Replace blocks with another block

Plain text, nothing hidden. Copy it into a file named cxblkrepl.lsp, or download it.

;;; ============================================================================
;;; CXBLKREPL - Replace blocks with another block
;;; Version 1.0.0
;;; CADXChange LISP tools - https://cadxchange.net/resources/lisp/cxblkrepl
;;; Tested in: AutoCAD (full version). Other programs that run AutoLISP may work but are not tested.
;;; Copyright (c) CADXChange. Free for personal and commercial use; do not resell or
;;; republish it as a collection. Terms: https://cadxchange.net/legal/lisp-terms
;;; ============================================================================

;; Replace the block references in NAMES by references to the block NEWNAME, at the same place, rotation,
;; scale and layer; attribute values are carried over by tag. Needs ATTREQ 0 and OSMODE 0 (the command sets them).
;; Returns how many blocks were replaced.
(defun cx:blkrepl-run (names newname / n ed rot attrs new)
  (setq n 0)
  (if (tblsearch "BLOCK" newname)
    (foreach e names
      (setq ed    (entget e)
            rot   (* (/ (if (cx:dxf 50 ed) (cx:dxf 50 ed) 0.0) pi) 180.0)
            attrs (mapcar (function (lambda (a) (cons (cx:dxf 2 (entget a)) (cx:dxf 1 (entget a))))) (cx:attribs e)))
      (command "_.-INSERT" newname
               "_X" (if (cx:dxf 41 ed) (cx:dxf 41 ed) 1.0)
               "_Y" (if (cx:dxf 42 ed) (cx:dxf 42 ed) 1.0)
               "_Z" (if (cx:dxf 43 ed) (cx:dxf 43 ed) 1.0)
               "_Rotate" rot
               (cx:dxf 10 ed))
      (setq new (entlast))
      (cx:upd new 8 (cx:dxf 8 ed))
      (if (cx:dxf 62 ed) (cx:upd new 62 (cx:dxf 62 ed)))
      (foreach a attrs (cx:att-set new (car a) (cdr a)))
      (entdel e)
      (setq n (1+ n))))
  n)

