Instruction stringlengths 14 778 | input_code stringlengths 0 4.24k | output_code stringlengths 1 5.44k |
|---|---|---|
Check if class already exists. Fix typo in keyword parameter. | (cl:in-package #:sicl-clos)
;;; The macro DEFINE-BUILT-IN-CLASS expands to a call to this
;;; function, and this function is used only in that situation. For
;;; that reason, we do not have to be particularly thorough about
;;; checking the validity of arguments.
;;;
;;; The argument DIRECT-SUPERCLASS-NAMES is a list... | (cl:in-package #:sicl-clos)
;;; The macro DEFINE-BUILT-IN-CLASS expands to a call to this
;;; function, and this function is used only in that situation. For
;;; that reason, we do not have to be particularly thorough about
;;; checking the validity of arguments.
;;;
;;; The argument DIRECT-SUPERCLASS-NAMES is a list... |
Make explicit the dependency on UIOP. | (in-package :asdf-user)
(asdf:defsystem #:ql-scm
:description "A Quicklisp extension that can pull from project SCMs directly."
:version (:read-file-form "version.lisp-expr")
:serial t
:depends-on (#:quicklisp)
:author "Eric Timmons <etimmons@mit.edu>"
:license "MIT"
:components ((:module "src"
... | (in-package :asdf-user)
(asdf:defsystem #:ql-scm
:description "A Quicklisp extension that can pull from project SCMs directly."
:version (:read-file-form "version.lisp-expr")
:serial t
:depends-on (#:quicklisp
(:feature (:not :asdf3) :uiop))
:author "Eric Timmons <etimmons@mit.edu>"
:license... |
Change DEFGENERIC IMPORT-RUCKSACK to DEFUN IMPORT-RUCKSACK to fix a compiler warning reported by Brad Beveridge. | (in-package :rucksack)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Import/export
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; The contents of a rucksack can be exported to a single file. The file will
;; contain enough information to recon... | (in-package :rucksack)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Import/export
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; The contents of a rucksack can be exported to a single file. The file will
;; contain enough information to recon... |
Add system dependency on wu-decimal | ;;;; grok-arch-hexagonal.asd
;;; The MIT License (MIT)
;;;
;;; Copyright (c) 2016 Michael J. Forster
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a copy
;;; of this software and associated documentation files (the "Software"), to deal
;;; in the Software without restriction, including ... | ;;;; grok-arch-hexagonal.asd
;;; The MIT License (MIT)
;;;
;;; Copyright (c) 2016 Michael J. Forster
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a copy
;;; of this software and associated documentation files (the "Software"), to deal
;;; in the Software without restriction, including ... |
Change to $ in a couple of places | (import extra/term (colored))
(defun print-error! (msg)
"Print an error messaage, MSG."
(unless (string? msg) (set! msg (pretty msg)))
(with (lines (string/split msg "\n" 1))
(print! (colored 31 (.. "[ERROR] " (car lines))))
(when (cadr lines) (print! (cadr lines)))))
(defun print-warning! (msg)
"Prin... | (import extra/term (colored))
(defun print-error! (msg)
"Print an error messaage, MSG."
(unless (string? msg) (set! msg (pretty msg)))
(with (lines (string/split msg "\n" 1))
(print! (colored 31 (.. "[ERROR] " (car lines))))
(when (cadr lines) (print! (cadr lines)))))
(defun print-warning! (msg)
"Prin... |
Support coercing stuff to FLOAT. | (in-package #:sys.int)
(define-condition unknown-coercion ()
((object :initarg :object
:reader unknown-coercion-object)
(type :initarg :type
:reader unknown-coercion-type))
(:report (lambda (condition stream)
(format stream "Don't know how to coerce ~S to type ~S."
... | (in-package #:sys.int)
(define-condition unknown-coercion ()
((object :initarg :object
:reader unknown-coercion-object)
(type :initarg :type
:reader unknown-coercion-type))
(:report (lambda (condition stream)
(format stream "Don't know how to coerce ~S to type ~S."
... |
Use an explicit asdf:perform :after method instead of :perform (load-op :after ...) | ;;;; -*- lisp -*-
(in-package :cl-user)
(defpackage :parenscript.system
(:use :cl :asdf))
(in-package :parenscript.system)
(defsystem :parenscript
:name "parenscript"
:author "Manuel Odendahl <manuel@bl0rg.net>"
:version "0"
:maintainer "Edward Marco Baringer <mb@bese.it>"
:licence "BSD"
:description ... | ;;;; -*- lisp -*-
(in-package :cl-user)
(defpackage :parenscript.system
(:use :cl :asdf))
(in-package :parenscript.system)
(defsystem :parenscript
:name "parenscript"
:author "Manuel Odendahl <manuel@bl0rg.net>"
:version "0"
:maintainer "Edward Marco Baringer <mb@bese.it>"
:licence "BSD"
:description ... |
Use proper argument order for IS. | (cl:defpackage #:macro-level_tests
(:use #:cl #:parachute)
(:import-from #:macro-level #:macro-level))
(cl:in-package #:macro-level_tests)
(define-test "main"
(is equal
(let ((alist nil))
(macro-level `(progn ,@(mapcar (lambda (var value)
(let ((var (intern... | (cl:defpackage #:macro-level_tests
(:use #:cl #:parachute)
(:import-from #:macro-level #:macro-level))
(cl:in-package #:macro-level_tests)
(define-test "main"
(is equal '((*a* . 1) (*b* . 2) (*c* . 3))
(let ((alist nil))
(macro-level `(progn ,@(mapcar (lambda (var value)
... |
Load a file containing the definition of the generic function CLASS-DIRECT-SUPERCLASSES. | (cl:in-package #:sicl-boot-phase2)
(defun ld (filename environment)
(format *trace-output* "Loading file ~a~%" filename)
(finish-output *trace-output*)
(sicl-extrinsic-environment:load-source-with-environments
(asdf:system-relative-pathname :sicl-boot-phase2 filename)
(sicl-boot-phase1:compilation-environm... | (cl:in-package #:sicl-boot-phase2)
(defun ld (filename environment)
(format *trace-output* "Loading file ~a~%" filename)
(finish-output *trace-output*)
(sicl-extrinsic-environment:load-source-with-environments
(asdf:system-relative-pathname :sicl-boot-phase2 filename)
(sicl-boot-phase1:compilation-environm... |
Return body result if string is not a string-stream. | ;;;;; TRE environment
;;;;; Copyright (c) 2005-2006,2008-2009 Sven Klose <pixel@copei.de>
(defmacro with-default-stream (nstr str &rest body)
"Set 'str' to *standard-output* if 'str' is T or create string-stream
if 'str' is NIL, evaluate 'body' and return the stream-string if 'str'
is NIL."
(with-gensym g
`(with... | ;;;;; TRE environment
;;;;; Copyright (c) 2005-2006,2008-2009 Sven Klose <pixel@copei.de>
(defmacro with-default-stream (nstr str &rest body)
"Set 'str' to *standard-output* if 'str' is T or create string-stream
if 'str' is NIL, evaluate 'body' and return the stream-string if 'str'
is NIL."
(with-gensym (g body-resu... |
Print one list of names of unused functions. | (fn warn-unused-functions ()
(!= (defined-functions)
(@ [hremove ! _]
(+ (hashkeys (used-functions))
(hashkeys (expander-macros (transpiler-macro-expander)))
(hashkeys (expander-macros (codegen-expander)))
*macros*))
(@ [!= (symbol-name _)
(| (tail? ! "_TREEXP")
... | (fn warn-unused-functions ()
(!= (defined-functions)
(@ [hremove ! _]
(+ (hashkeys (used-functions))
(hashkeys (expander-macros (transpiler-macro-expander)))
(hashkeys (expander-macros (codegen-expander)))
*macros*))
(!? (mapcan [!= (symbol-name _)
(& (no... |
Define system in package ASDF-USER. | (cl:in-package #:common-lisp-user)
(asdf:defsystem :clobber
:components
((:file "packages")
(:file "clobber" :depends-on ("packages"))
(:file "demo" :depends-on ("clobber"))
(:file "demo2" :depends-on ("clobber"))))
| (cl:in-package #:asdf-user)
(defsystem :clobber
:components
((:file "packages")
(:file "clobber" :depends-on ("packages"))
(:file "demo" :depends-on ("clobber"))
(:file "demo2" :depends-on ("clobber"))))
|
Add author and maintainer field. | (defpackage :info.isoraqathedh.acronyms.asdf
(:use #:cl #:asdf))
(in-package :info.isoraqathedh.acronyms.asdf)
(defsystem acronyms
:name "Acronym Expander"
:version "1.0.0"
:licence "MIT"
:description "A program that expands an acronym based on grammatical rules."
:serial t
:components ((:file "acronyms"... | (defpackage :info.isoraqathedh.acronyms.asdf
(:use #:cl #:asdf))
(in-package :info.isoraqathedh.acronyms.asdf)
(defsystem acronyms
:name "Acronym Expander"
:author "Isoraķatheð Zorethan <isoraqathedh.zorethan@gmail.com>"
:maintainer "Isoraķatheð Zorethan <isoraqathedh.zorethan@gmail.com>"
:version "1.0.0"
... |
Define mixin class for instructions with side effects. | (cl:in-package #:cleavir-ir)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Mixin classes for instructions according to successor count.
;;; Mixin class for instructions with no successors.
(defclass no-successors-mixin () ())
;;; Mixin class for instructions with a single successor.
(defclass... | (cl:in-package #:cleavir-ir)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Mixin classes for instructions according to successor count.
;;; Mixin class for instructions with no successors.
(defclass no-successors-mixin () ())
;;; Mixin class for instructions with a single successor.
(defclass... |
Tweak greeting and impl info. | (in-package :hunchentoot)
(format t "Am I alive??")
(format t "Dispatch ~A~%" *dispatch-table*)
(hunchentoot:define-easy-handler (say-yo :uri "/yo") (name)
(setf (hunchentoot:content-type*) "text/plain")
(progn
(format nil "Hey~@[ ~A~]!~%" name)
(format nil "~A ~A" (lisp-implementation-type) (lisp-implement... | (in-package :hunchentoot)
(format t "Am I alive??")
(format t "Dispatch ~A~%" *dispatch-table*)
(hunchentoot:define-easy-handler (say-yo :uri "/yo") (name)
(setf (hunchentoot:content-type*) "text/plain")
(format nil "Hey~@[ ~A~]! ~A ~A" name (lisp-implementation-type) (lisp-implementation-version)))
;(publish :p... |
Add documentation to the tuple class. | ;;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
;;;; Copyright (C) 2014 Varoun. P
;;;; 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, eith... | ;;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
;;;; Copyright (C) 2014 Varoun. P
;;;; 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, eith... |
Change default loglevel from :debug to :warn | ; Copyright 2017 James Fleming <james@electronic-quill.net>
;
; Licensed under the GNU General Public License
; - for details, see LICENSE.txt in the top-level directory
;;;; Logging infrastructure
;;; We only need something extremely simple
(in-package #:neo4cl)
(defvar *loglevels*
'(:crit 4
:critical ... | ; Copyright 2017 James Fleming <james@electronic-quill.net>
;
; Licensed under the GNU General Public License
; - for details, see LICENSE.txt in the top-level directory
;;;; Logging infrastructure
;;; We only need something extremely simple
(in-package #:neo4cl)
(defvar *loglevels*
'(:crit 4
:critical ... |
Update for latest bodge-ui changes | (bodge-util:define-package :cl-bodge.ui
(:nicknames :ge.ui)
(:use :cl :cl-bodge.engine :bodge-util :cl-bodge.graphics
:cl-bodge.canvas :cl-bodge.resources :claw)
(:reexport-from :bodge-ui
#:defwindow
#:on-window-close
#:horizontal-layout
... | (bodge-util:define-package :cl-bodge.ui
(:nicknames :ge.ui)
(:use :cl :cl-bodge.engine :bodge-util :cl-bodge.graphics
:cl-bodge.canvas :cl-bodge.resources :claw)
(:reexport-from :bodge-ui
#:defpanel
#:on-window-close
#:horizontal-layout
... |
Define ASDF system in package ASDF-USER. | (cl:in-package #:common-lisp-user)
(asdf:defsystem :cleavir-mir
:depends-on (:cleavir-ir)
:serial t
:components
((:file "general")
(:file "graphviz-drawing")))
| (cl:in-package #:asdf-user)
(defsystem :cleavir-mir
:depends-on (:cleavir-ir)
:serial t
:components
((:file "general")
(:file "graphviz-drawing")))
|
Add some rough error handling to REDIRECTING-JUMP | (in-package #:jumpotron)
(defclass redirecting-jump (jump)
((target :initarg :target
:initform (error "A jump needs a target")
:reader target
:documentation "FORMAT-string that will consume the words in the
query to construct a url to redirect the user to.")))
(defmethod jump ((jump... | (in-package #:jumpotron)
(defclass redirecting-jump (jump)
((target :initarg :target
:initform (error "A jump needs a target")
:reader target
:documentation "FORMAT-string that will consume the words in the
query to construct a url to redirect the user to.")))
(defmethod jump ((jump... |
Add CLISP support to METHOD-COMBINATION-EXPAND. | (in-package #:method-combination-utilities)
(defun method-combination-expander-function (method-combination)
#+ccl (cdr (ccl::method-combination-expander method-combination))
#-ccl (error "this function is not available on ~A"
(lisp-implementation-type)))
(defun method-combination-options (method-c... | (in-package #:method-combination-utilities)
(defun method-combination-expander-function (method-combination)
#+ccl (cdr (ccl::method-combination-expander method-combination))
#+clisp (clos::method-combination-expander method-combination)
#-(or ccl clisp)
(error "this function is not available on ~A" (lisp-impl... |
Use QL-DIST:ENSURE-INSTALLED to make sure quicklisp's slime is installed regardless of whether another swank is visible. | ;;;; slime-helper.lisp
(defpackage #:quicklisp-slime-helper
(:use #:cl)
(:export #:install)
(:shadowing-import-from #:alexandria
#:copy-file)
(:shadowing-import-from #:ql-setup
#:qmerge))
(in-package #:quicklisp-slime-helper)
(defun install ()
(let ((sour... | ;;;; slime-helper.lisp
(defpackage #:quicklisp-slime-helper
(:use #:cl)
(:export #:install)
(:shadowing-import-from #:alexandria
#:copy-file)
(:shadowing-import-from #:ql-dist
#:ensure-installed
#:find-system)
(:shadowing-import-fr... |
Load a file containing the definition of the class REAL-CLASS. | (cl:in-package #:sicl-boot)
(defun create-bridge-classes (boot)
(let ((c (c1 boot))
(r (r2 boot)))
(ld "../CLOS/t-defclass.lisp" c r)
(ld "../CLOS/standard-object-defclass.lisp" c r)
(ld "../CLOS/metaobject-defclass.lisp" c r)
(ld "../CLOS/specializer-defclass.lisp" c r)
(ld "../CLOS/class-defcl... | (cl:in-package #:sicl-boot)
(defun create-bridge-classes (boot)
(let ((c (c1 boot))
(r (r2 boot)))
(ld "../CLOS/t-defclass.lisp" c r)
(ld "../CLOS/standard-object-defclass.lisp" c r)
(ld "../CLOS/metaobject-defclass.lisp" c r)
(ld "../CLOS/specializer-defclass.lisp" c r)
(ld "../CLOS/class-defcl... |
Define ASDF system in package ASDF-USER. | ;;;; Copyright (c) 2008 - 2013
;;;;
;;;; Robert Strandh (robert.strandh@gmail.com)
;;;;
;;;; all rights reserved.
;;;;
;;;; Permission is hereby granted to use this software for any
;;;; purpose, including using, modifying, and redistributing it.
;;;;
;;;; The software is provided "as-is" with no warranty. The u... | ;;;; Copyright (c) 2008 - 2013
;;;;
;;;; Robert Strandh (robert.strandh@gmail.com)
;;;;
;;;; all rights reserved.
;;;;
;;;; Permission is hereby granted to use this software for any
;;;; purpose, including using, modifying, and redistributing it.
;;;;
;;;; The software is provided "as-is" with no warranty. The u... |
Make use of iterative mapping function. | (cl:in-package #:cleavir-ir)
(defgeneric specialize (instruction implementation processor os))
(defun hir-to-mir (initial-instruction implementation processor os)
;; Gather up all instructions in a table
(let ((table (make-hash-table :test #'eq)))
(labels ((traverse (instruction)
(unless (gethash inst... | (cl:in-package #:cleavir-ir)
(defgeneric specialize (instruction implementation processor os))
(defun hir-to-mir (initial-instruction implementation processor os)
(let ((all-instructions '()))
;; Gather up all instructions in a list.
(map-instructions
(lambda (instruction)
(push instruction all-... |
Introduce missing dependency on split-sequence. | (defsystem "petalisp.ir"
:author "Marco Heisig <marco.heisig@fau.de>"
:license "AGPLv3"
:depends-on
("alexandria"
"ucons"
"priority-queue"
"petalisp.utilities"
"petalisp.core")
:serial t
:components
((:file "packages")
(:file "device")
(:file "ir")
(:file "ir-checker")
(:file "ir... | (defsystem "petalisp.ir"
:author "Marco Heisig <marco.heisig@fau.de>"
:license "AGPLv3"
:depends-on
("alexandria"
"ucons"
"priority-queue"
"split-sequence"
"petalisp.utilities"
"petalisp.core")
:serial t
:components
((:file "packages")
(:file "device")
(:file "ir")
(:file "ir-che... |
Define method on INTERPRET-AST specialized to CONSTANT-AST. | (cl:in-package #:cleavir-ast-interpreter)
(defgeneric interpret-ast (ast static-env dynamic-env))
(defun interpret (ast)
(let ((static-env (list (make-hash-table :test #'eq)))
(dynamic-env '()))
(interpret-ast ast static-env dynamic-env)))
| (cl:in-package #:cleavir-ast-interpreter)
(defgeneric interpret-ast (ast static-env dynamic-env))
(defun interpret (ast)
(let ((static-env (list (make-hash-table :test #'eq)))
(dynamic-env '()))
(interpret-ast ast static-env dynamic-env)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;... |
Make CALCULATE-DIGEST work for all CL implementations. | ;;;; Depends on the MD5 library
(in-package :cleric)
(defun calculate-digest (challenge cookie)
(md5:md5sum-string (format nil "~a~a" cookie challenge)))
| ;;;; Depends on the MD5 library
(in-package :cleric)
(defun calculate-digest (challenge cookie)
(let ((input (format nil "~a~a" cookie challenge)))
#+(or :cmu :sbcl (and :lispworks (not :lispworks4)) :ccl :allegro)
(md5:md5sum-string input)
#-(or :cmu :sbcl (and :lispworks (not :lispworks4)) :ccl :alleg... |
Modify add-string to accept attributes and colors | (in-package :de.anvi.croatoan)
(defun add-string (window string &key y x n)
"Add the unrendered string to the window.
If n is given, write at most n chars from the string. If n is -1, as
many chars will be added that will fit on the line.
If the coordinates y and x are given, move to the destination first
and then... | (in-package :de.anvi.croatoan)
;; first attempt to create add-string with attributes and colors
;; without adding a complex-string type first.
(defun add-string (window string &key attributes color-pair y x n)
"Add the unrendered string to the window.
If n is given, write at most n chars from the string. If n is -1... |
Remove unique number. We will use a different technique. | (cl:in-package #:cleavir-simple-value-numbering)
;;; We attribute a unique number to each value designator. That way,
;;; we can keep the value designators in a partition sorted by the
;;; unique number which makes operations on partitions faster.
;;;
;;; This variable should be bound to some small integer at the
;;;... | (cl:in-package #:cleavir-simple-value-numbering)
;;; We use instances of this class to designate values.
(defclass value-designator ()
())
;;; This variable holds and EQ hash table mapping constants to value
;;; designators.
(defvar *constant-designators*)
(defun constant-designator (constant)
(let ((result (get... |
Use cl-ppcre in the knight-owl package | ;;;; packagedef.lisp
;;;; Author: Elliot Penson
(defpackage :knight-owl
(:use :common-lisp))
| ;;;; packagedef.lisp
;;;; Author: Elliot Penson
(ql:quickload "cl-ppcre")
(defpackage :knight-owl
(:use :common-lisp :cl-ppcre))
|
Add :description to system definition. | ;;;; quickproject.asd
(asdf:defsystem #:quickproject
:serial t
:components ((:file "package")
(:file "quickproject")))
| ;;;; quickproject.asd
(asdf:defsystem #:quickproject
:description "Creates the skeleton of a new Common Lisp project"
:serial t
:components ((:file "package")
(:file "quickproject")))
|
Create the "generate" function and use it. | (in-package #:deb-package)
(ftype get-item list symbol list)
(defun get-item (list keyword)
(rest
(find-if #'(lambda (item)
(getf item keyword))
list)))
(defmacro define-deb-package (name &body forms)
`(let ((name (string-downcase (symbol-name ',name)))
(changelog-entries
... | (in-package #:deb-package)
(ftype get-item list symbol list)
(defun get-item (list keyword)
(rest
(find-if #'(lambda (item)
(getf item keyword))
list)))
(defmacro define-deb-package (name &body forms)
`(let ((changelog-entries
(make-array
,(length (get-item form... |
Reorder calls and remove calls that are no longer needed. | (cl:in-package #:sicl-boot)
(defun fill-boot (boot)
(customize-c1 boot)
(customize-r1 boot)
(phase1 boot)
(customize-r2 boot)
(customize-c2 boot)
(phase2 boot)
(phase3 boot))
(defmethod initialize-instance :after ((boot boot) &key &allow-other-keys)
(fill-boot boot))
| (cl:in-package #:sicl-boot)
(defun fill-boot (boot)
(customize-c1 boot)
(customize-r2 boot)
(phase1 boot)
(phase2 boot)
(phase3 boot))
(defmethod initialize-instance :after ((boot boot) &key &allow-other-keys)
(fill-boot boot))
|
Add dependencies to DEFSYSTEM definition. |
(defsystem :named-readtables
:description "Library that creates a namespace for named readtable akin to the namespace of packages."
:author "Tobias C. Rittweiler <trittweiler@common-lisp.net>"
:version "1.0"
:licence "BSD"
:serial t
:components
((:file "package")
(:file "destructure-case")
(:file "... |
(defsystem :named-readtables
:description "Library that creates a namespace for named readtable akin to the namespace of packages."
:author "Tobias C. Rittweiler <trittweiler@common-lisp.net>"
:version "1.0 (unpublished so far)"
:licence "BSD"
:serial t
:components
((:file "package")
(:file "utils" ... |
Concatenate from leaves to root to use less heap. | ;;;;; TRE environment
;;;;; Copyright (c) 2008-2009 Sven Klose <pixel@copei.de>
(defun concat-stringtree (&rest x)
(apply #'string-concat (tree-list x)))
| ; tré – Copyright (c) 2008–2009,2016 Sven Klose <pixel@copei.de>
(defun %concat-stringtree (x)
(& x
(? (string? x)
x
(apply #'string-concat (@ #'%concat-stringtree x)))))
(defun concat-stringtree (&rest x)
(%concat-stringtree x))
|
Test qsort with and without getter | (test-case 'test-case-qsort
'((test test-qsort
((assert-equal '() (qsort '()))
(assert-equal '(1) (qsort '(1)))
(assert-equal '(1 2) (qsort '(1 2)))
(assert-equal '(1 2 3) (qsort '(3 1 2)))
(assert-equal '(1 2 ... | (test-case 'test-case-qsort
'((test test-qsort-without-getter
((assert-equal '() (qsort '()))
(assert-equal '(1) (qsort '(1)))
(assert-equal '(1 2) (qsort '(1 2)))
(assert-equal '(1 2 3) (qsort '(3 1 2)))
(asse... |
Define system in package ASDF-USER. | (in-package #:cl-user)
(asdf:defsystem :sicl-loop-test
:depends-on (:sicl-loop-support)
:serial t
:components
((:file "test-packages")
(:file "loop-defmacro")
(:file "loop-test")
(:file "simple-loop")
(:file "loop1")
(:file "loop2")
(:file "loop3")
(:file "loop4")
(:file "loop5")
(:f... | (in-package #:asdf-user)
(defsystem :sicl-loop-test
:depends-on (:sicl-loop-support)
:serial t
:components
((:file "test-packages")
(:file "loop-defmacro")
(:file "loop-test")
(:file "simple-loop")
(:file "loop1")
(:file "loop2")
(:file "loop3")
(:file "loop4")
(:file "loop5")
(:file... |
Package fix to rst plugin. | (eval-when (:compile-toplevel :load-toplevel)
(ql:quickload 'docutils))
(defpackage :coleslaw-rst
(:use :cl)
(:import-from :coleslaw #:render-content)
(:import-from :cl-docutils #:read-rst
#:write-html)
(:export #:enable))
(in-package :coleslaw-rst)
(defmethod render-content (t... | (eval-when (:compile-toplevel :load-toplevel)
(ql:quickload 'docutils))
(defpackage :coleslaw-rst
(:use :cl)
(:import-from :coleslaw #:render-content)
(:import-from :docutils #:read-rst
#:write-html)
(:export #:enable))
(in-package :coleslaw-rst)
(defmethod render-content (text (f... |
Use explicit package marker with IN-PACKAGE. | (in-package #:sicl-global-environment)
(defconstant nil 'nil)
(defconstant t 't)
| (cl:in-package #:sicl-global-environment)
(defconstant nil 'nil)
(defconstant t 't)
|
Add method on ROTATE-LEFT specialized to NODE. | (cl:in-package #:clump-binary-tree)
(defgeneric rotate-left (tree))
(defgeneric rotate-right (tree))
| (cl:in-package #:clump-binary-tree)
(defgeneric rotate-left (tree))
(defgeneric rotate-right (tree))
(defmethod rotate-left ((tree node))
(when (null (right tree))
(error 'right-subtree-must-be-non-nil :tree tree))
|
Make the system depend on the internationalization system. | (in-package #:common-lisp-user)
(asdf:defsystem cleavir-code-utilities
:serial t
:components
((:file "packages")
(:file "conditions")
(:file "argcount")
(:file "form")
(:file "general")
(:file "declarations")
(:file "lambda-lists")
(:file "destructuring")))
| (in-package #:common-lisp-user)
(asdf:defsystem cleavir-code-utilities
:depends-on (:cleavir-internationalization)
:serial t
:components
((:file "packages")
(:file "conditions")
(:file "argcount")
(:file "form")
(:file "general")
(:file "declarations")
(:file "lambda-lists")
(:file "destru... |
Define function VALIDATE-SUPERCLASS in run-time environment R2, always returning true. | (cl:in-package #:sicl-boot)
(defun customize-r2 (boot)
(let ((c (c1 boot))
(r (r2 boot)))
(define-make-instance boot)
(define-direct-slot-definition-class boot)
(define-find-class boot)
(ld "../CLOS/ensure-generic-function-using-class-support.lisp" c r)))
| (cl:in-package #:sicl-boot)
(defun define-validate-superclass (boot)
(setf (sicl-genv:fdefinition 'sicl-clos:validate-superclass (r2 boot))
(constantly t)))
(defun customize-r2 (boot)
(let ((c (c1 boot))
(r (r2 boot)))
(define-make-instance boot)
(define-direct-slot-definition-class boot)
(define-fi... |
Use explicit package prefix for IN-PACKAGE. | (in-package #:asdf-user)
(defsystem #:sicl-additional-types
:components
((:file "packages")
(:file "types" :depends-on ("packages"))))
| (cl:in-package #:asdf-user)
(defsystem #:sicl-additional-types
:components
((:file "packages")
(:file "types" :depends-on ("packages"))))
|
Load more files containing definitions of class accessors. | (cl:in-package #:sicl-boot)
(defun create-bridge-class-accessors (boot)
(let ((c (c2 boot))
(r (r3 boot)))
(ld "../CLOS/method-function-defgeneric.lisp" c r)))
| (cl:in-package #:sicl-boot)
(defun create-bridge-class-accessors (boot)
(let ((c (c2 boot))
(r (r3 boot)))
(ld "../CLOS/method-function-defgeneric.lisp" c r)
(ld "../CLOS/method-generic-function-defgeneric.lisp" c r)
(ld "../CLOS/method-lambda-list-defgeneric.lisp" c r)
(ld "../CLOS/method-qualifiers-defgen... |
Add package nickname :clu as shortcut. | (in-package :cl-user)
(uiop/package:define-package :clutils/all
(:nicknames :clutils)
(:use :cl)
(:use-reexport
:clutils/functional
:clutils/math
:clutils/strings
:clutils/macros
:clutils/lists
:clutils/sequences
:clutils/packages
:clutils/project))
| (in-package :cl-user)
(uiop/package:define-package :clutils/all
(:nicknames :clutils :clu)
(:use :cl)
(:use-reexport
:clutils/functional
:clutils/math
:clutils/strings
:clutils/macros
:clutils/lists
:clutils/sequences
:clutils/packages
:clutils/project))
|
Define system in package ASDF-USER. | (cl:in-package #:common-lisp-user)
(asdf:defsystem #:sicl-hir-to-mir
:depends-on (:cleavir-hir-to-mir
:cleavir-processor-x86-64
:sicl-target-sicl)
:serial t
:components
((:file "packages")
(:file "general")
(:file "cons")
(:file "integer")
(:file "environment-related-instructions"))... | (cl:in-package #:asdf-user)
(defsystem #:sicl-hir-to-mir
:depends-on (:cleavir-hir-to-mir
:cleavir-processor-x86-64
:sicl-target-sicl)
:serial t
:components
((:file "packages")
(:file "general")
(:file "cons")
(:file "integer")
(:file "environment-related-instructions")))
|
Fix invalid asdf version string and contact email | ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; Base: 10; indent-tabs-mode: nil -*-
(asdf:defsystem glop
:license "MIT"
:version "git"
:description "Direct FFI bindings for OpenGL window and context management"
:author "Morgan Veyret <patzy at appart kicks-ass net>"
:depends-on (:cffi)
:components
((:modu... | ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; Base: 10; indent-tabs-mode: nil -*-
(asdf:defsystem glop
:license "MIT"
:version "0.1.0"
:description "Direct FFI bindings for OpenGL window and context management"
:author "Morgan Veyret <patzy at oxyde dot org>"
:depends-on (:cffi)
:components
((:module "s... |
Define new class 3-NODE for the nodes with 3 children of the 2-3 tree. | (cl:in-package #:clump-2-3-tree)
(defclass tree ()
((%contents :initform nil :accessor contents)))
(defclass node ()
((%parent :initarg :parent :accessor parent)))
(defclass leaf (node)
((%contents :initarg :contents :accessor contents)))
(defclass 2-node (node)
((%left :initarg :left :accessor left)
(%r... | (cl:in-package #:clump-2-3-tree)
(defclass tree ()
((%contents :initform nil :accessor contents)))
(defclass node ()
((%parent :initarg :parent :accessor parent)))
(defclass leaf (node)
((%contents :initarg :contents :accessor contents)))
(defclass 2-node (node)
((%left :initarg :left :accessor left)
(%r... |
Add copyright dates and license statement. | (cl:in-package #:sicl-clos)
(defclass slot-definition (metaobject)
((%name
:initarg :name
:reader slot-definition-name)
(%allocation
:initarg :allocation
:initform :instance
:reader slot-definition-allocation)
(%type
:initarg :type
:initform t
:reader slot-definition-type)
... | ;;;; Copyright (c) 2013 - 2015
;;;;
;;;; Robert Strandh (robert.strandh@gmail.com)
;;;;
;;;; All rights reserved.
;;;;
;;;; Redistribution and use in source and binary forms, with or
;;;; without modification, are permitted provided that the following
;;;; conditions are met:
;;;;
;;;; 1. Redistributions of source ... |
Use Nyxt specific site instead of Atlas. | ;;;; SPDX-FileCopyrightText: Atlas Engineer LLC
;;;; SPDX-License-Identifier: BSD-3-Clause
(in-package :cl-user)
(uiop:define-package download-manager/tests
(:use #:common-lisp #:prove)
(:import-from #:download-manager))
(in-package :download-manager/tests)
(plan nil)
(subtest "Simple HTTP/HTTPS downloads"
(le... | ;;;; SPDX-FileCopyrightText: Atlas Engineer LLC
;;;; SPDX-License-Identifier: BSD-3-Clause
(in-package :cl-user)
(uiop:define-package download-manager/tests
(:use #:common-lisp #:prove)
(:import-from #:download-manager))
(in-package :download-manager/tests)
(plan nil)
(subtest "Simple HTTP/HTTPS downloads"
(le... |
Allow for :SLOT-DEFINITION initarg by adding &allow-other-keys. | (cl:in-package #:sicl-clos)
;;; The method defined here is meant to implement the behavior
;;; described in "Initialization of Method Metaobjects" in the AMOP.
;;; FIXME: Here, I specialize on METHOD, but check whether the
;;; specialization should be reserved for STANDARD-METHOD instead.
(defmethod initialize-insta... | (cl:in-package #:sicl-clos)
;;; The method defined here is meant to implement the behavior
;;; described in "Initialization of Method Metaobjects" in the AMOP.
;;; FIXME: Here, I specialize on METHOD, but check whether the
;;; specialization should be reserved for STANDARD-METHOD instead.
(defmethod initialize-insta... |
Define STANDARD-FUNCTION and explain why it is defined that way in comment. | (in-package #:sicl-clos)
(define-built-in-class sequence (t)
())
(define-built-in-class list (sequence)
())
(define-built-in-class symbol ()
((%name :initarg :name :reader symbol-name)
(%package :initarg :package :reader symbol-package)))
(define-built-in-class null (symbol list)
())
| (in-package #:sicl-clos)
;;; We need for funcallable standard objects and standard functions to
;;; be called the same way. There is a slight difficulty in order for
;;; that to happen, though. When a funcallable standard object is
;;; allocated, since it is a standard object, two additional cells are
;;; allocated ... |
Define system in package ASDF-USER. | (cl:in-package #:common-lisp-user)
(asdf:defsystem :sicl-type
:components
((:file "packages")))
| (cl:in-package #:asdf-user)
(defsystem :sicl-type
:components
((:file "packages")))
|
Remove some now-spurious exports, export conditions, use uninterned symbols | ;;;; package.lisp
(defpackage #:sdl2
(:use #:cl #:alexandria #:cffi)
(:export :sys-video
:sys-audio
:sys-timer
:sys-joystick
:sys-gamecontroller ; implies joystick
:noparachute
:everything
:init
:quit
:create-window
... | ;;;; package.lisp
(defpackage #:sdl2
(:use #:cl #:alexandria #:cffi)
(:export ;; API
#:init
#:quit
#:create-window
#:destroy-window
;; Conditions
#:sdl-error))
(defpackage #:sdl2-ffi)
|
Define ASDF system in package ASDF-USER. | (in-package #:common-lisp-user)
(asdf:defsystem :sicl-read
:components
((:file "packages" :depends-on ())
(:file "float" :depends-on ("packages"))
(:file "read" :depends-on ("packages" "float"))))
| (in-package #:asdf-user)
(defsystem :sicl-read
:components
((:file "packages" :depends-on ())
(:file "float" :depends-on ("packages"))
(:file "read" :depends-on ("packages" "float"))))
|
Add description to .asd file. | ;;
;; Copyright (c) 2010, Peter Seibel. All rights reserved.
;;
(defsystem monkeylib-markup-xml
:name "monkeylib-markup-xml"
:components
((:file "packages")
(:file "xml" :depends-on ("packages")))
:depends-on
(:com.gigamonkeys.macro-utilities
:com.gigamonkeys.utilities
:com.gigamonkeys.foo))
| ;;
;; Copyright (c) 2010, Peter Seibel. All rights reserved.
;;
(defsystem monkeylib-markup-xml
:name "monkeylib-markup-xml"
:description "Library for generating XML from Markup-formatted text."
:components
((:file "packages")
(:file "xml" :depends-on ("packages")))
:depends-on
(:com.gigamonkeys.macro-u... |
Make lambda exoression in (POSTPROCESSOR). | ; tré – Copyright (c) 2005–2014 Sven Michael Klose <pixel@copei.de>
(defun tre-expansions (x)
(backquote-expand (quasiquote-expand (macroexpand (dot-expand x)))))
(defun expr2cl (x) (make-lambdas (tre-expansions x)))
(defun file2cl (pathname) (expr2cl (read-file pathname)))
(defun files2cl (... | ; tré – Copyright (c) 2005–2014 Sven Michael Klose <pixel@copei.de>
(defun cl-expex-initializer (ex)
(= (expex-argument-filter ex) #'identity
(expex-setter-filter ex) #'identity))
(defun cl-frontend (x)
(aprog1 (transpiler-macroexpand (quasiquote-expand (dot-expand x)))
(fake-expression-expand (fake-pl... |
Load a file containing the definition of SLOT-DEFINITION. | (cl:in-package #:sicl-boot)
(defun create-bridge-classes (boot)
(let ((c (c1 boot))
(r (r2 boot)))
(ld "../CLOS/t-defclass.lisp" c r)
(ld "../CLOS/standard-object-defclass.lisp" c r)
(ld "../CLOS/metaobject-defclass.lisp" c r)
(ld "../CLOS/method-combination-defclass.lisp" c r)
(ld "../CLOS/spec... | (cl:in-package #:sicl-boot)
(defun create-bridge-classes (boot)
(let ((c (c1 boot))
(r (r2 boot)))
(ld "../CLOS/t-defclass.lisp" c r)
(ld "../CLOS/standard-object-defclass.lisp" c r)
(ld "../CLOS/metaobject-defclass.lisp" c r)
(ld "../CLOS/method-combination-defclass.lisp" c r)
(ld "../CLOS/slot... |
Load new file with definition of ENSURE-GENERIC-FUNCTION. | (cl:in-package #:sicl-extrinsic-hir-compiler)
(defun rp (filename)
(asdf:system-relative-pathname :sicl-extrinsic-hir-compiler filename))
(load (rp "../../Evaluation-and-compilation/lambda.lisp"))
(load (rp "../../Environment/multiple-value-bind.lisp"))
(load (rp "../../Data-and-control-flow/setf.lisp"))
(load (rp ... | (cl:in-package #:sicl-extrinsic-hir-compiler)
(defun rp (filename)
(asdf:system-relative-pathname :sicl-extrinsic-hir-compiler filename))
(load (rp "../../Evaluation-and-compilation/lambda.lisp"))
(load (rp "../../Environment/multiple-value-bind.lisp"))
(load (rp "../../Data-and-control-flow/setf.lisp"))
(load (rp ... |
Complete the renameing of brazilian portuguese | (in-package :local-time-locale)
(defmethod make-locale ((class (eql :pt-bz)))
(make-instance 'locale-pt
:first-day-of-week 0)) | (in-package :local-time-locale)
(defmethod make-locale ((class (eql :pt-br)))
(make-instance 'locale-pt
:first-day-of-week 0)) |
Modify some code for metap changed | ;;;; cl-singleton-mixin.lisp
;;;;
;;;; Copyright 2015 hipeta (rhipeta@gmail.com)
;;;;
;;;; This software is released under the MIT License.
;;;; http://opensource.org/licenses/mit-license.php
(in-package :cl-user)
(defpackage cl-singleton-mixin
(:use :cl)
(:export :singleton-class
:singleton-mixin
... | ;;;; cl-singleton-mixin.lisp
;;;;
;;;; Copyright 2015 hipeta (rhipeta@gmail.com)
;;;;
;;;; This software is released under the MIT License.
;;;; http://opensource.org/licenses/mit-license.php
(in-package :cl-user)
(defpackage cl-singleton-mixin
(:use :cl)
(:export :singleton-class
:singleton-mixin
... |
Split tests into tests and create comparison report | ;;; -*- Mode: Lisp; package: CL-USER; Syntax: Common-lisp; Base: 10 -*-
#|
|#
(in-package #:common-lisp-user)
(defpackage #:cl-markdown-test-system (:use #:cl #:asdf))
(in-package #:cl-markdown-test-system)
(defsystem cl-markdown-test
:version "0.1"
:author "Gary Warren King <gwking@metabang.com>"
:maintaine... | ;;; -*- Mode: Lisp; package: CL-USER; Syntax: Common-lisp; Base: 10 -*-
(in-package #:common-lisp-user)
(defpackage #:cl-markdown-test-system (:use #:cl #:asdf))
(in-package #:cl-markdown-test-system)
(defsystem cl-markdown-test
:version "0.1"
:author "Gary Warren King <gwking@metabang.com>"
:maintainer "Gary ... |
Make petalisp.utilties depend on alexandria. | (defsystem "petalisp.utilities"
:author "Marco Heisig <marco.heisig@fau.de>"
:license "AGPLv3"
:depends-on ()
:serial t
:components
((:file "packages")
(:file "identical")
(:file "memoization")
(:file "extended-euclid")
(:file "define-method-pair")
(:file "define-class-predicate")
(:file... | (defsystem "petalisp.utilities"
:author "Marco Heisig <marco.heisig@fau.de>"
:license "AGPLv3"
:depends-on ("alexandria")
:serial t
:components
((:file "packages")
(:file "identical")
(:file "memoization")
(:file "extended-euclid")
(:file "define-method-pair")
(:file "define-class-predicate... |
Remove "M" from revision number. | ;;;;; tré – Copyright (c) 2009,2011–2012 Sven Michael Klose <pixel@copei.de>
(defvar *tre-revision*
,(with-open-file in (open "_current-version" :direction 'input)
(let l (string-list (read-line in))
(list-string (subseq l
(!? (position #\: l)
... | ;;;;; tré – Copyright (c) 2009,2011–2012 Sven Michael Klose <pixel@copei.de>
(defvar *tre-revision*
,(with-open-file in (open "_current-version" :direction 'input)
(let l (string-list (read-line in))
(list-string
(alet (subseq l
(!? (position #\: l)
... |
Make `alist` the first parameter of all the alist handling functions | (in-package :cl-user)
(defpackage :nellie.alists
(:use :cl)
(:nicknames #:alists)
(:export #:alist-get
#:alist-get-str
#:alist-set
#:alist-update
#:alist-merge))
(in-package :nellie.alists)
(defun alist-get (key alist)
(cdr (assoc key alist)))
(defun alist-get-str ... | (in-package :cl-user)
(defpackage :nellie.alists
(:use :cl)
(:nicknames #:alists)
(:export #:alist-get
#:alist-get-str
#:alist-set
#:alist-update
#:alist-merge))
(in-package :nellie.alists)
(defun alist-get (alist key &key (test #'eql))
(cdr (assoc key alist :test t... |
Load file containing definition of class METAOBJECT. | (cl:in-package #:sicl-boot-phase1)
(defun ld (filename environment)
(format *trace-output* "Loading file ~a~%" filename)
(finish-output *trace-output*)
(sicl-extrinsic-environment:load-source-with-environments
filename (compilation-environment environment) environment))
(defun fill-environment (environment)
... | (cl:in-package #:sicl-boot-phase1)
(defun ld (filename environment)
(format *trace-output* "Loading file ~a~%" filename)
(finish-output *trace-output*)
(sicl-extrinsic-environment:load-source-with-environments
filename (compilation-environment environment) environment))
(defun fill-environment (environment)
... |
Fix name of utils.lisp in the asd | ;;;; tutorial-builder.asd
(asdf:defsystem #:tutorial-builder
:serial t
:description "A library for presenting md files as tutorials."
:author "Matt Niemeir <matt.niemeir@gmail.com>"
:license "BSD 2-clause"
:depends-on (#:lazy-susan
#:dishes
#:uiop
#:alexandria
... | ;;;; tutorial-builder.asd
(asdf:defsystem #:tutorial-builder
:serial t
:description "A library for presenting md files as tutorials."
:author "Matt Niemeir <matt.niemeir@gmail.com>"
:license "BSD 2-clause"
:depends-on (#:lazy-susan
#:dishes
#:uiop
#:alexandria
... |
Fix typo in system description | (asdf:defsystem cl-rfc3339
:author "Gregory Tod <lisp@gtod.net>"
:version "0.1.0"
:license "MIT"
:description "Canonicalize time formats to a specifc RFC 3339 compliant string."
:depends-on (#:local-time)
:components ((:file "package")
(:file "rfc3339")))
| (asdf:defsystem cl-rfc3339
:author "Gregory Tod <lisp@gtod.net>"
:version "0.1.0"
:license "MIT"
:description "Canonicalize time formats to a specific RFC 3339 compliant string."
:depends-on (#:local-time)
:components ((:file "package")
(:file "rfc3339")))
|
Define function in R1, but operate on R2. | (cl:in-package #:sicl-boot)
(defun define-ensure-generic-function-r1 (boot)
(setf (sicl-genv:fdefinition 'ensure-generic-function (r1 boot))
(lambda (function-name &rest arguments)
(let ((args (copy-list arguments)))
(loop while (remf args :environment))
(if (sicl-genv:fboundp function-name (r1 boot))
... | (cl:in-package #:sicl-boot)
;;; We define a special version of ENSURE-GENERIC-FUNCTION in the
;;; run-time environment R1. While the function is defined in the
;;; run-time environment R1, it operates on the run-time environment
;;; R2. This version checks whether there is already a function named
;;; FUNCTION-NAME ... |
Remove Ironclad from system def | ;;;; bit-smasher.asd
;;;; Copyright (c) 2014--2015, "the Phoeron" Colin J.E. Lupton <//thephoeron.com>
;;;; See LICENSE for additional information.
(in-package :cl-user)
(defpackage bit-smasher-asd
(:use :cl :asdf)
(:export #:*bit-smasher-version*))
(in-package :bit-smasher-asd)
(defparameter *bit-smasher-vers... | ;;;; bit-smasher.asd
;;;; Copyright (c) 2014--2015, "the Phoeron" Colin J.E. Lupton <//thephoeron.com>
;;;; See LICENSE for additional information.
(in-package :cl-user)
(defpackage bit-smasher-asd
(:use :cl :asdf)
(:export #:*bit-smasher-version*))
(in-package :bit-smasher-asd)
(defparameter *bit-smasher-vers... |
Rename in preparation for a TWO-SUCCESSORS-TRANSFER function. | (cl:in-package #:cleavir-type-inference)
(defgeneric transfer (instruction input-bag))
(defmethod transfer (instruction input-bag)
(loop with result = input-bag
for output in (cleavir-ir:outputs instruction)
when (typep output 'cleavir-ir:lexical-location)
do (setf result (update output t result))
finally (re... | (cl:in-package #:cleavir-type-inference)
(defgeneric one-successor-transfer (instruction input-bag))
(defmethod one-successor-transfer (instruction input-bag)
(loop with result = input-bag
for output in (cleavir-ir:outputs instruction)
when (typep output 'cleavir-ir:lexical-location)
do (setf result (update ou... |
Allow calls to unknown functions. | ;;;; tré - Copyright (c) 2011 Sven Klose <pixel@copei.de>
(defun function-arguments (fun)
(awhen fun.__source
!.))
(defun function-body (fun)
(awhen fun.__source
.!))
| ;;;; tré - Copyright (c) 2011 Sven Klose <pixel@copei.de>
(defun function-arguments (fun)
(? fun
(aif fun.__source
!.
'(&rest unknown-args))
'(&rest unknown-args)))
(defun function-body (fun)
(awhen fun.__source
.!))
|
Remove the hcat.lisp reference (for now). | (in-package :cl-user)
(defpackage :nellie.asd
(:use :cl :asdf))
(in-package :nellie.asd)
(asdf:defsystem #:nellie
:serial t
:description "Away from the circus"
:version "0.1"
:author "Mike Ivanov"
:license "LGPLv3"
:depends-on (:iterate :drakma :flexi-streams :cl-ppcre :cl-json
:getopt :... | (in-package :cl-user)
(defpackage :nellie.asd
(:use :cl :asdf))
(in-package :nellie.asd)
(asdf:defsystem #:nellie
:serial t
:description "Away from the circus"
:version "0.1"
:author "Mike Ivanov"
:license "LGPLv3"
:depends-on (:iterate :drakma :flexi-streams :cl-ppcre :cl-json
:getopt :... |
Add qualifiers to DEFGLOBAL example. | #|
This file is a part of cl-cuda project.
Copyright (c) 2012 Masayuki Takagi (kamonama@gmail.com)
|#
(in-package :cl-user)
(defpackage cl-cuda-examples.defglobal
(:use :cl :cl-cuda)
(:export :main))
(in-package :cl-cuda-examples.defglobal)
(setf cl-cuda:*show-messages* nil)
;;
;; Globals
(defglobal foo in... | #|
This file is a part of cl-cuda project.
Copyright (c) 2012 Masayuki Takagi (kamonama@gmail.com)
|#
(in-package :cl-user)
(defpackage cl-cuda-examples.defglobal
(:use :cl :cl-cuda)
(:export :main))
(in-package :cl-cuda-examples.defglobal)
(setf cl-cuda:*show-messages* nil)
;;
;; Globals
(defglobal foo in... |
Allow vectors and lists of objects to be passed to GL-DELETE(-OBJECT) | (in-package :kit.gl)
;;; Protocol for everyone
(defgeneric gl-delete-object (gl-object)
(:documentation "Call the appropriate gl* function to free the resource
`GL-OBJECT`."))
(defun gl-delete (&rest gl-objects)
"Delete `GL-OBJECTS` by calling `GL-DELETE-OBJECT` on each."
(map nil #'gl-delete-object gl-objects... | (in-package :kit.gl)
;;; Protocol for everyone
(defgeneric gl-delete-object (gl-object)
(:documentation "Call the appropriate gl* function to free the resource
`GL-OBJECT`."))
(defmethod gl-delete-object ((gl-objects list))
(map nil #'gl-delete-object gl-objects))
(defmethod gl-delete-object ((gl-objects vector... |
Test for eval-if-constant in an environment. | (in-package :serapeum.tests)
(def-suite macro-tools :in serapeum)
(in-suite macro-tools)
(test read-only-var
(let ((x 1))
(with-read-only-vars (x)
(is (eql x 1)))))
(test read-only-var-warning
(if (can-introspect-environment?)
(signals warning
(compile nil
'(lambda ()
... | (in-package :serapeum.tests)
(def-suite macro-tools :in serapeum)
(in-suite macro-tools)
(test read-only-var
(let ((x 1))
(with-read-only-vars (x)
(is (eql x 1)))))
(test read-only-var-warning
(if (can-introspect-environment?)
(signals warning
(compile nil
'(lambda ()
... |
Set function type at compile time. | (cl:in-package #:sicl-global-environment)
(defmacro defun (name lambda-list &body body)
(multiple-value-bind (declarations documentation forms)
(cleavir-code-utilities:separate-function-body body)
;; FIXME: handle documentation
(declare (ignore documentation))
(let ((definition `(lambda ,lambda-lis... | (cl:in-package #:sicl-global-environment)
(defmacro defun (&environment env name lambda-list &body body)
(multiple-value-bind (declarations documentation forms)
(cleavir-code-utilities:separate-function-body body)
(let ((global-env (cleavir-env:global-environment env))
(arg-type
(cleavir-code-utili... |
Fix defpackage for proper use of Closer MOP | (in-package :cl-user)
(defpackage :manifest
(:use :cl :toot :split-sequence :closer-mop :monkeylib-html :monkeylib-text-output)
(:shadowing-import-from :closer-mop
:defmethod
:defgeneric
:standard-generic-function)
(:export :start
... | (in-package :cl-user)
(defpackage :manifest
(:use :closer-common-lisp
:monkeylib-html
:monkeylib-text-output
:toot
:split-sequence)
(:export :start
:stop))
|
Fix problem with get-name and empty hash. | (in-package :brreg)
(push (cons "application" "json") drakma:*text-content-types*)
(defun get-jsonhash (orgnummer)
(when (and (every #'digit-char-p orgnummer)
(= (length orgnummer) 9))
(multiple-value-bind (response status)
(drakma:http-request
(format nil "http://data.brreg.no/en... | (in-package :brreg)
(push (cons "application" "json") drakma:*text-content-types*)
(defun get-jsonhash (orgnummer)
(when (and (every #'digit-char-p orgnummer)
(= (length orgnummer) 9))
(multiple-value-bind (response status)
(drakma:http-request
(format nil "http://data.brreg.no/en... |
Update how the CFFI groveller is invoked | ;;;; clinenoise.asd
(cl:eval-when (:load-toplevel :execute)
(asdf:operate 'asdf:load-op 'cffi-grovel))
(asdf:defsystem #:clinenoise
:serial t
:description "Describe clinenoise here"
:author "Your Name <your.name@example.com>"
:license "Specify license here"
:depends-on (#:cffi
#:alexandria
... | ;;;; clinenoise.asd
(asdf:defsystem #:clinenoise
:serial t
:description "Describe clinenoise here"
:author "Your Name <your.name@example.com>"
:license "Specify license here"
:defsystem-depends-on ("cffi-grovel")
:depends-on (#:cffi
#:alexandria
#:split-sequence
#:cffi-... |
Enlarge default *targmax*, configure constructors | (in-package :ratatoskr)
(default-targmaxes
((cmd-join . 4)
(cmd-part . 4)
(cmd-mode . 100)
(cmd-names . 1)
(cmd-privmsg . 4)
(cmd-notice . 4)
(cmd-whois . 4)))
(defparameter *targmaxes*
(alist-hash-table +default-targmaxes+ :test 'eq))
(defconstant +max-params+ 10)
(defvar *targma... | (in-package :ratatoskr)
(default-targmaxes
((cmd-join . 4)
(cmd-part . 4)
(cmd-mode . 100)
(cmd-names . 1)
(cmd-privmsg . 4)
(cmd-notice . 4)
(cmd-whois . 4)
(cmd-userhost . 5)))
(defparameter *targmaxes*
(alist-hash-table +default-targmaxes+ :test 'eq))
(defconstant +max-par... |
Define system in package ASDF-USER. | (cl:in-package #:common-lisp-user)
(asdf:defsystem cleavir-code-utilities
:depends-on (:cleavir-internationalization)
:serial t
:components
((:file "packages")
(:file "conditions")
(:file "condition-reporters-english")
(:file "argcount")
(:file "form")
(:file "list-structure")
(:file "declara... | (cl:in-package #:asdf-user)
(defsystem cleavir-code-utilities
:depends-on (:cleavir-internationalization)
:serial t
:components
((:file "packages")
(:file "conditions")
(:file "condition-reporters-english")
(:file "argcount")
(:file "form")
(:file "list-structure")
(:file "declarations")
(... |
Add new component to system definition. | (cl:in-package #:asdf-user)
(defsystem :cleavir-ast
:depends-on (:cleavir-io
:cleavir-meter)
:serial t
:components
((:file "packages")
(:file "general-purpose-asts")
(:file "fixnum-related-asts")
(:file "float-related-asts")
(:file "cons-related-asts")
(:file "standard-object-related-ast... | (cl:in-package #:asdf-user)
(defsystem :cleavir-ast
:depends-on (:cleavir-io
:cleavir-meter)
:serial t
:components
((:file "packages")
(:file "general-purpose-asts")
(:file "fixnum-related-asts")
(:file "float-related-asts")
(:file "cons-related-asts")
(:file "standard-object-related-ast... |
Rename function and add more comments. | (cl:in-package #:sicl-clos)
;;; We use the reader DEFAULT-INITARGS rather than
;;; CLASS-DEFAULT-INITARGS, because the AMOP stipulates that
;;; CLASS-DEFAULT-INITARGS must return the empty list for built-in
;;; classes. However, our built-in classes do have default initargs.
;;; The solution to this problem is to use... | (cl:in-package #:sicl-clos)
;;; The function in this file implements the action of the default
;;; method on the generic function MAKE-BUILT-IN-INSTANCE, i.e. the
;;; one specialized to BUILT-IN-CLASS.
;;;
;;; We use the reader DEFAULT-INITARGS rather than
;;; CLASS-DEFAULT-INITARGS, because the AMOP stipulates that
;... |
Test if (NOT 0) returns T. | ;;;;; TRE environment
;;;;; Copyright (c) 2009 Sven Klose <pixel@copei.de>
;;;;;
;;;;; Testing stage 0 functions
;(define-test "%NCONC"
; ((%nconc '(1 2) '(3 4)))
; '(1 2 3 4))
(define-test "%NCONC with NIL first"
((%nconc nil '(3 4)))
'(3 4))
(define-test "%NCONC with NIL second"
((%nconc '(1 2) nil))
'(1... | ;;;;; TRE environment
;;;;; Copyright (c) 2009 Sven Klose <pixel@copei.de>
;;;;;
;;;;; Testing stage 0 functions
;(define-test "%NCONC"
; ((%nconc '(1 2) '(3 4)))
; '(1 2 3 4))
(define-test "NOT 0 is NIL"
((not 0))
nil)
(define-test "%NCONC with NIL first"
((%nconc nil '(3 4)))
'(3 4))
(define-test "%NCON... |
Define *T* as a symbol macro for finding target class. | (cl:in-package #:sicl-boot-phase2)
(defvar *t*
(find-bridge-class 't))
(defvar *standard-reader-method*
(find-bridge-class 'standard-reader-method))
(defvar *standard-writer-method*
(find-bridge-class 'standard-writer-method))
(defvar *standard-object*
(find-bridge-class 'standard-object))
(defvar *funcall... | (cl:in-package #:sicl-boot-phase2)
(define-symbol-macro *t*
(find-target-class 't))
(defvar *standard-reader-method*
(find-bridge-class 'standard-reader-method))
(defvar *standard-writer-method*
(find-bridge-class 'standard-writer-method))
(defvar *standard-object*
(find-bridge-class 'standard-object))
(de... |
Use asdf-driver, not asdf-utils anymore. | ;;;;; XCVB-Utils. Mix and match utilities from xcvb, asdf, alexandria, fare-utils
#+xcvb
(module
(:build-depends-on ((:asdf "alexandria")
(:asdf "fare-utils")
(:asdf "asdf-utils")
"/xcvb/driver")))
(asdf/package:define-package :xcvb-utils
(:mix :fare-u... | ;;;;; XCVB-Utils. Mix and match utilities from xcvb, asdf, alexandria, fare-utils
#+xcvb
(module
(:build-depends-on ((:asdf "alexandria")
(:asdf "fare-utils")
(:asdf "asdf-utils")
"/xcvb/driver")))
(asdf/package:define-package :xcvb-utils
(:mix :asdf/d... |
Use the SICL reader in COMPILE-FILE. | (in-package #:sicl-compiler)
(defun compile-file (input-file &key
(output-file nil output-file-p)
(verbose *compile-verbose*)
(print *compile-print*)
(external-format :default))
(with-open-file (stream input-file
:direction :input
:external-format external-format)
(let* ((*compile-fi... | (in-package #:sicl-compiler)
(defun compile-file (input-file &key
(output-file nil output-file-p)
(verbose *compile-verbose*)
(print *compile-print*)
(external-format :default))
(with-open-file (stream input-file
:direction :input
:external-format external-format)
(let* ((*compile-fi... |
Use MAKE-INSTANCE instead of MAKE-INSTANCE-DEFAULT. | (cl:in-package #:sicl-clos)
(eval-when (:compile-toplevel :load-toplevel :execute)
(fmakunbound 'defgeneric))
(defmacro defgeneric (name parameters)
`(progn
(let* ((class (find-bridge-class 'standard-generic-function))
(fun (make-instance-default class
:name ',name
:lambda-list ',parameters
... | (cl:in-package #:sicl-clos)
(eval-when (:compile-toplevel :load-toplevel :execute)
(fmakunbound 'defgeneric))
(defmacro defgeneric (name parameters)
`(progn
(let* ((class (find-bridge-class 'standard-generic-function))
(fun (make-instance class
:name ',name
:lambda-list ',parameters
:meth... |
Add comment explaining how we test the SPLAY operation. | (cl:in-package #:clump-test)
(defun in-order-traversal (tree)
(let ((result '()))
(clump-binary-tree:recursive-traversal
tree
;; Function PRE. Do nothing.
(constantly t)
;; Function IN.
(lambda (node)
(push (data node) result)
t)
;; Function POST. Do nothing.
#'... | (cl:in-package #:clump-test)
;;; We know that the SPLAY operation preserves an in-order traversal
;;; of the tree. Therefore, we test the SPLAY operation by the
;;; following steps:
;;;
;;; 1. Generate a random tree
;;; 2. Make an in-order traversal of that tree, saving the result
;;; 3. Select a random node of th... |
Make loading relative to ASDF system location. | (cl:in-package #:sicl-boot-phase2)
(defun ld (filename environment)
(format *trace-output* "Loading file ~a~%" filename)
(finish-output *trace-output*)
(sicl-extrinsic-environment:load-source-with-environments
filename
(sicl-boot-phase1:compilation-environment (phase1-environment environment))
environme... | (cl:in-package #:sicl-boot-phase2)
(defun ld (filename environment)
(format *trace-output* "Loading file ~a~%" filename)
(finish-output *trace-output*)
(sicl-extrinsic-environment:load-source-with-environments
(asdf:system-relative-pathname :sicl-boot-phase2 filename)
(sicl-boot-phase1:compilation-environm... |
Add missing dependency on alexandria | ;; This file is part of yason, a Common Lisp JSON parser/encoder
;;
;; Copyright (c) 2008 Hans Hbner
;; All rights reserved.
;;
;; Please see the file LICENSE in the distribution.
;;;; -*- Mode: LISP -*-
(in-package :cl-user)
(defpackage :yason.system
(:use :cl :asdf))
(in-package :yason.system)
(defsystem :yaso... | ;; This file is part of yason, a Common Lisp JSON parser/encoder
;;
;; Copyright (c) 2008 Hans Hbner
;; All rights reserved.
;;
;; Please see the file LICENSE in the distribution.
;;;; -*- Mode: LISP -*-
(in-package :cl-user)
(defpackage :yason.system
(:use :cl :asdf))
(in-package :yason.system)
(defsystem :yaso... |
Use CODE-CHAR instead of FORMAT. | ;;;;; tré – Copyright (c) 2013 Sven Michael Klose <pixel@copei.de>
(defvar *terpri* (format nil "~%"))
| ;;;;; tré – Copyright (c) 2013–2014 Sven Michael Klose <pixel@copei.de>
(defvar *terpri* (string (code-char 10)))
|
Comment out the testing related things until they work properly | (ql:quickload :fiveam)
(defsystem :cqlcl
:author "Aaron France"
:version "0.0.1"
:license "BSD"
:description "CQLv2 binary protocol"
:serial t
:components ((:file "package")
(:file "util")
(:file "constants")
(:file "types")
(:file "headers")
... | (defsystem :cqlcl
:author "Aaron France"
:version "0.0.1"
:license "BSD"
:description "CQLv2 binary protocol"
:serial t
:components ((:file "package")
(:file "util")
(:file "constants")
(:file "types")
(:file "headers")
(:file "proto... |
Add some helper methods for debugging streams | (in-package :cqlcl)
(defmacro rev-hash (ht)
(let ((ht-sym (gensym "hash-table"))
(ht-orig (gensym "hash-table-orig"))
(k (gensym))
(v (gensym)))
`(let* ((,ht-orig ,ht)
(,ht-sym (make-hash-table :size (hash-table-count ,ht) :test #'equal)))
(maphash (lambda (,k ,v)
... | (in-package :cqlcl)
(defmacro rev-hash (ht)
(let ((ht-sym (gensym "hash-table"))
(ht-orig (gensym "hash-table-orig"))
(k (gensym))
(v (gensym)))
`(let* ((,ht-orig ,ht)
(,ht-sym (make-hash-table :size (hash-table-count ,ht) :test #'equal)))
(maphash (lambda (,k ,v)
... |
Use proper argument order for IS. | (cl:defpackage #:bubble-operator-upwards_tests
(:use #:cl #:parachute)
(:import-from #:bubble-operator-upwards #:bubble-operator-upwards #:cartesian-product))
(cl:in-package #:bubble-operator-upwards_tests)
(define-test "featured-examples"
(is equal
(bubble-operator-upwards 'and '(plate (and ham eggs) bea... | (cl:defpackage #:bubble-operator-upwards_tests
(:use #:cl #:parachute)
(:import-from #:bubble-operator-upwards #:bubble-operator-upwards #:cartesian-product))
(cl:in-package #:bubble-operator-upwards_tests)
(define-test "featured-examples"
(is equal '(and (plate ham beans) (plate eggs beans))
(bubble-oper... |
Add border and misc tests to examples system. | ;;; -*- lisp -*-
(defpackage :clim-examples.system
(:use :cl :asdf))
(in-package :clim-examples.system)
;;; CLIM-Examples depends on having at least one backend loaded.
(defsystem :clim-examples
:depends-on (:mcclim)
:components
((:module "Examples"
:components
((:file "calc... | ;;; -*- lisp -*-
(defpackage :clim-examples.system
(:use :cl :asdf))
(in-package :clim-examples.system)
;;; CLIM-Examples depends on having at least one backend loaded.
(defsystem :clim-examples
:depends-on (:mcclim)
:components
((:module "Examples"
:components
((:file "calc... |
Add border and misc tests to examples system. | ;;; -*- lisp -*-
(defpackage :clim-examples.system
(:use :cl :asdf))
(in-package :clim-examples.system)
;;; CLIM-Examples depends on having at least one backend loaded.
(defsystem :clim-examples
:depends-on (:mcclim)
:components
((:module "Examples"
:components
((:file "calc... | ;;; -*- lisp -*-
(defpackage :clim-examples.system
(:use :cl :asdf))
(in-package :clim-examples.system)
;;; CLIM-Examples depends on having at least one backend loaded.
(defsystem :clim-examples
:depends-on (:mcclim)
:components
((:module "Examples"
:components
((:file "calc... |
Add description to .asd file. | ;;
;; Copyright (c) 2005-2010, Peter Seibel. All rights reserved.
;;
(asdf:defsystem com.gigamonkeys.binary-data
:name "binary-data"
:author "Peter Seibel <peter@gigamonkeys.com>"
:components
((:file "packages")
(:file "binary-data" :depends-on ("packages"))
(:file "common-datatypes" :depends-on ("packag... | ;;
;; Copyright (c) 2005-2011, Peter Seibel. All rights reserved.
;;
(defsystem com.gigamonkeys.binary-data
:name "binary-data"
:description "Library for reading and writing binary data."
:author "Peter Seibel <peter@gigamonkeys.com>"
:components
((:file "packages")
(:file "binary-data" :depends-on ("pack... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.