Commit 59b87521 authored by Pascal J. Bourguignon's avatar Pascal J. Bourguignon

Implemented IBCL completely.

parent 718cb37c
......@@ -444,6 +444,7 @@ and restart the scheduling then.")
(format nil ,control-string ,@arguments))))
,@body)
`(macrolet ((debug-format (control-string &rest arguments)
(declare (ignore control-string arguments))
`(progn)))
,@body)))
......
......@@ -281,10 +281,11 @@ DO: Sets the elementSize() parameter.
"
RETURN: The number of arrangement of k elements (without repeat) taken amongst n.
"
(loop with r = 1
for i from (- n k -1) to m
do (setf r (* r i))
finally (return r)))
(loop
:with r = 1
:for i :from (- n k -1) :to n
:do (setf r (* r i))
:finally (return r)))
(defmethod compute-cardinal ((self arrangement-sans-repeat))
......
......@@ -109,7 +109,7 @@ CONTENTS: A p-list containing the initial key value pairs.
(:documentation "RETURN: the number of associations in the DICTIONARY."))
(defsetf dictionary-get (dictionary key &optional default) (new-value)
(declare (ignore default))
(declare (ignorable default))
`(dictionary-set ,dictionary ,key ,new-value))
......
......@@ -167,17 +167,20 @@ RETURN: A list of the selected symbols.
(let ((pack (find-package package)))
(if pack
(let ((sl '()))
(and exported
(do-external-symbols (s pack)
(push s sl)))
(when exported
(do-external-symbols (s pack)
(push s sl)))
(do-symbols (s pack)
(when (or all
(and homely (eq pack (symbol-package s)))
(and homely (eq pack (symbol-package s)))
(and shadowing (member s (package-shadowing-symbols pack))))
(pushnew s sl)))
(if sorted (sort sl (function string<)) sl))
(if sorted
(sort sl (function string<))
sl))
(error "No package ~S" package))))
(defun list-all-symbols (package &key (sorted t))
"
RETURN: A list of all the symbols present in the PACKAGE.
......@@ -186,6 +189,7 @@ SORTED: Whether the result list is sorted (default T).
"
(list-symbols package :sorted sorted :all t))
(defun list-external-symbols (package &key (sorted t))
"
RETURN: A list of all the symbols exported from the PACKAGE.
......@@ -613,39 +617,40 @@ STEAL: If another package has already this nickname, then steal it.
FORCE: If another package has this nickname as package name, then steal it.
RETURN: The package designated by PACKAGE.
"
;; !!! The consequences are undefined if new-name or any new-nickname
;; !!! conflicts with any existing package names. Therefore we use a temp name.
(verbose "~&# ADDING TO PACKAGE ~S~%
~&# THE NICKNAME ~S~%" package nickname)
(let* ((pack (find-package package))
(package (if pack
(package-name pack)
(error "~S: There is no package named \"~A\"."
'add-nickname package)))
(packname (if pack
(package-name pack)
(error "~S: There is no package named \"~A\"."
'add-nickname package)))
(nickpack (find-package nickname))
(cnt 0))
(flet ((temp-name ()
(loop
:for name = (format nil "TEMP-~A-~A" package (incf cnt))
:for name = (format nil "TEMP-~A-~A" packname (incf cnt))
:while (find-package name)
:finally (return name))))
(cond
((eq nickpack pack) (verbose "~&# ALREADY GOT IT~%"))
((null nickpack)
;; The consequences are undefined if new-name or any
;; new-nickname conflicts with any existing package names.
;; Therefore we use a temp name.
(let ((temp (temp-name))
(nicks (cons nickname (copy-seq (package-nicknames pack)))))
(rename-package pack temp nicks)
(rename-package pack package nicks))
(when (built-in-p package)
(rename-package pack temp nicks)
(rename-package pack packname nicks))
(when (built-in-p packname)
(pushnew nickname *built-in-packages* :test (function string=))))
((and force (string= nickname (package-name nickpack)))
(let ((nicks (or (package-nicknames nickpack)
(list (gen-old-name nickname)))))
(rename-package nickpack (first nicks) (rest nicks))
(add-nickname package nickname)))
(add-nickname pack nickname)))
((and (or steal force) (string/= nickname (package-name nickpack)))
(remove-nickname nickpack nickname)
(add-nickname package nickname))
(add-nickname pack nickname))
(force
(error "~S is already a nickname of the package ~S" nickname nickpack))
(t
......
......@@ -240,9 +240,9 @@ FILE-NAME-LIST: A list of file pathnames, C++ sources and headers."))
;;----------------------------------------------------------------------
(defclass c++token-filter (token-filter)
((source :accessor source :initform nil)
(doquotes :accessor doquotes :initform t)
(dotrace :accessor dotrace :initform nil)))
((c++source :accessor c++source :initform nil)
(doquotes :accessor doquotes :initform t)
(dotrace :accessor dotrace :initform nil)))
(defmethod do-quotes ((self c++token-filter) flag)
(let ((old (doquotes self)))
......@@ -250,30 +250,30 @@ FILE-NAME-LIST: A list of file pathnames, C++ sources and headers."))
old))
(defmethod set-source ((self c++token-filter) (input look-ahead-char-filter))
(setf (source self) input))
(setf (c++source self) input))
(defmethod read-a-token ((self c++token-filter))
;; * '::' ( ) { } ;; '->' "<char>*" CR '/*' '*/' '//'
(let ((r (let ((s nil) (c (read-a-char (source self))))
(let ((r (let ((s nil) (c (read-a-char (c++source self))))
;; skip spaces;; note we don't skip new-lines here.
(loop while (equal (char-kind c) 'space) do
(setq c (read-a-char (source self))))
(setq c (read-a-char (c++source self))))
(if (equal 'eof c)
'eof
(let ((kind (char-kind c)))
(setq s (cons c s))
(cond
((equal kind 'letter)
(setq c (next-char (source self)))
(setq c (next-char (c++source self)))
(setq kind (char-kind c))
(loop while (or (equal kind 'letter)
(equal kind 'digit)) do
(setq c (read-a-char (source self)))
(setq c (read-a-char (c++source self)))
(setq s (cons c s))
(setq c (next-char (source self)))
(setq c (next-char (c++source self)))
(setq kind (char-kind c))))
((equal kind 'digit)
(setq c (next-char (source self)))
(setq c (next-char (c++source self)))
(setq kind (char-kind c))
(loop while (or (equal kind 'digit)
(equal c (character "."))
......@@ -284,13 +284,13 @@ FILE-NAME-LIST: A list of file pathnames, C++ sources and headers."))
(equal c (character "x"))
(equal c (character "X"))
) do
(setq c (read-a-char (source self)))
(setq c (read-a-char (c++source self)))
(setq s (cons c s))
(setq c (next-char (source self)))
(setq c (next-char (c++source self)))
(setq kind (char-kind c))))
((and (doquotes self) (equal kind 'quote))
(let ((term c))
(setq c (read-a-char (source self)))
(setq c (read-a-char (c++source self)))
(loop while (not (or (equal 'eof c)
(equal (char-kind c) 'new-line)
(equal term c))) do
......@@ -298,42 +298,42 @@ FILE-NAME-LIST: A list of file pathnames, C++ sources and headers."))
(if (char= (character "\\") c)
(progn
(setq c (read-a-char
(source self)))
(c++source self)))
(setq s (cons c s))))
(setq c (read-a-char (source self))))
(setq c (read-a-char (c++source self))))
(if (equal term c)
(setq s (cons c s)))))
((equal kind 'new-line)
(setq c (next-char (source self)))
(setq c (next-char (c++source self)))
(loop while (equal (char-kind c) 'new-line) do
(setq c (read-a-char (source self)))
(setq c (read-a-char (c++source self)))
(setq s (cons c s))
(setq c (next-char (source self)))))
(setq c (next-char (c++source self)))))
((char= (character "-") c)
(if (char= (character ">")
(next-char (source self)))
(next-char (c++source self)))
(progn
(setq c (read-a-char (source self)))
(setq c (read-a-char (c++source self)))
(setq s (cons c s)))))
((char= (character "/") c)
(if (or (char= (character "/")
(next-char (source self)))
(next-char (c++source self)))
(char= (character "*")
(next-char (source self))))
(next-char (c++source self))))
(progn
(setq c (read-a-char (source self)))
(setq c (read-a-char (c++source self)))
(setq s (cons c s)))))
((char= (character "*") c)
(if (char= (character "/")
(next-char (source self)))
(next-char (c++source self)))
(progn
(setq c (read-a-char (source self)))
(setq c (read-a-char (c++source self)))
(setq s (cons c s)))))
((char= (character ":") c)
(if (char= (character ":")
(next-char (source self)))
(next-char (c++source self)))
(progn
(setq c (read-a-char (source self)))
(setq c (read-a-char (c++source self)))
(setq s (cons c s))))))
(concatenate 'string (reverse s)))))))
(if (dotrace self)
......@@ -565,8 +565,7 @@ FILE-NAME-LIST: A list of file pathnames, C++ sources and headers."))
(cond
((stringp file-name-list) (parse self (list file-name-list)))
((null file-name-list) t)
(t (let (
(source (make-instance 'file-filter))
(t (let ((source (make-instance 'file-filter))
(lasource (make-instance 'look-ahead-char-filter))
(tokens (make-instance 'c++token-filter))
(skip-ccomments (make-instance 'ccomment-filter))
......@@ -574,7 +573,6 @@ FILE-NAME-LIST: A list of file pathnames, C++ sources and headers."))
(preprocess (make-instance 'cpreprocessor-filter))
(nonltokens (make-instance 'c++nonltoken-filter))
(analysis (make-instance 'look-ahead-token-filter)))
(set-file source (open (car file-name-list)))
(push-on-filter lasource source)
(set-source tokens lasource)
......
......@@ -84,7 +84,7 @@
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;****************************************************************************
(cl:in-package "COMMON-LISP-USER")
(in-package "COMMON-LISP-USER")
(defpackage "COM.INFORMATIMAGO.COMMON-LISP.HEAP.HEAP"
(:use "COMMON-LISP"
"COM.INFORMATIMAGO.COMMON-LISP.HEAP.MEMORY")
......
;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: cl-saving-defines.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; See :documentation of package below.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <pjb@informatimago.com>
;;;;MODIFICATIONS
;;;; 2012-08-07 <PJB> Extracted from ibcl.lisp and restructured.
;;;; 2006-07-01 <PJB> Added deftype, defclass.
;;;; 2006-05-04 <PJB> Added this header. Augmented.
;;;;BUGS
;;;; Missing some def* macros, like define-symbol-macro,
;;;; defconditions, defmethod, defgeneric, etc.
;;;; Missing some functions, like make-package, rename-package, etc.
;;;; See also MOP functions.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2012 - 2012
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(defpackage "COM.INFORMATIMAGO.COMMON-LISP.LISP.CL-SAVING-DEFINES"
(:use "COMMON-LISP"
"COM.INFORMATIMAGO.COMMON-LISP.LISP.SOURCE"
"COM.INFORMATIMAGO.COMMON-LISP.LISP-SEXP.SOURCE-FORM")
(:shadow "DEFPACKAGE"
"DEFINE-COMPILER-MACRO" "DEFINE-MODIFY-MACRO"
"DEFINE-SETF-EXPANDER" "DEFMACRO" "DEFSETF"
"DEFVAR" "DEFPARAMETER"
"DEFCONSTANT" "DEFINE-SYMBOL-MACRO"
"DEFSTRUCT" "DEFCLASS"
"DEFTYPE" "DEFINE-CONDITION"
"DEFINE-METHOD-COMBINATION" "DEFGENERIC"
"DEFMETHOD" "DEFUN")
(:export "DEFPACKAGE"
"DEFINE-COMPILER-MACRO" "DEFINE-MODIFY-MACRO"
"DEFINE-SETF-EXPANDER" "DEFMACRO" "DEFSETF"
"DEFVAR" "DEFPARAMETER"
"DEFCONSTANT" "DEFINE-SYMBOL-MACRO"
"DEFSTRUCT" "DEFCLASS"
"DEFTYPE" "DEFINE-CONDITION"
"DEFINE-METHOD-COMBINATION" "DEFGENERIC"
"DEFMETHOD" "DEFUN")
(:documentation "
This package exports macros wrapping the CL def* macros that save the
source form.
Copyright Pascal J. Bourguignon 2006 - 2012
This package is provided under the Afero General Public License 3.
See the source file for details.
"))
(in-package "COM.INFORMATIMAGO.COMMON-LISP.LISP.CL-SAVING-DEFINES")
(cl:defmacro define-wrapper-macro (defname (name &rest lambda-list) source-type)
(let ((source (gensym)))
`(cl:defmacro ,defname ,(list* '&whole source (cons name lambda-list))
(declare (ignorable ,@(mapcar (function parameter-name)
(lambda-list-parameters
(parse-lambda-list (cons name lambda-list) :macro)))))
`(progn
(setf (source ',,name ',,source-type) ',,source)
,(cons (intern (string (first ,source)) "COMMON-LISP") (rest ,source))))))
(define-wrapper-macro defpackage (name &rest options) :package)
(define-wrapper-macro defvar (name &optional value docstring) :variable)
(define-wrapper-macro defparameter (name value &optional docstring) :variable)
(define-wrapper-macro defconstant (name value &optional docstring) :variable)
(define-wrapper-macro define-symbol-macro (name expansion) :variable)
(cl:defmacro defstruct (&whole form name-and-options &rest fields)
(declare (ignorable fields))
`(progn
(setf (source ',(if (consp name-and-options)
(car name-and-options)
name-and-options)
:type) ',form)
,(cons 'cl:defstruct (rest form))))
(define-wrapper-macro deftype (name lambda-list &body body) :type)
(define-wrapper-macro defclass (name parents slots &rest options) :type)
(define-wrapper-macro define-condition (name parents slots &rest options) :type)
(define-wrapper-macro define-compiler-macro (name lambda-list &body body) :compiler-macro)
(define-wrapper-macro define-modify-macro (name lambda-list fun &optional docstring) :function)
(define-wrapper-macro define-setf-expander (name lambda-list &body body) :function)
(define-wrapper-macro defsetf (name lambda-list &body body) :function)
(define-wrapper-macro defmacro (name lambda-list &body body) :function)
(define-wrapper-macro defun (name lambda-list &body body) :function)
(define-wrapper-macro defgeneric (name lambda-list &rest options) :function)
(define-wrapper-macro define-method-combination (name &rest options) :method-combination)
(cl:defmacro defmethod (&whole form name &rest arguments)
(let ((qualifiers (loop
:while (atom (first arguments))
:collect (pop arguments))))
(destructuring-bind (lambda-list &body body) arguments
(declare (ignorable body))
(let ((specializers (mapcar
(lambda (parameter)
(if (parameter-specializer-p parameter)
(parameter-specializer parameter)
't))
(lambda-list-mandatory-parameters
(parse-lambda-list lambda-list :specialized)))))
`(progn
(setf (source '(,name ,qualifiers ,specializers) :method) ',form)
,(cons 'cl:defmethod (rest form)))))))
;;;; THE END ;;;;
;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.common-lisp.lisp.ibcl.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.common-lisp.lisp.ibcl library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <pjb@informatimago.com>
;;;;MODIFICATIONS
;;;; 2010-10-31 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2012
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem :com.informatimago.common-lisp.lisp.ibcl
;; system attributes:
:description "IBCL and utilities."
:long-description "
This system provides three packages:
COM.INFORMATIMAGO.COMMON-LISP.LISP.SOURCE keep sources sexps.
COM.INFORMATIMAGO.COMMON-LISP.LISP.CL-SAVING-DEFINES def* macro saving sources.
COM.INFORMATIMAGO.COMMON-LISP.LISP.IBCL IBCL package.
"
:author "Pascal J. Bourguignon <pjb@informatimago.com>"
:maintainer "Pascal J. Bourguignon <pjb@informatimago.com>"
:licence "AGPL3"
;; component attributes
:name "Informatimago Common Lisp Lisp Language Stuff"
:version "1.0.0"
:properties ((#:author-email . "pjb@informatimago.com")
(#:date . "Summer 2012")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.common-lisp.lisp.ibcl/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.lisp-sexp")
:components ((:file "source")
(:file "cl-saving-defines" :depends-on ("source"))
(:file "ibcl" :depends-on ("source" "cl-saving-defines"))))
;;;; THE END ;;;;
......@@ -2,6 +2,8 @@
cf. how clisp debugger is written?
Those are a few notes about ibcl, stepper and future possible projects.
Purpose
#######
......@@ -266,6 +268,84 @@ even this function call: ::
- Source of "x" is function call ^2 in function F.
Saving sources
--------------
The COM.INFORMATIMAGO.COMMON-LISP.LISP.CL-SAVING-DEFINES package
defines CL macros to record source sexp.
::
---- -------------------------- ----------- ----------- ------
time source-type name
---- -------------------------- ----------- ----------- ------
done DEFPACKAGE :package string
actually we could generate the defpackage form
from the package object.
done DEFVAR :variable symbol
done DEFPARAMETER :variable symbol
done DEFCONSTANT :variable symbol
done DEFINE-SYMBOL-MACRO :variable symbol
done DEFSTRUCT :type symbol
constructors, predicates and accessors:
we won't trace into them.
done DEFCLASS :type symbol
accessors: we won't trace into them.
done DEFTYPE :type symbol
done DEFINE-CONDITION runtime :type symbol
accessors and report functions:
we won't trace into them.
done DEFINE-COMPILER-MACRO compilation symbol
can be :compiler-macro or :setf-compiler-macro
done DEFINE-MODIFY-MACRO compilation :function symbol
done DEFINE-SETF-EXPANDER compilation :setf-mac symbol
done DEFSETF compilation :setf-mac symbol
done DEFMACRO compilation :function symbol
done DEFINE-METHOD-COMBINATION runtime :meth-comb symbol
done DEFUN runtime :function symbol or (setf symbol)
done DEFGENERIC runtime :function symbol or (setf symbol)
DEFMETHOD runtime :method symbol or (setf symbol)
methods need method-qualifiers and specializer in addition to the symbol.
---- -------------------------- ----------- ----------- ------
We store the source forms to the symbol-plist.
When the stepper needs to walk the source to generate a stepping
function, it takes the source form, process it, and redefine the
symbol, putting a property indicating that the stepped form is
the current definition.
When we want to remove the stepping form, we just re-evaluate the
source form. ⚠ this works only for toplevel forms, not for clozure:
(let ((x 42))
(defun f () x))
--> (source 'f 'function :package *package*) --> (defun f () x)
(source '(m () (t t)) :method) --> (defmethod m (x y) …)
(source '(m () (t t)) :setf-method) --> (defmethod (setf m) (new-value x) …)
(source '((setf m) () (t t)) :method) --> (defmethod (setf m) (new-value x) …)
(source '(m (:around) (string integer)) :method) --> (defmethod m :around ((x string) (n integer)) …)
remove-method
rename-package
delete-package
Tools
######
......
This diff is collapsed.
This diff is collapsed.
......@@ -47,8 +47,8 @@ Implements a Common Lisp stepper.
#|Random notes.
Note
====
Terminology
===========
The term "to trace" here doen't mean CL:TRACE, but executing forms
while printing each subexpressions before evaluating them and printing
......@@ -97,24 +97,28 @@ Lazy Option
In the lazy option, we only instrument the forms and the functions or
methods needed to perform he stepping or tracing. This require
keeping around the source forms. This can be done by IBCL.
keeping around the source forms.
But IBCL only keeps the source of predefined macros (a subset of the
CL def* macros), so we may miss user defined macros
(define-such-and-such…), unless they expand to CL def* macros.
Macro Option
------------
A macro that would expand to something like: ::
IBCL only keeps the source of predefined macros (a subset of the CL
def* macros), so we may miss user defined macros (define-such-and-such…),
unless they expand to CL def* macros.
With a macro that would expand to something like: ::
(progn
(setf (gethash 'some-key *some-hash*) (some-object (lambda () 'some-code)))
(defun something ()
'some-code))
would instrument the function ``something``, but not the anonymous
we would instrument the function ``something``, but not the anonymous
function or code possibly returned by the ``some-object`` function.
Problems
Note
----------
In ccl, a macro like cl:defmethod expands to implementation specific
......@@ -123,6 +127,8 @@ functions passing lambda expressions or other code chunks as data.
This would prevent their instrumenting by IBCL-like macros.
Operation
-------------
|#
;;;----------------------------------------------------------------------
;;;
......
......@@ -32,7 +32,7 @@
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(cl:in-package "COM.INFORMATIMAGO.LINC")
(in-package "COM.INFORMATIMAGO.LINC")
(make-declare com.informatimago.linc.c::variable "A variable.")
(make-declare com.informatimago.linc.c::class "A class.")
......
......@@ -32,7 +32,7 @@
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(cl:in-package "COM.INFORMATIMAGO.LINC")
(in-package "COM.INFORMATIMAGO.LINC")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
......
......@@ -46,7 +46,7 @@
;; file:///home/pjb/library/informatique/protocols_and_standards/ISO-IEC-14882/www.kuzbass.ru:8086/docs/isocpp/index.html
(cl:in-package "COM.INFORMATIMAGO.LINC")
(in-package "COM.INFORMATIMAGO.LINC")
......@@ -58,8 +58,8 @@
;; :arguments '(2 3))
;; (cl:in-package :com.informatimago.linc)
;; (cl:in-package :com.informatimago.linc.c)
;; (in-package :com.informatimago.linc)
;; (in-package :com.informatimago.linc.c)
;; c1::c2::m1(a,b,c);
;; ((:: c1 c2 m1) (a b c))
......
......@@ -32,7 +32,7 @@
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(cl:defpackage "COM.INFORMATIMAGO.LINC"
(defpackage "COM.INFORMATIMAGO.LINC"
(:use "COMMON-LISP"
"COM.INFORMATIMAGO.COMMON-LISP.CESARUM.UTILITY"
"COM.INFORMATIMAGO.COMMON-LISP.CESARUM.LIST"
......@@ -43,7 +43,7 @@
"COMPILE-LINC-FILE"
))
(cl:defpackage "COM.INFORMATIMAGO.LINC.C"
(defpackage "COM.INFORMATIMAGO.LINC.C"
(:nicknames "COM.INFORMATIMAGO.LINC.C++")
(:use))
......
......@@ -32,7 +32,7 @@
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************