(defun c:CXBLKREPL ( / *error* cx:sv ss newname n)
  (setq *error* cx:err)
  (if (setq ss (cx:pick "\nSelect the blocks to replace: " '((0 . "INSERT"))))
    (progn
      (princ (strcat "\nBlocks in this drawing: " (cx:join (cx:block-names) ", ")))
      (setq newname (cx:ask-str "Replace with the block" "-"))
      (if (not (tblsearch "BLOCK" newname))
        (princ (strcat "\nThere is no block named " newname "."))
        (progn
          (cx:start '(("CMDECHO" . 0) ("ATTREQ" . 0) ("ATTDIA" . 0) ("OSMODE" . 0)))
          (setq n (cx:blkrepl-run (cx:ss->list ss) newname))
          (princ (strcat "\n" (itoa n) " block(s) replaced."))
          (cx:end)))))
  (princ))


;;; ---- Shared helpers (used by the command above; identical in every CADXChange tool) ----

(defun cx:dxf (code ed)
  (cdr (assoc code ed)))

;; The ATTRIB entities of a block reference, in order.
(defun cx:attribs (ins / e out)
  (setq e (entnext ins))
  (while (and e (= (cx:dxf 0 (entget e)) "ATTRIB"))
    (setq out (cons e out) e (entnext e)))
  (reverse out))

;; Change one group of an entity: (cx:upd ename 8 "LAYER1"); the group is added when missing.
(defun cx:upd (ename code value / ed old)
  (setq ed (entget ename) old (assoc code ed))
  (entmod (if old (subst (cons code value) old ed) (append ed (list (cons code value)))))
  (entupd ename))

;; The ATTRIB of a block reference with the tag TAG (any case), or nil.
(defun cx:att-find (ins tag / r)
  (foreach a (cx:attribs ins)
    (if (and (not r) (= (strcase (cx:dxf 2 (entget a))) (strcase tag))) (setq r a)))
  r)

;; Replace the text of a TEXT, ATTRIB, ATTDEF or MTEXT.
(defun cx:text-set (ename str / ed out)
  (setq ed (entget ename))
  (if (= (cx:dxf 0 ed) "MTEXT")
    (progn
      ;; MTEXT stores text in 250-character pieces: 3 groups for the first pieces, 1 for the last
      (foreach p ed (if (not (member (car p) '(1 3))) (setq out (cons p out))))
      (setq out (reverse out))
      (while (> (strlen str) 250)
        (setq out (append out (list (cons 3 (substr str 1 250)))) str (substr str 251)))
      (setq ed (append out (list (cons 1 str)))))
    (setq ed (subst (cons 1 str) (assoc 1 ed) ed)))
  (entmod ed)
  (entupd ename)
  T)

;; Set the attribute TAG of a block reference to VALUE; returns T when the block has that attribute.
(defun cx:att-set (ins tag value / a)
  (if (setq a (cx:att-find ins tag))
    (progn (cx:text-set a value) (entupd ins) T)))

;; Close the undo step and put the system variables back.
(defun cx:end ()
  (foreach v cx:sv (setvar (car v) (cdr v)))
  (command "_.UNDO" "_End")
  (setq cx:sv nil)
  (princ))

;; Error handler: restores everything, stays quiet on Esc.
(defun cx:err (msg)
  (if (> (getvar "CMDACTIVE") 0) (command))
  (cx:end)
  (if (and msg (not (wcmatch (strcase msg) "*BREAK*,*CANCEL*,*EXIT*")))
    (princ (strcat "\nError: " msg)))
  (princ))

;; Use the objects already selected, or ask the user to select; FILTER is an ssget filter list or nil.
(defun cx:pick (msg filter / ss)
  (setq ss (if filter (ssget "_I" filter) (ssget "_I")))
  (if (null ss)
    (progn
      (princ msg)
      (setq ss (if filter (ssget filter) (ssget)))))
  ss)

(defun cx:join (lst delim / out)
  (setq out "")
  (foreach s lst
    (setq out (if (= out "") s (strcat out delim s))))
  (if lst out ""))

;; 1-based position of SUB in STR at or after START, or nil.
(defun cx:find (str sub start / n i r)
  (setq n (strlen sub) i start r nil)
  (if (> n 0)
    (while (and (not r) (<= i (1+ (- (strlen str) n))))
      (if (= (substr str i n) sub) (setq r i))
      (setq i (1+ i))))
  r)

;; The names of the block definitions that can be inserted (no anonymous or xref blocks).
(defun cx:block-names (/ r out)
  (setq r (tblnext "BLOCK" T))
  (while r
    (if (and (/= (substr (cx:dxf 2 r) 1 1) "*") (not (cx:find (cx:dxf 2 r) "|" 1)))
      (setq out (cons (cx:dxf 2 r) out)))
    (setq r (tblnext "BLOCK")))
  (reverse out))

;;; Helpers that draw small things: labels and markers. See helpers.lsp for the format.

;; Ask for a string (spaces allowed) with a default; "-" means an empty string.
(defun cx:ask-str (msg def / v)
  (setq v (getstring T (strcat "\n" msg " <" def ">: ")))
  (cond ((= v "") def) ((= v "-") "") (T v)))

;; Save the system variables in VARS ((name . value) ...), set them, and open one undo step.
;; The caller declares cx:sv as a local so the saved values live exactly as long as the command.
(defun cx:start (vars)
  (setq cx:sv (mapcar (function (lambda (v) (cons (car v) (getvar (car v))))) vars))
  (command "_.UNDO" "_Begin")
  (foreach v vars (setvar (car v) (cdr v)))
  (princ))

;; Selection set to a list of entity names.
(defun cx:ss->list (ss / i out)
  (setq i 0)
  (if ss
    (repeat (sslength ss)
      (setq out (cons (ssname ss i) out)
            i   (1+ i))))
  (reverse out))

(princ "\nCXBLKREPL loaded. Type CXBLKREPL to start.")
(princ)

More commands: Blocks and attributes

• CXATTFILLFill an attribute in many blocks
• CXATTNUMNumber a block attribute in sequence
• CXATTCOPYCopy attribute values from one block to others
• CXATTVISShow or hide block attributes
• CXBLKCOUNTCount blocks by name
• CXBLKRENRename blocks in bulk
• CXBLKXPExplode blocks but keep their attribute text
• CXBLKSELSelect blocks by name or attribute value
• CXBLKATInsert a block at many places at once