;; load them all by doing (require 'cedet). This is mostly for
;; compatibility with the upstream, stand-alone CEDET distribution.
-(eval-when-compile
- (require 'cl))
-
(declare-function inversion-find-version "inversion")
(defconst cedet-version "2.0"
;; This provides a dired interface to EDE, allowing users to modify
;; their project file by adding files (or whatever) directly from a
;; dired buffer.
-(eval-when-compile (require 'cl))
+
+;;; Code:
+
(require 'easymenu)
(require 'dired)
(require 'ede)
-;;; Code:
(defvar ede-dired-keymap
(let ((map (make-sparse-keymap)))
(define-key map ".a" 'ede-dired-add-to-target)
(require 'ede)
(require 'ede/make)
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(declare-function semanticdb-file-table-object "semantic/db")
(declare-function semanticdb-needs-refresh-p "semantic/db")
;; detected build on source directory
(and (file-exists-p (expand-file-name ".config" dir)) dir)
;; use configuration
- (case project-linux-build-directory-default
+ (cl-case project-linux-build-directory-default
(same dir)
(ask (read-directory-name "Select Linux' build directory: " dir)))))
the result is `ask', let the user choose from architectures found
in DIR."
(let ((arch (ede-linux--detect-architecture bdir)))
- (case arch
+ (cl-case arch
(ask
(completing-read "Select target architecture: "
(ede-linux--get-archs dir)))
"Returns a list with include directories.
Returned directories might not exist, since they are not created
until Linux is built for the first time."
- (map 'list
+ (cl-map 'list
(lambda (elem) (format (concat (car elem) "/" (cdr elem)) arch))
;; XXX: taken from the output of "make V=1"
(list (cons dir "arch/%s/include")
;; 1) Insert distribution source variables for targets
;; 2) Insert user requested rules
-(eval-when-compile (require 'cl))
(require 'ede/proj)
(require 'ede/proj-obj)
(require 'ede/proj-comp)
;; To write a method that inserts a variable or rule for a compiler
;; based object, wrap the body of your call in `ede-compiler-only-once'
-(eval-when-compile (require 'cl))
(require 'ede) ;source object
(require 'ede/autoconf-edit)
;; This misc target lets the user link in custom makefiles to an EDE
;; project.
-(eval-when-compile (require 'cl))
(require 'ede/pmake)
(require 'ede/proj-comp)
;; Handles a superclass of target types which create object code in
;; and EDE Project file.
-(eval-when-compile (require 'cl))
(require 'ede/proj)
(declare-function ede-pmake-varname "ede/pmake")
;;
;; Handle building programs from object files in and EDE Project file.
-(eval-when-compile (require 'cl))
(require 'ede/pmake)
(require 'ede/proj-obj)
;;; Code:
-(eval-when-compile (require 'cl))
(require 'speedbar)
(require 'eieio-speedbar)
(require 'ede)
;;; Code:
-(eval-when-compile (require 'cl))
-
(require 'find-func)
;; For find-function-regexp-alist. It is tempting to replace this
;; ‘require’ by (defvar find-function-regexp-alist) and
;; constant. These need to be returned as there would be no
;; other possible completions.
-(eval-when-compile (require 'cl))
(require 'semantic)
(require 'semantic/format)
(require 'semantic/ctxt)
;; `semantic-complete-inline-tag-engine' will complete text in
;; a buffer.
-(eval-when-compile (require 'cl))
(require 'semantic)
(require 'eieio-opt)
(require 'semantic/analyze)
;; Each parser must implement the interface and override any methods as needed.
;;
-(eval-when-compile (require 'cl))
(require 'semantic)
(require 'eieio)
(require 'cl-generic)
;;
;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(require 'semantic)
(require 'semantic/decorate)
(require 'semantic/tag-ls)
(defsubst semantic-decoration-set-property (deco property value)
"Set the DECO decoration's PROPERTY to VALUE.
Return DECO."
- (assert (semantic-decoration-p deco))
+ (cl-assert (semantic-decoration-p deco))
(semantic-overlay-put deco property value)
deco)
(defsubst semantic-decoration-get-property (deco property)
"Return the DECO decoration's PROPERTY value."
- (assert (semantic-decoration-p deco))
+ (cl-assert (semantic-decoration-p deco))
(semantic-overlay-get deco property))
(defsubst semantic-decoration-set-face (deco face)
(defsubst semantic-decoration-set-priority (deco priority)
"Set the priority of the decoration DECO to PRIORITY.
Return DECO."
- (assert (natnump priority))
+ (cl-assert (natnump priority))
(semantic-decoration-set-property deco 'priority priority))
(defsubst semantic-decoration-priority (deco)
(defsubst semantic-decoration-move (deco begin end)
"Move the decoration DECO on the region between BEGIN and END.
Return DECO."
- (assert (semantic-decoration-p deco))
+ (cl-assert (semantic-decoration-p deco))
(semantic-overlay-move deco begin end)
deco)
\f
(defun semantic-decorate-clear-tag (tag &optional deco)
"Remove decorations from TAG.
If optional argument DECO is non-nil, remove only that decoration."
- (assert (or (null deco) (semantic-decoration-p deco)))
+ (cl-assert (or (null deco) (semantic-decoration-p deco)))
;; Clear primary decorations.
;; For now, just unhighlight the tag. How to deal with other
;; primary decorations like invisibility, etc. ? Maybe just
;;; Code:
-(eval-when-compile (require 'cl))
(require 'semantic)
(require 'eieio-base)
(require 'ring)
;;; Code:
(require 'semantic/wisent)
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
\f
;;;; -------------------
;;;; Misc. useful things
(progn
(if (wisent-check-$N body n)
;; Accumulate $i symbol
- (pushnew body found :test #'equal))
+ (cl-pushnew body found :test #'equal))
(cons found body))
;; BODY is a list, expand inside it
(let (xbody sexpr)
;; $i symbol
((wisent-check-$N sexpr n)
;; Accumulate $i symbol
- (pushnew sexpr found :test #'equal))
+ (cl-pushnew sexpr found :test #'equal))
)
;; Accumulate expanded forms
(setq xbody (nconc xbody (list sexpr))))
(require 'semantic/ctxt)
(require 'semantic/format)
-(eval-when-compile
- (require 'cl))
-
;;; Customization
;;
;; + first argument is self
(when (and (> (length (semantic-tag-function-arguments tag)) 0)
(string= (semantic-tag-name
- (first (semantic-tag-function-arguments tag)))
+ (car (semantic-tag-function-arguments tag)))
"self"))
(semantic-tag-put-attribute tag :parent "dummy"))
;; The output are a series of EIEIO objects which represent the
;; templates in a way that could be inserted later.
-(eval-when-compile (require 'cl))
(require 'semantic)
(require 'eieio)
(require 'cl-generic)
;;; CLASSES
-(eval-when-compile (require 'cl))
(require 'eieio)
(require 'cl-generic)
(require 'srecode)
;;; Code:
-(eval-when-compile (require 'cl))
(require 'eieio)
(require 'srecode/dictionary)
(require 'srecode/insert)
projects / emacs.git / commitdiff