Trovare e sostituire in molti testi insieme

Testo semplice, niente di nascosto. Copialo in un file chiamato cxtxtrepl.lsp oppure scaricalo.

;;; ============================================================================
;;; CXTXTREPL - Find and replace in selected texts
;;; Version 1.0.0
;;; CADXChange LISP tools - https://cadxchange.net/resources/lisp/cxtxtrepl
;;; 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 FIND by REPL in the texts of NAMES; MATCHCASE = T for an exact-case match.
;; Returns (texts-changed . replacements). Matches that run across a format code in an MTEXT are not found.
(defun cx:txtrepl-run (names find repl matchcase / n total old new mt cnt)
  (setq n 0 total 0)
  (foreach e names
    (setq old (cx:text-get e) mt (= (cx:dxf 0 (entget e)) "MTEXT") cnt 0)
    (setq new (cx:fmt-map old mt
                (function (lambda (s prev)
                  (setq cnt (+ cnt (cx:count-sub (if matchcase s (strcase s)) (if matchcase find (strcase find)))))
                  (if matchcase (cx:replace s find repl) (cx:replace-ci s find repl))))))
    (if (/= new old)
      (progn (cx:text-set e new) (setq n (1+ n) total (+ total cnt)))))
  (cons n total))

(defun c:CXTXTREPL ( / *error* cx:sv ss find repl mc r)
  (setq *error* cx:err)
  (if (setq ss (cx:pick "\nSelect texts: " '((0 . "TEXT,MTEXT"))))
    (progn
      (setq find (cx:ask-str "Find" "-"))
      (if (/= find "")
        (progn
          (setq repl (cx:ask-str "Replace with (- for nothing)" "")
                mc   (= (cx:ask-kw "Match case" "Yes No" "No") "Yes"))
          (cx:start '(("CMDECHO" . 0)))
          (setq r (cx:txtrepl-run (cx:ss->list ss) find repl mc))
          (princ (strcat "\n" (itoa (cdr r)) " replacement(s) in " (itoa (car r)) " text(s)."))
          (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 text of a TEXT, ATTRIB, ATTDEF or MTEXT (MTEXT keeps its codes).
(defun cx:text-get (ename / ed s)
  (setq ed (entget ename))
  (if (= (cx:dxf 0 ed) "MTEXT")
    (progn
      (setq s "")
      (foreach p ed (if (= (car p) 3) (setq s (strcat s (cdr p)))))
      (strcat s (cx:dxf 1 ed)))
    (cx:dxf 1 ed)))

;; Split a TEXT (MT = nil) or MTEXT (MT = T) string into ((T . "plain") (C . "format code") ...).
;; Codes are %%c-style symbols, and in MTEXT also \P, \f...; \H...; \S...; {, } and the like.
(defun cx:fmt-tokens (str mt / out plain i n c d j k)
  (setq out nil plain "" i 1 n (strlen str))
  (while (<= i n)
    (setq c (substr str i 1) k 0)
    (cond
      ((and (= c "%") (= (substr str (1+ i) 1) "%") (< (1+ i) n))
       (setq k (if (wcmatch (substr str (+ i 2) 1) "#") 5 3)))
      ((and mt (= c "\\"))
       (setq d (substr str (1+ i) 1))
       (cond
         ((= d "") (setq k 1))
         ((member d '("P" "X" "x" "L" "l" "O" "o" "K" "k" "~" "\\" "{" "}")) (setq k 2))
         ((member d '("U" "u")) (setq k 7))
         (T
          (setq j i)
          (while (and (<= j n) (/= (substr str j 1) ";")) (setq j (1+ j)))
          (setq k (if (<= j n) (1+ (- j i)) 2)))))
      ((and mt (or (= c "{") (= c "}"))) (setq k 1)))
    (if (> k 0)
      (progn
        (if (/= plain "") (setq out (cons (cons 'T plain) out) plain ""))
        (setq out (cons (cons 'C (substr str i k)) out) i (+ i k)))
      (setq plain (strcat plain c) i (1+ i))))
  (if (/= plain "") (setq out (cons (cons 'T plain) out)))
  (reverse out))

;; Apply FN to the plain parts of a TEXT or MTEXT string, leaving format codes alone.
;; FN gets the plain part and the character before it (a space at the start).
(defun cx:fmt-map (str mt fn / out prev)
  (setq out "" prev " ")
  (foreach tk (cx:fmt-tokens str mt)
    (if (= (car tk) 'T)
      (setq out (strcat out (apply fn (list (cdr tk) prev)))
            prev (substr (cdr tk) (strlen (cdr tk))))
      (setq out (strcat out (cdr tk))
            prev (if (= (cdr tk) "\\P") " " prev))))
  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)

;; How many times SUB occurs in STR.
(defun cx:count-sub (str sub / n pos p)
  (setq n 0 pos 1)
  (while (setq p (cx:find str sub pos))
    (setq n (1+ n) pos (+ p (max 1 (strlen sub)))))
  n)

;; Replace every OLD in STR by NEW (case sensitive).
(defun cx:replace (str old new / n out pos)
  (setq n (strlen old) out "" pos 1)
  (if (= n 0)
    str
    (progn
      (while (<= pos (1+ (- (strlen str) n)))
        (if (= (substr str pos n) old)
          (setq out (strcat out new) pos (+ pos n))
          (setq out (strcat out (substr str pos 1)) pos (1+ pos))))
      (strcat out (substr str pos)))))

;; Replace every OLD in STR by NEW, ignoring case.
(defun cx:replace-ci (str old new / n out pos up uo)
  (setq n (strlen old) out "" pos 1 up (strcase str) uo (strcase old))
  (if (= n 0)
    str
    (progn
      (while (<= pos (1+ (- (strlen str) n)))
        (if (= (substr up pos n) uo)
          (setq out (strcat out new) pos (+ pos n))
          (setq out (strcat out (substr str pos 1)) pos (1+ pos))))
      (strcat out (substr str pos)))))

;; 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)

;; 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)

;; 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)))

;; Ask for one of the keywords in BITS ("Yes No"), default DEF; returns the keyword.
(defun cx:ask-kw (msg bits def / v)
  (initget 0 bits)
  (setq v (getkword (strcat "\n" msg " [" (cx:replace bits " " "/") "] <" def ">: ")))
  (if v v def))

;; 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 "\nCXTXTREPL loaded. Type CXTXTREPL to start.")
(princ)

Altri comandi: Testo

• CXNUMNumerare i testi in sequenza
• CXTXTADDAggiungere un prefisso o un suffisso a molti testi
• CXTXTCUTTagliare caratteri all'inizio o alla fine dei testi
• CXTXTCASECambiare maiuscole e minuscole di molti testi
• CXTXTCLEANPulire spazi e formattazione dei testi
• CXT2MUnire testi a riga singola in un unico testo multilinea
• CXM2TScomporre un testo multilinea in testi a riga singola
• CXTXTALIGNAllineare i testi a un testo di riferimento
• CXTXTSTYLECambiare stile e altezza di molti testi
• CXTXTCOUNTContare i testi identici
• CXTXTSUMSommare i numeri contenuti nei testi