Instruction stringlengths 14 778 | input_code stringlengths 0 4.24k | output_code stringlengths 1 5.44k |
|---|---|---|
Install bridge generic functions later in the pase. | (cl:in-package #:common-lisp-user)
(asdf:defsystem :sicl-clos-phase3
:depends-on (:sicl-clos-phase1 :sicl-clos-phase2)
;; We use :SERIAL T so as to reduce the clutter with respect to the
;; dependencies, and to make the order completely predictable.
:serial t
:components
((:file "finalize-classes")
(:fi... | (cl:in-package #:common-lisp-user)
(asdf:defsystem :sicl-clos-phase3
:depends-on (:sicl-clos-phase1 :sicl-clos-phase2)
;; We use :SERIAL T so as to reduce the clutter with respect to the
;; dependencies, and to make the order completely predictable.
:serial t
:components
((:file "finalize-classes")
(:fi... |
Test should be run in a subshell | (defpackage :shcl/test/main
(:use :common-lisp)
(:import-from :shcl/test/lexer)
(:import-from :shcl/test/utility)
(:import-from :shcl/test/posix)
(:import-from :shcl/test/lisp-interpolation)
(:import-from :shcl/test/data)
(:import-from :shcl/test/iterator)
(:import-from :shcl/test/command)
(:import-fr... | (defpackage :shcl/test/main
(:use :common-lisp)
(:import-from :shcl/test/lexer)
(:import-from :shcl/test/utility)
(:import-from :shcl/test/posix)
(:import-from :shcl/test/lisp-interpolation)
(:import-from :shcl/test/data)
(:import-from :shcl/test/iterator)
(:import-from :shcl/test/command)
(:import-fr... |
Replace `NIL` with `()` in stub function definition. | (defpackage #:hello-world
(:use #:cl)
(:export #:hello))
(in-package #:hello-world)
(defun hello NIL)
| (defpackage #:hello-world
(:use #:cl)
(:export #:hello))
(in-package #:hello-world)
(defun hello ())
|
Remove stray MCN-UTILS dependency (sorry!) | ;;;; lazy-susan.asd
(asdf:defsystem #:lazy-susan
:serial t
:description "A readtable which provides more flexible symbol reading"
:author "Matt Niemeir <matt.niemeir@gmail.com>"
:license "BSD 2-clause"
:depends-on (#:mcn-utils)
:components ((:file "package")
(:file "utils")
(:... | ;;;; lazy-susan.asd
(asdf:defsystem #:lazy-susan
:serial t
:description "A readtable which provides more flexible symbol reading"
:author "Matt Niemeir <matt.niemeir@gmail.com>"
:license "BSD 2-clause"
:components ((:file "package")
(:file "utils")
(:file "syntax")
... |
Handle any CL object without error. | (cl:in-package #:sicl-clos)
(eval-when (:compile-toplevel :load-toplevel :execute)
(fmakunbound 'class-of))
(defun class-of (object)
(heap-instance-class object))
| (cl:in-package #:sicl-clos)
(eval-when (:compile-toplevel :load-toplevel :execute)
(fmakunbound 'class-of))
(defun class-of (object)
(if (heap-instance-p object)
(heap-instance-class object)
(cdr (assoc t *classes*))))
|
Use option :SERIAL T to simplify system definition. | (cl:in-package #:asdf-user)
(defsystem :sicl-conditions
:components
((:file "packages")
(:file "support"
:depends-on ("packages"))))
| (cl:in-package #:asdf-user)
(defsystem :sicl-conditions
:serial t
:components
((:file "packages")
(:file "support")))
|
Call function for customizing compilation environment C1. | (cl:in-package #:sicl-boot)
(defun fill-boot (boot)
(fill1 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)
(fill1 boot))
(defmethod initialize-instance :after ((boot boot) &key &allow-other-keys)
(fill-boot boot))
|
Define system in package ASDF-USER. | ;;; -*- Mode: Lisp -*-
;;; (c) copyright 2009 by
;;; Samium Gromoff (_deepfire@feelingofgreen.ru)
;;;
;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Library General Public
;;; License as published by the Free Software Foundation; either
;;; versio... | ;;; -*- Mode: Lisp -*-
;;; (c) copyright 2009 by
;;; Samium Gromoff (_deepfire@feelingofgreen.ru)
;;;
;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Library General Public
;;; License as published by the Free Software Foundation; either
;;; versio... |
Call function that defines backquote macros. | (cl:in-package #:sicl-extrinsic-environment)
(defun fill-environment (environment)
(import-from-host-common-lisp environment)
(import-from-sicl-global-environment environment)
(import-loop-support environment)
(define-defmacro environment)
(define-default-setf-expander environment))
| (cl:in-package #:sicl-extrinsic-environment)
(defun fill-environment (environment)
(import-from-host-common-lisp environment)
(import-from-sicl-global-environment environment)
(import-loop-support environment)
(define-backquote-macros environment)
(define-defmacro environment)
(define-default-setf-expander... |
Create list of bindings for the case of a variable. | (cl:in-package #:sicl-arithmetic)
(defmacro incf (&environment env place &optional (delta-form 1))
(multiple-value-bind (vars vals store-vars writer-form reader-form)
(get-setf-expansion place env)
(if (null vars)
`(let (,(first store-vars) (+ ,reader-form ,delta-form))
,writer-form)
`(let* ((,(first... | (cl:in-package #:sicl-arithmetic)
(defmacro incf (&environment env place &optional (delta-form 1))
(multiple-value-bind (vars vals store-vars writer-form reader-form)
(get-setf-expansion place env)
(if (null vars)
`(let ((,(first store-vars) (+ ,reader-form ,delta-form)))
,writer-form)
`(let* ((,(fir... |
Add twist and vector tests to package. | ;;;; lisphys.asd
(asdf:defsystem #:lisphys
:serial t
:description "Describe lisphys here"
:author "Guillaume <guillaume.saupin@gmail.com>"
:license "Specify license here"
:depends-on (#:clunit
#:alexandria)
:components ((:file "infpre")
(:file "package")
(:file "memoization")
... | ;;;; lisphys.asd
(asdf:defsystem #:lisphys
:serial t
:description "Describe lisphys here"
:author "Guillaume <guillaume.saupin@gmail.com>"
:license "Specify license here"
:depends-on (#:clunit
#:alexandria)
:components ((:file "infpre")
(:file "package")
(:file "memoization")
... |
Define generic functions SPLAY-STEP and SPLAY. | (cl:in-package #:clump-splay-tree)
| (cl:in-package #:clump-splay-tree)
(defgeneric splay-step (node))
(defgeneric splay (node))
|
Add multi-selection support to reopen-buffer. | ;;; recent-buffers.lisp --- Manage list of recent buffers.
(in-package :next)
(annot:enable-annot-syntax)
@export
(defmethod buffer-match-predicate ((buffer buffer))
(lambda (other-buffer)
(when other-buffer
(and (string= (url buffer) (url other-buffer))
(string= (title buffer) (title other-buf... | ;;; recent-buffers.lisp --- Manage list of recent buffers.
(in-package :next)
(annot:enable-annot-syntax)
@export
(defmethod buffer-match-predicate ((buffer buffer))
(lambda (other-buffer)
(when other-buffer
(and (string= (url buffer) (url other-buffer))
(string= (title buffer) (title other-buf... |
Define default method on function SPLAY-STEP. | (cl:in-package #:clump-splay-tree)
(defgeneric splay-step-with-parent (node parent))
(defgeneric splay-step (node))
(defgeneric splay (node))
| (cl:in-package #:clump-splay-tree)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Generic function SPLAY-STEP-WITH-PARENT.
;;;
;;; This function should not be called directly by client code. It is
;;; called by the function SPLAY-STEP with the NODE to splay and the
;;; PARENT of NODE, ... |
Allow more than two arguments to EQL. | ;;;;; tré – Copyright (c) 2008–2009,2011–2013 Sven Michael Klose <pixel@copei.de>
(defun eql (x y)
(| x (setq x nil))
(| y (setq y nil))
(| (%%%eq x y)
(? (| (number? x) (number? y))
(?
(& (integer? x) (integer? y)) (integer== x y)
(& (character? x) (character? y)) (character== x... | ;;;;; tré – Copyright (c) 2008–2009,2011–2013 Sven Michael Klose <pixel@copei.de>
(defun %eql (x y)
(| x (setq x nil))
(| y (setq y nil))
(| (%%%eq x y)
(? (| (number? x) (number? y))
(?
(& (integer? x) (integer? y)) (integer== x y)
(& (character? x) (character? y)) (character== ... |
Use FiveAM's new random testing for the parse-float test | ;;;; -*- lisp -*-
(in-package :it.bese.arnesi)
(def-suite :it.bese.arnesi.numbers :in :it.bese.arnesi)
(in-suite :it.bese.arnesi.numbers)
(test mulf
(let ((a 0))
(is (= 0 (mulf a 10)))
(is (= 0 a)))
(let ((a 1))
(is (= 4 (mulf a 4)))
(is (= 1 (mulf a (/ 4))))
(is (= 1 a))))
(test minf
(l... | ;;;; -*- lisp -*-
(in-package :it.bese.arnesi)
(def-suite :it.bese.arnesi.numbers :in :it.bese.arnesi)
(in-suite :it.bese.arnesi.numbers)
(test mulf
(let ((a 0))
(is (= 0 (mulf a 10)))
(is (= 0 a)))
(let ((a 1))
(is (= 4 (mulf a 4)))
(is (= 1 (mulf a (/ 4))))
(is (= 1 a))))
(test minf
(l... |
Fix .asd when loading on an unsupported lisp (e.g. clasp). | (asdf:defsystem #:closer-mop
:name "Closer to MOP"
:description "Closer to MOP is a compatibility layer that rectifies many of the absent or incorrect CLOS MOP features across a broad range of Common Lisp implementations."
:author "Pascal Costanza"
:version "1.0.0"
:licence "MIT-style license"
:components
... | (asdf:defsystem #:closer-mop
:name "Closer to MOP"
:description "Closer to MOP is a compatibility layer that rectifies many of the absent or incorrect CLOS MOP features across a broad range of Common Lisp implementations."
:author "Pascal Costanza"
:version "1.0.0"
:licence "MIT-style license"
:serial t
:... |
Call run-all-tests instead of run! for upward compatibility with FiveAM v1.3 | (in-package :cl-user)
(defpackage :defrest-system
(:use :cl :asdf))
(in-package :defrest-system)
(defsystem :defrest
:description "defrest: expose functions as REST webservices for ajax or other stuff"
:version "1"
:author "Mathias Menzel-Nielsen <(reverse \"ed.tfosztam@eztam\")>" ;nospam
:license "BSD"
:... | (in-package :cl-user)
(defpackage :defrest-system
(:use :cl :asdf))
(in-package :defrest-system)
(defsystem :defrest
:description "defrest: expose functions as REST webservices for ajax or other stuff"
:version "1"
:author "Mathias Menzel-Nielsen <(reverse \"ed.tfosztam@eztam\")>" ;nospam
:license "BSD"
:... |
Define ASDF system in package ASDF-USER. | (cl:in-package #:common-lisp-user)
(asdf:defsystem :cleavir-ast-to-hir-test
:depends-on (:cleavir-generate-ast-test
:cleavir-ast-to-hir
:cleavir-hir-interpreter)
:serial t
:components
((:file "packages")
(:file "ast-to-hir")))
| (cl:in-package #:asdf-user)
(defsystem :cleavir-ast-to-hir-test
:depends-on (:cleavir-generate-ast-test
:cleavir-ast-to-hir
:cleavir-hir-interpreter)
:serial t
:components
((:file "packages")
(:file "ast-to-hir")))
|
Add slot TREE to condition INVALID-BINARY-TREE. | (cl:in-package #:clump-binary-tree)
(define-condition binary-tree-error (error acclimation:condition)
())
(define-condition invalid-binary-tree (binary-tree-error)
())
| (cl:in-package #:clump-binary-tree)
(define-condition binary-tree-error (error acclimation:condition)
())
(define-condition invalid-binary-tree (binary-tree-error)
((%tree :initarg :tree :reader tree)))
|
Add method on REPLACE-CHILD specialized to a NULL node. | (cl:in-package #:clump-binary-tree)
(defgeneric replace-child (node old-child new-child))
| (cl:in-package #:clump-binary-tree)
(defgeneric replace-child (node old-child new-child))
(defmethod replace-child ((node null) (old-child node) new-child)
new-child)
|
Define generic function for determining whether an instruction can be removed. | (cl:in-package #:cleavir-remove-useless-instructions)
(defun remove-useless-instructions (initial-instruction)
(cleavir-ir:reinitialize-data initial-instruction)
(let ((useless-instructions '()))
(cleavir-ir:map-instructions-arbitrary-order
(lambda (instruction)
(when (and (= (length (cleavir-ir:su... | (cl:in-package #:cleavir-remove-useless-instructions)
(defgeneric instruction-may-be-removed-p (instruction))
(defun remove-useless-instructions (initial-instruction)
(cleavir-ir:reinitialize-data initial-instruction)
(let ((useless-instructions '()))
(cleavir-ir:map-instructions-arbitrary-order
(lambda ... |
Put code in specific package. | (cl:in-package #:sicl-reader)
(defun make-contents ()
(make-array 10
:fill-pointer 0
:element-type 'character
:adjustable t))
(defclass source-tracking-stream
(trivial-gray-streams:fundamental-character-input-stream)
((%original :initarg :original :reader original)
(%contents :initform... | (cl:in-package #:sicl-source-tracking-reader)
(defun make-contents ()
(make-array 10
:fill-pointer 0
:element-type 'character
:adjustable t))
(defclass source-tracking-stream
(trivial-gray-streams:fundamental-character-input-stream)
((%original :initarg :original :reader original)
(%co... |
Return the unread char if it is non-NIL. | (cl:in-package #:sicl-source-tracking-reader)
(defun make-contents ()
(make-array 10
:fill-pointer 0
:element-type 'character
:adjustable t))
(defclass source-tracking-stream
(trivial-gray-streams:fundamental-character-input-stream)
((%original :initarg :original :reader original)
(%co... | (cl:in-package #:sicl-source-tracking-reader)
(defun make-contents ()
(make-array 10
:fill-pointer 0
:element-type 'character
:adjustable t))
(defclass source-tracking-stream
(trivial-gray-streams:fundamental-character-input-stream)
((%original :initarg :original :reader original)
(%co... |
Use existing FORM-MIXIN class as a superclass. | ;;;; Copyright (c) 2014
;;;;
;;;; 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 user of
... | ;;;; Copyright (c) 2014
;;;;
;;;; 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 user of
... |
Add :author/:license to ASD file | (when (asdf:find-system :local-time nil) (pushnew :js-dates *features*))
(asdf:defsystem :cl-js
:description "JavaScript-to-CL compiler and runtime"
:depends-on (:parse-js :cl-ppcre #+js-dates :local-time)
:serial t
:components
((:file "package")
(:file "utils")
(:file "js")
(:file "jsos")
(:file... | (when (asdf:find-system :local-time nil) (pushnew :js-dates *features*))
(asdf:defsystem :cl-js
:description "JavaScript-to-CL compiler and runtime"
:author "Marijn Haverbeke <marijnh@gmail.com>"
:license "MIT"
:depends-on (:parse-js :cl-ppcre #+js-dates :local-time)
:serial t
:components
((:file "packag... |
Add method on REPORT-CONDITION specialized to NO-OBJECT-PRECEDING-DOT. | (cl:in-package #:sicl-read)
(defmethod cleavir-i18n:report-condition
((condition unmatched-right-parenthesis)
stream
(language cleavir-i18n:english))
(format stream "Unmatched right parenthesis found."))
(defmethod cleavir-i18n:report-condition
((condition only-dots-in-token)
stream
(lan... | (cl:in-package #:sicl-read)
(defmethod cleavir-i18n:report-condition
((condition unmatched-right-parenthesis)
stream
(language cleavir-i18n:english))
(format stream "Unmatched right parenthesis found."))
(defmethod cleavir-i18n:report-condition
((condition only-dots-in-token)
stream
(lan... |
Enable running 5am tests by default | (defpackage #:local-time.system
(:use :common-lisp :asdf))
(in-package #:local-time.system)
(defsystem :local-time
:name "local-time"
:version "0.9.1"
:author "Daniel Lowe <dlowe@sanctuary.org>"
:description "A library for manipulating dates and times, based on a paper by Erik Naggum"
:components ((:file ... | (defpackage #:local-time.system
(:use :common-lisp :asdf))
(in-package #:local-time.system)
(defsystem :local-time
:name "local-time"
:version "0.9.1"
:author "Daniel Lowe <dlowe@sanctuary.org>"
:description "A library for manipulating dates and times, based on a paper by Erik Naggum"
:components ((:file ... |
Use CL functions where possible. | ; tré – Copyright (c) 2014–2015 Sven Michael Klose <pixel@hugbox.org>
(defbuiltin not (&rest x) (cl:every #'cl:not x))
(defbuiltin builtin? (x) (cl:gethash x *builtins*))
(defun variable-compare (predicate x)
(? .x
(alet x.
(@ (i .x t)
(| (funcall predicate ! i)
(return nil))))
... | ; tré – Copyright (c) 2014–2015 Sven Michael Klose <pixel@hugbox.org>
(defbuiltin not (&rest x) (cl:every #'cl:not x))
(defbuiltin builtin? (x) (cl:gethash x *builtins*))
(defun variable-compare (predicate x)
(? .x
(@ (i .x t)
(| (funcall predicate x. i)
(return nil)))
(cl:error "At leas... |
Put the LAMBDA macro in the package where it belongs. | (cl:in-package #:sicl-global-environment)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Macro LAMBDA.
(defmacro lambda (lambda-list &body body)
`(function (lambda ,lambda-list ,@body)))
| (cl:in-package #:sicl-evaluation-and-compilation)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Macro LAMBDA.
(defmacro lambda (lambda-list &body body)
`(function (lambda ,lambda-list ,@body)))
|
Define system in package ASDF-USER. | ;;; -*- Mode: Lisp -*-
;;; (c) copyright 2008 by
;;; Troels Henriksen (athas@sigkill.dk)
;;;
;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Library General Public
;;; License as published by the Free Software Foundation; either
;;; version 2 of th... | ;;; -*- Mode: Lisp -*-
;;; (c) copyright 2008 by
;;; Troels Henriksen (athas@sigkill.dk)
;;;
;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Library General Public
;;; License as published by the Free Software Foundation; either
;;; version 2 of th... |
Update link to weblocks project |
(in-package :website)
;;;
(defwidget header (on-demand-selector)
((default-title :accessor header-default-title
:initarg :default-title
:type string
:initform "")
(title-fn :accessor header-title-fn
:type function
:initarg :title-fn... |
(in-package :website)
;;;
(defwidget header (on-demand-selector)
((default-title :accessor header-default-title
:initarg :default-title
:type string
:initform "")
(title-fn :accessor header-title-fn
:type function
:initarg :title-fn... |
Make the system depend on the internationalization system. | (cl:in-package #:common-lisp-user)
(asdf:defsystem :cleavir-environment
:serial t
:components
((:file "packages")
(:file "conditions")
(:file "query")
(:file "augmentation-functions")
(:file "default-augmentation-classes")
(:file "default-info-methods")
(:file "eval")))
| (cl:in-package #:common-lisp-user)
(asdf:defsystem :cleavir-environment
:depends-on (:cleavir-internationalization)
:serial t
:components
((:file "packages")
(:file "conditions")
(:file "query")
(:file "augmentation-functions")
(:file "default-augmentation-classes")
(:file "default-info-methods"... |
Add variable for target operating system. | (cl:in-package #:sicl-extrinsic-file-compiler)
(defparameter *sicl* (make-instance 'sicl-target-sicl:sicl))
(defun ast-from-stream (stream environment)
(cleavir-ast:make-progn-ast
(loop with eof = (list nil)
for form = (sicl-reader:read stream nil eof)
until (eq form eof)
collect (cleavir-generate-ast:gene... | (cl:in-package #:sicl-extrinsic-file-compiler)
(defparameter *sicl* (make-instance 'sicl-target-sicl:sicl))
(defparameter *gnu-linux* (make-instance 'sicl-os-gnu-linux:gnu-linux))
(defun ast-from-stream (stream environment)
(cleavir-ast:make-progn-ast
(loop with eof = (list nil)
for form = (sicl-reader:read s... |
Add 410 example to asd | (defpackage :glkit.asdf
(:use #:cl #:asdf))
(in-package :glkit.asdf)
(defsystem :glkit-examples
:description "Various utilities for OpenGL"
:author ("rpav")
:license "MIT"
:version "0.0"
:depends-on (:sdl2kit-examples :glkit)
:pathname "examples"
:serial t
:components
((:file "package")
(:fil... | (defpackage :glkit.asdf
(:use #:cl #:asdf))
(in-package :glkit.asdf)
(defsystem :glkit-examples
:description "Various utilities for OpenGL"
:author ("rpav")
:license "MIT"
:version "0.0"
:depends-on (:sdl2kit-examples :glkit)
:pathname "examples"
:serial t
:components
((:file "package")
(:fil... |
Remove extraneous CLD from example. | (in-package :6502)
(defparameter *benchmark*
(asm " ;; Clear the Decimal and Carry status bits
CLD
CLC
;; Set the Accumulator and X and Y regs to zero
LDA #$00
LDX #$00
LDY #$00
;; Increment Y until it wraps around to zero, then proceed to 0x0b
... | (in-package :6502)
(defparameter *benchmark*
(asm " ;; Clear the Carry status bit
CLC
;; Set the Accumulator and X and Y regs to zero
LDA #$00
LDX #$00
LDY #$00
;; Increment Y until it wraps around to zero, then proceed to 0x0b
loop:
INY
... |
Add English documentation for function ROTATE-LEFT. | (cl:in-package #:clump-binary-tree)
(setf (documentation 'left 'function)
(format nil "Given a binary tree, return the left child of that tree.~@
If an object other than a binary tree is given,~@
then an error of type INVALID-BINARY-TREE is signaled."))
(setf (documentation... | (cl:in-package #:clump-binary-tree)
(setf (documentation 'left 'function)
(format nil "Given a binary tree, return the left child of that tree.~@
If an object other than a binary tree is given,~@
then an error of type INVALID-BINARY-TREE is signaled."))
(setf (documentation... |
Print place if it's not an atom. | ;;;;; tré - Copyright (c) 2005-2006,2008,2010-2012 Sven Michael Klose <pixel@copei.de>
;; Create new local variable.
(defmacro let (place expr &body body)
(?
(not body)
(progn
(print place)
(print expr)
(print body)
(%error "body expected"))
(cons? place)
(%error "place is not an atom")
`... | ;;;;; tré – Copyright (c) 2005-2006,2008,2010–2012 Sven Michael Klose <pixel@copei.de>
;; Create new local variable.
(defmacro let (place expr &body body)
(?
(not body)
(progn
(print place)
(print expr)
(print body)
(%error "body expected"))
(cons? place)
(progn
(print place)
(%err... |
Make the extrinsic environment a superclass. | (cl:in-package #:sicl-extrinsic-hir-compiler)
(defclass environment (sicl-simple-environment:simple-environment)
())
| (cl:in-package #:sicl-extrinsic-hir-compiler)
(defclass environment (sicl-extrinsic-environment:environment)
())
|
Add new parameter to generic function definition. | (cl:in-package #:clump-binary-tree)
(defgeneric iterative-traversal (tree enter))
(defmethod iterative-traversal ((tree node-with-parent) enter leave)
(let ((current-node tree))
(loop do (if (or (not (funcall enter current-node))
(and (null (left current-node))
(null (right current-node))))
(loop... | (cl:in-package #:clump-binary-tree)
(defgeneric iterative-traversal (tree enter leave))
(defmethod iterative-traversal ((tree node-with-parent) enter leave)
(let ((current-node tree))
(loop do (if (or (not (funcall enter current-node))
(and (null (left current-node))
(null (right current-node))))
... |
Define EFFECTIVE-SLOT-DEFINITION-CLASS in phase 3. | (cl:in-package #:sicl-boot)
(defclass header ()
((%class :initarg :class :accessor class)
(%rack :initarg :rack :reader rack)))
(defun define-allocate-general-instance (env)
(setf (sicl-genv:fdefinition 'sicl-clos:allocate-general-instance env)
(lambda (class size)
(make-instance 'header
:class class
... | (cl:in-package #:sicl-boot)
(defun define-effective-slot-definition-class-phase3 (env1 env2)
(setf (sicl-genv:fdefinition 'sicl-clos:effective-slot-definition-class
env1)
(lambda (&rest args)
(declare (ignore args))
(sicl-genv:find-class 'sicl-clos:standard-effective-slot-definition
env2))))
(d... |
Create new constant variable in addition to existing special variable. | (cl:in-package #:sicl-extrinsic-environment)
(defun import-from-sicl-global-environment (environment)
(setf (sicl-env:special-variable 'sicl-env:*global-environment* environment t)
environment))
| (cl:in-package #:sicl-extrinsic-environment)
(defun import-from-sicl-global-environment (environment)
;; This variable is deprecated. Uses of it should be replaced by
;; uses of the constant sicl-env:+global-environment+
(setf (sicl-env:special-variable 'sicl-env:*global-environment* environment t)
environment... |
Use %%%CONS instead of CONS to work around infinite loops due to argument expansions. | ;;;;; tré – Copyright (c) 2005–2009,2011–2012 Sven Michael Klose <pixel@copei.de>
(defun %compiled-atom (x quoted?)
(? (& quoted? x (symbol? x))
(list 'quote x)
x))
(defun compiled-list (x &key (quoted? nil))
(? (cons? x)
`(cons ,(%compiled-atom x. quoted?)
,(compiled-list .x :quoted? q... | ;;;;; tré – Copyright (c) 2005–2009,2011–2012 Sven Michael Klose <pixel@copei.de>
(defun %compiled-atom (x quoted?)
(? (& quoted? x (symbol? x))
(list 'quote x)
x))
(defun compiled-list (x &key (quoted? nil))
(? (cons? x)
`(%%%cons ,(%compiled-atom x. quoted?)
,(compiled-list .x :quo... |
Load a file containing support code for DEFCLASS. | (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)
... |
Use explicit test for type of argument. | (cl:in-package #:sicl-cons)
(defun car (list)
(declare (type list list))
(if (consp list)
(cleavir-primop:car list)
nil))
(defun cdr (list)
(declare (type list list))
(if (consp list)
(cleavir-primop:cdr list)
nil))
(defun rplaca (cons object)
(declare (type cons cons))
(cleavir... | (cl:in-package #:sicl-cons)
(defun car (list)
(if (consp list)
(cleavir-primop:car list)
(if (null list)
nil
(error 'must-be-list :datum list))))
(defun cdr (list)
(if (consp list)
(cleavir-primop:cdr list)
(if (null list)
nil
(error 'must-be-list :datum list))))
(defun rpla... |
Define class for result of analysis. | (cl:in-package #:cleavir-dataflow-analysis)
(defclass operation ()
((%instruction :initarg :instruction :reader instruction)
(%inputs :initform '() :initarg inputs :accessor inputs)
(%outputs :initform '() :initarg outputs :accessor outputs)))
| (cl:in-package #:cleavir-dataflow-analysis)
(defclass operation ()
((%instruction :initarg :instruction :reader instruction)
(%inputs :initform '() :initarg inputs :accessor inputs)
(%outputs :initform '() :initarg outputs :accessor outputs)))
(defclass dataflow ()
((%operations :initarg :operations :access... |
Make integer of number of times. | ;;;;; tré – Copyright (c) 2005–2008,2010–2012 Sven Michael Klose <pixel@copei.de>
(defmacro do (binds (test &rest result) &body body)
(let tag (gensym)
`(block nil
(let* ,(mapcar #'((b)
`(,(car b) ,(cadr b)))
binds)
(tagbody
,tag
(? ,test
(return ... | ;;;;; tré – Copyright (c) 2005–2008,2010–2012 Sven Michael Klose <pixel@copei.de>
(defmacro do (binds (test &rest result) &body body)
(let tag (gensym)
`(block nil
(let* ,(mapcar #'((b)
`(,(car b) ,(cadr b)))
binds)
(tagbody
,tag
(? ,test
(return ... |
Use new component name in system definitions. | (cl:in-package #:asdf-user)
(defsystem :sicl-sequences
:depends-on (:lisp-unit)
:serial t
:components
((:file "packages")
(:file "common")
(:file "sequences")
(:file "condition-reporters-en")
(:file "docstrings-en")))
(defsystem :sicl-sequences-tiny
:depends-on (:lisp-unit)
:serial t
:compon... | (cl:in-package #:asdf-user)
(defsystem :sicl-sequences
:depends-on (:lisp-unit)
:serial t
:components
((:file "packages")
(:file "conditions")
(:file "sequences")
(:file "condition-reporters-en")
(:file "docstrings-en")))
(defsystem :sicl-sequences-tiny
:depends-on (:lisp-unit)
:serial t
:co... |
Fix typo in `if-confirm' docstring. | ;;;; SPDX-FileCopyrightText: Atlas Engineer LLC
;;;; SPDX-License-Identifier: BSD-3-Clause
(in-package :nyxt)
(export-always '*yes-no-choices*)
(defparameter *yes-no-choices* '(:yes "yes" :no "no")
"The suggestions when asking the user for a yes/no choice.
See `if-confirm'.
The first suggestion poses as a default."... | ;;;; SPDX-FileCopyrightText: Atlas Engineer LLC
;;;; SPDX-License-Identifier: BSD-3-Clause
(in-package :nyxt)
(export-always '*yes-no-choices*)
(defparameter *yes-no-choices* '(:yes "yes" :no "no")
"The suggestions when asking the user for a yes/no choice.
See `if-confirm'.
The first suggestion poses as a default."... |
Destroy the webview on frame exit | (defpackage lispkit
(:use :gtk :gdk :gdk-pixbuf :gobject
:drakma :cl-webkit
:glib :gio :pango :cairo :common-lisp)
(:export #:main))
(in-package :lispkit)
(defun main (&rest args)
(declare (ignore args))
(within-main-loop
(let ((window (gtk-window-new :toplevel))
(view (webkit.fo... | (defpackage lispkit
(:use :gtk :gdk :gdk-pixbuf :gobject
:drakma :cl-webkit
:glib :gio :pango :cairo :common-lisp)
(:export #:main))
(in-package :lispkit)
(defun main (&rest args)
(declare (ignore args))
(within-main-loop
(let ((window (gtk-window-new :toplevel))
(view (webkit.fo... |
Remove function IMPORT-SPECIAL-OPERATORS. No longer needed. | (cl:in-package #:sicl-extrinsic-environment)
(defun import-special-operators (environment)
(loop for symbol being each external-symbol in '#:common-lisp
when (special-operator-p symbol)
do (setf (sicl-env:special-operator symbol environment) t)))
;;; Enter every Common Lisp class into the environment.
(defun im... | (cl:in-package #:sicl-extrinsic-environment)
;;; Enter every Common Lisp class into the environment.
(defun import-classes (environment)
(loop for symbol being each external-symbol in '#:common-lisp
for class = (find-class symbol nil)
unless (null class)
do (setf (sicl-env:find-class symbol environment)
cl... |
Add vao-shader-150 to the asd | (defpackage :glkit.asdf
(:use #:cl #:asdf))
(in-package :glkit.asdf)
(defsystem :glkit-examples
:description "Various utilities for OpenGL"
:author ("rpav")
:license "MIT"
:version "0.0"
:depends-on (:sdl2kit-examples :glkit)
:pathname "examples"
:serial t
:components
((:file "vaos")
(:file "... | (defpackage :glkit.asdf
(:use #:cl #:asdf))
(in-package :glkit.asdf)
(defsystem :glkit-examples
:description "Various utilities for OpenGL"
:author ("rpav")
:license "MIT"
:version "0.0"
:depends-on (:sdl2kit-examples :glkit)
:pathname "examples"
:serial t
:components
((:file "vaos")
(:file "... |
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 short description in ASDF file | ;;;; The MIT License (MIT)
;;;; Copyright (c) 2015 Huang Xuxing
;;;; 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 without limitation the rights to... | ;;;; The MIT License (MIT)
;;;; Copyright (c) 2015 Huang Xuxing
;;;; 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 without limitation the rights to... |
Define save info for new AST class. | (cl:in-package #:cleavir-ast)
(defclass scope-ast (ast)
((%child-ast :initarg :child-ast :reader child-ast)
(%variable-ast :initarg :variable-ast :reader variable-ast)))
| (cl:in-package #:cleavir-ast)
(defclass scope-ast (ast)
((%child-ast :initarg :child-ast :reader child-ast)
(%variable-ast :initarg :variable-ast :reader variable-ast)))
(cleavir-io:define-save-info scope-ast
(:child-ast child-ast)
(:variable-ast variagble-ast))
|
Use package ASDF-USER for system definition. | (cl:in-package #:common-lisp-user)
(asdf:defsystem :cleavir-generate-ast-test
:depends-on (:cleavir-generate-ast
:cleavir-ast-transformations
:cleavir-ast-interpreter)
:serial t
:components
((:file "packages")
(:file "environment")
(:file "minimal-compilation")
(:file "generate-ast")))... | (cl:in-package #:asdf-user)
(defsystem :cleavir-generate-ast-test
:depends-on (:cleavir-generate-ast
:cleavir-ast-transformations
:cleavir-ast-interpreter)
:serial t
:components
((:file "packages")
(:file "environment")
(:file "minimal-compilation")
(:file "generate-ast")))
|
Add method specialized to RETURN-INSTRUCTION. | (cl:in-package #:cleavir-remove-useless-instructions)
(defgeneric instruction-may-be-removed-p (instruction))
(defmethod instruction-may-be-removed-p (instruction)
(and (= (length (cleavir-ir:successors instruction)) 1)
(loop for output in (cleavir-ir:outputs instruction)
always (null (cleavir-ir:using... | (cl:in-package #:cleavir-remove-useless-instructions)
(defgeneric instruction-may-be-removed-p (instruction))
(defmethod instruction-may-be-removed-p (instruction)
(and (= (length (cleavir-ir:successors instruction)) 1)
(loop for output in (cleavir-ir:outputs instruction)
always (null (cleavir-ir:using... |
Return NIL if place is NIL. | ;;;;; tré – Copyright (c) 2010,2012 Sven Michael Klose <pixel@copei.de>
(defun %hcache-remove (plc vals)
(& plc vals
(| (not .vals)
(%hcache-remove plc .vals))
(| (hremove plc vals.)
t)))
(defun hcache-remove (plc &rest vals)
(%hcache-remove plc vals))
(defun %hcache (plc vals)
(& plc vals
(| (... | ;;;;; tré – Copyright (c) 2010,2012–2013 Sven Michael Klose <pixel@copei.de>
(defun hcache-remove (plc &rest vals)
(& plc vals
(| (not .vals)
(apply #'hcache-remove plc .vals))
(| (hremove plc vals.)
t)))
(defun hcache (plc &rest vals)
(& plc vals
(| (& (not .vals)
(href plc vals.))
(appl... |
Remove stale Trees system dependency | (asdf:defsystem #:ttnr
:depends-on (#:alexandria #:trees #:bmgraph #:bmgraph-bestpath #:minimal-graph)
:components ((:file "ttnr")
(:file "utils")
(:file "series-parallel-optimizations")))
| (asdf:defsystem #:ttnr
:depends-on (#:alexandria #:bmgraph #:bmgraph-bestpath #:minimal-graph)
:components ((:file "ttnr")
(:file "utils")
(:file "series-parallel-optimizations")))
|
Use a more general algorithm. | ;;;;; TRE environment
;;;;; Copyright (c) 2009 Sven Klose <pixel@copei.de>
(defun unique-0 (head tail)
(when head
(if (= head tail.)
(unique-0 head .tail)
(cons head
(unique-0 tail. .tail)))))
(defun unique (x &key (test #'<=))
(let sorted (sort x :test test)
(unique-0 sorted. .sorted)))
| ;;;;; TRE environment
;;;;; Copyright (c) 2010 Sven Klose <pixel@copei.de>
(defun unique (x &key (test #'eql))
(when x
(if (member x. .x :test test)
(unique .x :test test)
(cons x.
(unique .x :test test)))))
|
Use function for accessing global environment. | (cl:in-package #:sicl-clos)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; DEFGENERIC.
;;; FIXME: Add options and methods
(defmacro defgeneric (&environment env name lambda-list)
(let* ((arg-type (cleavir-code-utilities:lambda-list-type-specifier lambda-list))
(function-type `(func... | (cl:in-package #:sicl-clos)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; DEFGENERIC.
;;; FIXME: Add options and methods
(defmacro defgeneric (&environment env name lambda-list)
(let* ((arg-type (cleavir-code-utilities:lambda-list-type-specifier lambda-list))
(function-type `(func... |
Add description to .asd file. | ;;
;; Copyright (c) 2010, Peter Seibel. All rights reserved.
;;
(defsystem gigamonkey-distcompiler
:components
((:file "packages")
(:file "tarhash" :depends-on ("packages"))
(:file "distcompiler" :depends-on ("packages" "tarhash")))
:depends-on (:ironclad
:com.gigamonkeys.pathnames
... | ;;
;; Copyright (c) 2010, Peter Seibel. All rights reserved.
;;
(defsystem gigamonkey-distcompiler
:components
:description "Tool for generating Quicklisp dists."
((:file "packages")
(:file "tarhash" :depends-on ("packages"))
(:file "distcompiler" :depends-on ("packages" "tarhash")))
:depends-on (:ironcl... |
Add docstring for function RIGHT. | (cl:in-package #:clump-binary-tree)
(setf (documentation 'left 'function)
(format nil "Given a binary tree, obtain the left child of that tree.~@
If an object other than a binary tree is given,~@
then an error of type INVALID-BINARY-TREE is signaled."))
| (cl:in-package #:clump-binary-tree)
(setf (documentation 'left 'function)
(format nil "Given a binary tree, return the left child of that tree.~@
If an object other than a binary tree is given,~@
then an error of type INVALID-BINARY-TREE is signaled."))
(setf (documentation... |
Add sb-introspect dependency on SBCL. | ;;;; System definition for TRIVIAL-DOCUMENTATION.
(defsystem trivial-documentation
:description
"Extract documentation and definitions for symbols and packages."
:author "Max Rottenkolber <max@mr.gy>"
:license "GNU AGPL"
:components ((:file "extract"))
:depends-on ("closer-mop"))
| ;;;; System definition for TRIVIAL-DOCUMENTATION.
(defsystem trivial-documentation
:description
"Extract documentation and definitions for symbols and packages."
:author "Max Rottenkolber <max@mr.gy>"
:license "GNU AGPL"
:components ((:file "extract"))
:depends-on ("closer-mop" #+sbcl"sb-introspect"))
|
Add reader conditional for clarity | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
(in-package :swap-bytes)
#+x86
(defun swap-bytes-16 (integer)
(declare (type (unsigned-byte 16) integer))
(swap-bytes-16 integer))
(defun swap-bytes-32 (integer)
(declare (type (unsigned-byte 32) integer))
(swap-bytes-32 integer))
#+x86-64
(defun swap-bytes-64 (... | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
(in-package :swap-bytes)
#+x86
(defun swap-bytes-16 (integer)
(declare (type (unsigned-byte 16) integer))
(swap-bytes-16 integer))
#+(or x86 x86-64)
(defun swap-bytes-32 (integer)
(declare (type (unsigned-byte 32) integer))
(swap-bytes-32 integer))
#+x86-64
(def... |
Remove useless DEFPACKAGE from the .asd file | ;;; -*- Lisp -*- mode
(defpackage #:split-sequence-system (:use #:cl #:asdf))
(in-package :split-sequence-system)
(defsystem :split-sequence
:version "20011114.1"
:components ((:file "split-sequence"))
:in-order-to ((asdf:test-op (asdf:load-op :split-sequence-tests)))
:perform (asdf:test-op :after (op c)
... | ;;; -*- Lisp -*-
(defsystem :split-sequence
:version "20011114.1"
:components ((:file "split-sequence"))
:in-order-to ((asdf:test-op (asdf:load-op :split-sequence-tests)))
:perform (asdf:test-op :after (op c)
(funcall (intern (symbol-name '#:run!) '#:5am) :split-sequence)))
(defsystem :split-se... |
Load a file containing the definition of METHOD-COMBINATION. | (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/method-combination-defclass.lisp" c r)
(ld "../CLOS/spec... |
Fix the user name of PostgreSQL. | (in-package :cl-user)
(defpackage integral-test.init.postgres
(:use :cl
:integral)
(:export :connect-to-testdb))
(in-package :integral-test.init.postgres)
(defun connect-to-testdb ()
(disconnect-toplevel)
(connect-toplevel :postgres
:database-name "integral_test"
... | (in-package :cl-user)
(defpackage integral-test.init.postgres
(:use :cl
:integral)
(:export :connect-to-testdb))
(in-package :integral-test.init.postgres)
(defun connect-to-testdb ()
(disconnect-toplevel)
(connect-toplevel :postgres
:database-name "integral_test"
... |
Use new condition to report syntax error in SETF. | (in-package #:sicl-global-environment)
(defmacro setf (&environment env place new-value-form &rest more-pairs)
(cond ((null more-pairs)
(multiple-value-bind (variables
values
store-variables
writer-form
reader-form)
(sicl-env:get-setf-expansion place env)
(declare ... | (in-package #:sicl-global-environment)
(defmacro setf (&whole form &environment env place new-value-form &rest more-pairs)
(cond ((null more-pairs)
(multiple-value-bind (variables
values
store-variables
writer-form
reader-form)
(sicl-env:get-setf-expansion place env)
... |
Use explicit package marker for IN-PACKAGE. | (in-package :sicl.tags)
;;; Number of bytes in a machine word.
(cl:defparameter +machine-word-length+ 64)
;;; The basic type that raw memory contains.
(cl:deftype machine-word ()
`(cl:unsigned-byte ,+machine-word-length+))
;;; Number of bits used for first-order tag
(cl:defparameter +number-of-low-tag-bits+ 3)
;... | (cl:in-package #:sicl.tags)
;;; Number of bytes in a machine word.
(cl:defparameter +machine-word-length+ 64)
;;; The basic type that raw memory contains.
(cl:deftype machine-word ()
`(cl:unsigned-byte ,+machine-word-length+))
;;; Number of bits used for first-order tag
(cl:defparameter +number-of-low-tag-bits+ 3... |
Rename stream argument and give it a reasonable default value. | (cl:in-package #:sicl-reader)
(defparameter *syntax-trees* '())
(defun read (&optional
(input-stream *standard-input*)
(eof-error-p t)
(eof-value nil)
(recursive-p nil))
(let ((*preserve-whitespace* recursive-p)
(*syntax-trees* (cons (list nil) *syntax-trees*)))
(let ((result (r... | (cl:in-package #:sicl-reader)
(defparameter *syntax-trees* '())
(defun read (&optional
(input-stream *standard-input*)
(eof-error-p t)
(eof-value nil)
(recursive-p nil))
(let ((*preserve-whitespace* recursive-p)
(*syntax-trees* (cons (list nil) *syntax-trees*)))
(let ((result (r... |
Return NIL for all errors. | (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... |
Simplify system by using option :SERIAL T. | (cl:in-package #:asdf-user)
(defsystem :cleavir-ssa-form
:depends-on (:cleavir-utilities
:cleavir-dominance)
:components
((:file "packages")
(:file "ssa-form" :depends-on ("packages"))))
| (cl:in-package #:asdf-user)
(defsystem :cleavir-ssa-form
:depends-on (:cleavir-utilities
:cleavir-dominance)
:serial t
:components
((:file "packages")
(:file "ssa-form")))
|
Use specific package and adjust references accordingly. | (cl:in-package #:sicl-reader)
(defparameter *syntax-trees* '())
(defun read (&optional
(input-stream *standard-input*)
(eof-error-p t)
(eof-value nil)
(recursive-p nil))
(let ((*preserve-whitespace* recursive-p)
(*syntax-trees* (cons (list nil) *syntax-trees*)))
(let ((result (r... | (cl:in-package #:sicl-source-tracking-reader)
(defparameter *syntax-trees* '())
(defun sicl-reader:read
(&optional
(input-stream *standard-input*)
(eof-error-p t)
(eof-value nil)
(recursive-p nil))
(let ((sicl-reader::*preserve-whitespace* recursive-p)
(*syntax-trees* (cons (list ni... |
Fix a problem with CLISP compilation | ;; Common Lisp Script
;; Manoel Vilela
(defun reverse-digits (n)
(labels ((next (n v)
(if (zerop n)
v
(multiple-value-bind (q r)
(truncate n 10)
(next q (+ (* v 10) r))))))
(next n 0)))
(defun palindromep (n)
(= n (reverse-... | ;; Common Lisp Script
;; Manoel Vilela
(defun reverse-digits (n)
(labels ((next (n v)
(if (zerop n)
v
(multiple-value-bind (q r)
(truncate n 10)
(next q (+ (* v 10) r))))))
(next n 0)))
(defun palindromep (n)
(= n (reverse-... |
Define variable *GLOBAL-ENVIRONMENT* in the exitrinsic environment. | (cl:in-package #:sicl-extrinsic-environment)
;;; Add every global environment function into the environment.
(defun import-from-sicl-global-environment (environment)
(loop for symbol being each external-symbol in '#:sicl-global-environment
when (fboundp symbol)
do (setf (sicl-env:fdefinition symbol environment)
... | (cl:in-package #:sicl-extrinsic-environment)
;;; Add every global environment function into the environment.
(defun import-from-sicl-global-environment (environment)
(loop for symbol being each external-symbol in '#:sicl-global-environment
when (fboundp symbol)
do (setf (sicl-env:fdefinition symbol environment)
... |
Define method on REPLACE specialized to 2-NODE. | (cl:in-package #:clump-2-3-tree)
;;; This generic function can be used only on an empty tree.
(defgeneric insert (object tree))
(defmethod insert :before (object (tree tree))
(unless (null (contents tree))
(error "Do this error message better.")))
(defmethod insert (object (tree tree))
(setf (contents tree)
... | (cl:in-package #:clump-2-3-tree)
;;; This generic function can be used only on an empty tree.
(defgeneric insert (object tree))
(defmethod insert :before (object (tree tree))
(unless (null (contents tree))
(error "Do this error message better.")))
(defmethod insert (object (tree tree))
(setf (contents tree)
... |
Load a file containing the definition of the class SPECIALIZER. | (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)
... |
Increment column count in default case. | (cl:in-package #:sicl-source-tracking-reader)
(defun make-contents ()
(make-array 10
:fill-pointer 0
:element-type 'character
:adjustable t))
(defclass source-tracking-stream
(trivial-gray-streams:fundamental-character-input-stream)
((%original :initarg :original :reader original)
(%co... | (cl:in-package #:sicl-source-tracking-reader)
(defun make-contents ()
(make-array 10
:fill-pointer 0
:element-type 'character
:adjustable t))
(defclass source-tracking-stream
(trivial-gray-streams:fundamental-character-input-stream)
((%original :initarg :original :reader original)
(%co... |
Remove 2 extraneous spaces in ASD file. | (asdf:defsystem #:hexstream-project-template
:author "Jean-Philippe Paradis <hexstream@gmail.com>"
;; See the UNLICENSE file for details.
:license "Public Domain"
:description "I unsophistically copy/paste and rename/modify these files to start a new project, currently."
:depends-on ()
:version "0.1"... | (asdf:defsystem #:hexstream-project-template
:author "Jean-Philippe Paradis <hexstream@gmail.com>"
;; See the UNLICENSE file for details.
:license "Public Domain"
:description "I unsophistically copy/paste and rename/modify these files to start a new project, currently."
:depends-on ()
:version "0.1"
... |
Use unexported names for slot writers. | (cl:in-package #:clump-2-3-tree)
(defclass tree ()
((%contents :initform nil :accessor contents)
(%leaf-class :initarg :leaf-class :reader leaf-class)
(%2-node-class :initarg :2-node-class :reader 2-node-class)
(%3-node-class :initarg :3-node-class :reader 3-node-class)))
(defclass node ()
((%parent :ini... | (cl:in-package #:clump-2-3-tree)
(defclass tree ()
((%contents :initform nil :accessor contents)
(%leaf-class :initarg :leaf-class :reader leaf-class)
(%2-node-class :initarg :2-node-class :reader 2-node-class)
(%3-node-class :initarg :3-node-class :reader 3-node-class)))
(defclass node ()
((%parent :ini... |
Load a file containing the definition of the macro DEFCLASS. | (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)
... |
Change load order so WRAPPER is available to SFFI | (defpackage :cl-autowrap.asdf
(:use #:cl #:asdf))
(in-package :cl-autowrap.asdf)
(defsystem :cl-autowrap
:description "Import c2ffi specs and generate CFFI wrappers"
:author "Ryan Pavlik"
:license "BSD-2-Clause"
:version "1.0"
:depends-on (:alexandria :cffi :cl-json :cl-ppcre
:external-pro... | (defpackage :cl-autowrap.asdf
(:use #:cl #:asdf))
(in-package :cl-autowrap.asdf)
(defsystem :cl-autowrap
:description "Import c2ffi specs and generate CFFI wrappers"
:author "Ryan Pavlik"
:license "BSD-2-Clause"
:version "1.0"
:depends-on (:alexandria :cffi :cl-json :cl-ppcre
:external-pro... |
Change soname of syscall wrapper library. | ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; indent-tabs-mode: nil -*-
(in-package :common-lisp-user)
(eval-when (:compile-toplevel :load-toplevel :execute)
(asdf:oos 'asdf:load-op :cffi-grovel))
(asdf:defsystem :iolib.syscalls
:description "Syscalls and foreign types."
:maintainer "Stelian Ionescu <sionescu... | ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; indent-tabs-mode: nil -*-
(in-package :common-lisp-user)
(eval-when (:compile-toplevel :load-toplevel :execute)
(asdf:oos 'asdf:load-op :cffi-grovel))
(asdf:defsystem :iolib.syscalls
:description "Syscalls and foreign types."
:maintainer "Stelian Ionescu <sionescu... |
Fix test to reflect change to scheme style reduce. | (describe reduce-with-lambda
(== (reduce (lambda (acc item) 0 (+ acc item)) 0 '(1 2 3)) 6))
(describe reduce-with-primitive
(== (reduce + 0 '(1 2 3)) 6))
(describe reduce-building-a-list
(== (reduce (lambda (l i) (cons i l)) '() '(1 2 3 4)) '(4 3 2 1))) | (describe reduce-with-lambda
(== (reduce (lambda (acc item) 0 (+ acc item)) 0 '(1 2 3)) 6))
(describe reduce-with-primitive
(== (reduce + 0 '(1 2 3)) 6))
(describe reduce-building-a-list
(== (reduce (lambda (l i) (cons i l)) '() '(1 2 3 4)) '(4 3 2 . 1))
(== (reduce list '() '(1 2 ... |
Test finding multiple package versions. | (in-package :cl-user)
(prove:plan nil)
(defvar *test-package-name* "hello")
(defvar *test-complex-package-name* "nyxt")
(prove:subtest "Package list"
(prove:ok (< 0 (length (ospama:list-packages))))
(prove:ok (typep (first (ospama:list-packages)) 'ospama:os-package)))
(prove:subtest "Find package"
(prove:is (... | (in-package :cl-user)
(prove:plan nil)
(defvar *test-package-name* "hello")
(defvar *test-complex-package-name* "nyxt")
(defvar *multi-version-package-name* "linux-libre")
(prove:subtest "Package list"
(prove:ok (< 0 (length (ospama:list-packages))))
(prove:ok (typep (first (ospama:list-packages)) 'ospama:os-pac... |
Comment out the in-package form by default | (defpackage #:local-time.system
(:use :common-lisp :asdf))
(in-package #:local-time.system)
(defsystem :local-time
:name "local-time"
:version "0.9.1"
:author "Daniel Lowe <dlowe@sanctuary.org>"
:description "A library for manipulating dates and times, based on a paper by Erik Naggum"
:components ((:file ... | (defpackage #:local-time.system
(:use :common-lisp :asdf))
(in-package #:local-time.system)
(defsystem :local-time
:name "local-time"
:version "0.9.1"
:author "Daniel Lowe <dlowe@sanctuary.org>"
:description "A library for manipulating dates and times, based on a paper by Erik Naggum"
:components ((:file ... |
Add type-checking, type-casting functions to package exports | ;;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: BIT-SMASHER; Base: 10 -*-
;;;; packages.lisp
;;;; Copyright (c) 2014 "the Phoeron" Colin J.E. Lupton <//thephoeron.com>
;;;; See LICENSE for additional information.
(in-package :cl-user)
(defpackage #:bit-smasher
(:nicknames #:bitsmash)
(:use :cl :cl-user :ironc... | ;;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: BIT-SMASHER; Base: 10 -*-
;;;; packages.lisp
;;;; Copyright (c) 2014 "the Phoeron" Colin J.E. Lupton <//thephoeron.com>
;;;; See LICENSE for additional information.
(in-package :cl-user)
(defpackage #:bit-smasher
(:nicknames #:bitsmash)
(:use :cl :cl-user :ironc... |
Define a function for defining ALLOCATE-GENERAL-INSTANCE. | (cl:in-package #:sicl-boot)
(defclass header ()
((%class :initarg :class :accessor class)
(%rack :initarg :rack :reader rack)))
(defun phase3 (boot)
(let ((c (c1 boot))
(r (r2 boot)))
(define-effective-slot-definition-class boot)
(ld "../CLOS/class-finalization-support.lisp" c r)
(export-to-host '... | (cl:in-package #:sicl-boot)
(defclass header ()
((%class :initarg :class :accessor class)
(%rack :initarg :rack :reader rack)))
(defun define-allocate-general-instance (env)
(setf (sicl-genv:fdefinition 'sicl-clos:allocate-general-instance env)
(lambda (class size)
(make-instance 'header
:class class
... |
Load file containing support code for class finalization. | (cl:in-package #:sicl-boot)
(defun phase3 (boot)
(let ((c (c1 boot))
(r (r2 boot)))
(define-effective-slot-definition-class boot)))
| (cl:in-package #:sicl-boot)
(defun phase3 (boot)
(let ((c (c1 boot))
(r (r2 boot)))
(define-effective-slot-definition-class boot)
(ld "../CLOS/class-finalization-support.lisp" c r)))
|
Remove log4cl from the dependencies for the freetype system | #| dummy system to make Quicklisp happy |#
(defsystem #:mcclim-fonts)
(defsystem #:mcclim-fonts/truetype
:depends-on (#:clim-basic #:zpb-ttf #:cl-vectors #:cl-paths-ttf #:cl-aa #:alexandria)
:components ((:static-file "README.md")
(:file "truetype-package")
(:file "fontconfig"... | #| dummy system to make Quicklisp happy |#
(defsystem #:mcclim-fonts)
(defsystem #:mcclim-fonts/truetype
:depends-on (#:clim-basic #:zpb-ttf #:cl-vectors #:cl-paths-ttf #:cl-aa #:alexandria)
:components ((:static-file "README.md")
(:file "truetype-package")
(:file "fontconfig"... |
Replace dependency mpc with maxpc. | ;;;; System definition for PURL.
(defpackage purl-asd
(:documentation
"System definition for PURL.")
(:use :cl :asdf))
(in-package :purl-asd)
(defsystem purl
:description "Parse and print URLs as described in RFC 1738."
:author "Max Rottenkolber <max@mr.gy>"
:license "GNU AGPL"
:version "1.1"
:compo... | ;;;; System definition for PURL.
(defpackage purl-asd
(:documentation
"System definition for PURL.")
(:use :cl :asdf))
(in-package :purl-asd)
(defsystem purl
:description "Parse and print URLs as described in RFC 1738."
:author "Max Rottenkolber <max@mr.gy>"
:license "GNU AGPL"
:version "1.1"
:compo... |
Fix incorrect terminology in PRINT-OBJECT methods. | (cl:in-package #:sicl-boot)
(defmethod print-object ((class standard-class) stream)
(format stream
"#<Ersatz standard class ~s>"
(sicl-clos:class-name class)))
(defmethod print-object ((class sicl-clos:built-in-class) stream)
(format stream
"#<Ersatz built-in class ~s>"
(sicl-clos:class-name class)))
... | (cl:in-package #:sicl-boot)
(defmethod print-object ((class standard-class) stream)
(format stream
"#<Bridge standard class ~s>"
(sicl-clos:class-name class)))
(defmethod print-object ((class sicl-clos:built-in-class) stream)
(format stream
"#<Bridge built-in class ~s>"
(sicl-clos:class-name class)))
... |
Set the Google jump URL to the proper thing | (in-package :lispkit)
(defparameter *jumps* (make-hash-table :test #'equal))
(defun defjump (place prefix url)
(setf (gethash prefix place) url))
(defjump *jumps* "g" "http://google.com/search?=~a")
(defun lookup-jump (s table)
(gethash s table))
(defun extract-jump-str (s)
(split-sequence " " s :test #'str... | (in-package :lispkit)
(defparameter *jumps* (make-hash-table :test #'equal))
(defun defjump (place prefix url)
(setf (gethash prefix place) url))
(defjump *jumps* "g" "http://google.com/search?q=~a")
(defun lookup-jump (s table)
(gethash s table))
(defun extract-jump-str (s)
(split-sequence " " s :test #'st... |
Define ASDF system in package ASDF-USER. | (in-package #:cl-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" ... | (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... |
Fix symbol exporting from IOLIB.BASE | ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; indent-tabs-mode: nil -*-
;;;
;;; --- Package definition.
;;;
(in-package :common-lisp-user)
(defpackage :iolib.base
(:use #:common-lisp :alexandria)
(:shadow #:defun #:defmethod
#:defmacro #:define-compiler-macro)
(:export #:return* #:defun #:defmethod
... | ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; indent-tabs-mode: nil -*-
;;;
;;; --- Package definition.
;;;
(in-package :common-lisp-user)
(defpackage :iolib.base
(:use #:common-lisp :alexandria)
(:shadow #:defun #:defmethod
#:defmacro #:define-compiler-macro)
(:export #:return* #:defun #:defmethod
... |
Stop stack overflow when loaded from sys.int. | (defun cal (file)
(handler-bind
;; automatically choose 'smash existing class' when loading
((t (lambda (c)
(invoke-restart 'continue))))
(sys.int::cal file)))
(cal "home/med/package.lisp")
(cal "home/med/line.lisp")
(cal "home/med/mark.lisp")
(cal "home/med/editor.lisp")
(cal "home/med/bu... | (sys.int::cal "home/med/package.lisp")
(in-package :med)
(defmacro awhen (cond &body body)
`(let ((it ,cond))
(when it
,@body)))
(defun cal (file)
(handler-bind
;; automatically choose 'smash existing class' when loading
((t (lambda (c)
(declare (ignore c))
(awhen (f... |
Save new definition in environment. | (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... |
Put deprecated symbols into extra export | ;; -*- Syntax: Ansi-Common-Lisp; Mode: lisp; -*-
(defpackage cl-dot
(:use :common-lisp)
(:export #:attributed #:node
#:*dot-path*
#:*neato-path*
#:graph-object-knows-of #:graph-object-node
#:graph-object-points-to #:graph-object-pointed-to-by
#:generate-graph-... | ;; -*- Syntax: Ansi-Common-Lisp; Mode: lisp; -*-
(defpackage cl-dot
(:use :common-lisp)
(:export #:attributed #:node
#:*dot-path*
#:*neato-path*
#:graph-object-knows-of #:graph-object-node
#:graph-object-points-to #:graph-object-pointed-to-by
#:graph-object-ed... |
Clean up the ASD file. | ;; -*- Syntax: Ansi-Common-Lisp; Mode: lisp; -*-
(asdf:defsystem :cl-dot
:version "0.9.0"
:description "Generate Dot Output from Arbitrary Lisp Data"
:author "Juho Snellman <jsnell@iki.fi>"
:maintainer "Michael Weber <michaelw@foldr.org>"
:depends-on (:uiop)
:serial t
:components
((:file "package")
... | ;; -*- Syntax: Ansi-Common-Lisp; Mode: lisp; -*-
(asdf:defsystem :cl-dot
:version "0.9.0"
:description "Generate Dot Output from Arbitrary Lisp Data"
:author "Juho Snellman <jsnell@iki.fi>"
:maintainer "Michael Weber <michaelw@foldr.org>"
:depends-on (:uiop)
:serial t
:components
((:file "package")
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.