Newsgroup: it.comp.software.cad
Titolo: Esiste un programma per convertire *.lsp da inglese in italiano?

Esite un programma per convertire un file lsp (Autocad R14) scritto con i 
comandi inlgese in italiano ?
Grazie mille
egittologo 

Che io sappia non esiste, ma non avrebbe nemmeno senso esistere.
Tutte le versioni localizzate di AutoCAD sono in grado di leggere i lisp 
scritti in inglese.
Non avviene invece il contrario: AutoCAD inglese non può leggere un lisp 
scritto in italiano.
Per far si che il lisp scritto in inglese sia letto anche da tutte le 
localizzazioni di AutoCAD (italiano compreso) occorre inserire l'underscore 
(ovvero il simbolo "_") prima del nome di ogni comando.
Ad es.:
(command "erase" "all" "") ; funziona solo su AutoCAD inglese
(command "_erase" "_all" "") ; funziona su tutti gli AutoCAD.
Potresti editare manualmente questi comandi. Un primo passaggio potrebbe 
essere quello di fare un trova sostituisci di
(command "       con      (command "_
Ciao
-- 
Emiliano - Webmaster di EmiCAD® - Tutto per AutoCAD e ProgeSOFT® ProgeCAD
e-mail:  
webm...@emicad.it
web:  
www.emicad.it
 

 
Aggiungo: già che ci sei mettici pure il punto prima dei comandi
(command "_.erase" "_all" "")
in questo modo by-passi eventuali (rari) alias dei comandi.
Ciao
Maci

se non č compilato puoi fare da te semplicemente oppure ricopialo con copia e incolla qui e vedremo di che si tratta, comunque non č difficile devi con blocco note aprire il file lisp e cercare i vari comandi in inglese e renderli attivabili con qualsiasi linque
esempi
line   --->   _line
layer --->   _layer
offset --->  _offset
dopo aver messo _ la stanghetta gių funziona dappertutto
-- 
liber 
------------------------------------------------------------------------
View this thread: 
http://www.itsistemi.net/viewtopic-762177.html
Inviato via 
http://www.itsistemi.net

 copia e incolla qui e vedremo di che si tratta ......
;;; ACAD.LSP inglese - v2.05 - ultima revisione 20/07/2001 - Angelo
;;;--------------------------------------------------------------------------
;;;   CHTEXT.lsp
;;;--------------------------------------------------------------------------
;;;
;;; Main function -- no arguments
;;;
(defun chtxt (/ sset opt ssl nsset temp unctr
                sslen style hgt rot txt ent cht_oc
                loc loc1 justp justq orthom )
  (setq pt_ver "1.00")                ; Reset this local if you make a 
change.
  ;;
  ;; Internal error handler defined locally
  ;;
  (defun cht_er (s)                   ; If an error (such as CTRL-C) occurs
                                      ; while this command is active...
    (if (/= s "Function cancelled")
      (if (= s "quit / exit abort")
        (princ)
        (princ (strcat "\nErrore: " s))
      )
    )
    (command)
    (eval(read U:E))
    (if cht_oe                        ; If an old error routine exists
      (setq *error* cht_oe)           ; then, reset it
    )
    (if cht_oc (setvar "cmdecho" cht_oc)) ; Reset command echoing
    (if cht_ot (setvar "texteval" cht_ot))
    (if cht_oh (setvar "highlight" cht_oh))
    (princ)
  )
  ;;
  ;; Body of function
  ;;
  (if *error*                         ; Set our new error handler
    (setq cht_oe *error* *error* cht_er)
    (setq *error* cht_er)
  )
  ;; Set undo groups and ends with (eval(read U:G)) or (eval(read U:E))
  (setq U:G "(command \"UNDO\" \"GROUP\")"
        U:E "(command \"UNDO\" \"END\")"
  )
  (setq cht_oc (getvar "cmdecho"))
  (setq cht_oh (getvar "highlight"))
  (setvar "cmdecho" 0)
  (eval(read U:G))
  (princ (strcat "\nCambio testo, Versione " pt_ver
                 ", (c) 1990 by Autodesk, AG "))
  (prompt "\nSelezionare testo da cambiare. ")
  (setq sset (ssget))
  (if (null sset)
    (progn
      (princ "\nERRORE: Nessuna selezione.")
      (exit)
    )
  )
  ;; Verify the entity set.
  (cht_ve)
  ;; This is the main option loop.
  (cht_ol)
  (if cht_oe (setq *error* cht_oe))   ; Reset old error function if error
  (eval(read U:E))
  (if cht_ot (setvar "texteval" cht_ot))
  (if cht_oh (setvar "highlight" cht_oh))
  (if cht_oc (setvar "cmdecho" cht_oc)) ; Reset command echoing
  (princ)
)
;;;
;;; Verify and sort out non-text entities from the selection set.
;;;
(defun cht_ve ()
  (setq ssl   (sslength sset)
        nsset (ssadd))
  (if (> ssl 25)
    (princ "\nVerifica delle entità selezionate -- attendere prego. ")
  )
  (while (> ssl 0)
    (setq temp (ssname sset (setq ssl (1- ssl))))
    (if (= (cdr(assoc 0 (entget temp))) "TEXT")
      (ssadd temp nsset)
    )
  )
  (setq ssl (sslength nsset)
        sset nsset
        unctr 0
  )
  (print ssl)
  (princ "entità di testo trovata. ")
)
;;;
;;; The option loop.
;;;
(defun cht_ol ()
  (setq opt T)
  (while (and opt (> ssl 0))
    (setq unctr (1+ unctr))
    (command "UNDO" "GROUP")
    (initget "LOcazione Giustificazione Stile ALtezza Rotazione LArghezza 
Testo ANnulla")
    (setq opt (getkword
      "\nALtezza/Giustificazione/LOcazione/Rotazione/Stile/Testo/ANnulla/LArghezza: 
"))
    (if opt
      (cond
        ((= opt "ANnulla")
          (cht_ue)                    ; Undo the previous command.
        )
        ((= opt "LOcazione")
          (cht_le)                    ; Change the location.
        )
        ((= opt "Giustificazione")
          (cht_je)                    ; Change the justification.
        )
        ((= opt "Stile")     (cht_pe "Stile"    "nome stile"     7) )
        ((= opt "ALtezza")   (cht_pe "ALtezza"   "valore per altezza" 
40) )
        ((= opt "Rotazione") (cht_pe "Rotazione" "angolo rotazione" 50) )
        ((= opt "LArghezza") (cht_pe "Larghezza"    "fattore larghezza" 
 41) )
        ((= opt "Testo")
          (cht_te)                    ; Change the text.
        )
      )
      (setq opt nil)
    )
    (command "UNDO" "END")
  )
)
;;;
;;; Undo an entry.
;;;
(defun cht_ue ()
  (if (> unctr 1)
    (progn
      (command "UNDO" "END")
      (command "UNDO" "2")
      (setq unctr (- unctr 2))
    )
    (progn
      (princ "\nNiente da annullare. ")
      (setq unctr (- unctr 1))
    )
  )
)
;;;
;;; Change the location of an entry.
;;;
(defun cht_le ()
  (setq sslen (sslength sset)
        style ""
        hgt   ""
        rot   ""
        txt   ""
  )
  (command "CHANGE" sset "" "")
  (while (> sslen 0)
    (setq ent (entget(ssname sset (setq sslen (1- sslen))))
          opt (list (cadr (assoc 11 ent))
                    (caddr (assoc 11 ent))
                    (cadddr (assoc 11 ent)))
    )
    (prompt "\nNuova locazione del testo: ")
    (command pause)
    (if (null loc)
      (setq loc opt)
    )
    (command style hgt rot txt)
  )
  (command)
)
;;;
;;; Change the justification of an entry.
;;;
(defun cht_je ()
  (if (getvar "DIMCLRD")
    (initget (strcat "ASinistra ACentro ADestra "
                     "MSinistra MCentro MDestra "
                     "BSinistra BCentro BDestra "
                     "Lunghezza Centro Fisso Sinistra Mezzo Destra ?"))
    (initget "Lunghezza Centro Fisso Sinistra Mezzo Destra ?")
  )
  (setq sslen (sslength sset))
  (setq justp (getkword (strcat "\nModalità di allineamento - "
              "Lunghezza/Centro/Fisso/Sinistra/Mezzo/Destra/<?>: ")))
  (cond
    ((= justp "Sinistra")    (setq justp 0 justq 0) )
    ((= justp "Centro")  (setq justp 1 justq 0) )
    ((= justp "Destra")   (setq justp 2 justq 0) )
    ((= justp "Lunghezza") (setq justp 3 justq 0) )
    ((= justp "Fisso")     (setq justp 5 justq 0) )
    ((= justp "ASinistra")   (setq justp 0 justq 3) )
    ((= justp "ACentro") (setq justp 1 justq 3) )
    ((= justp "ADestra")  (setq justp 2 justq 3) )
    ((= justp "MSinistra")   (setq justp 0 justq 2) )
    ((= justp "Mezzo")  (setq justp 1 justq 2) )
    ((= justp "MCentro") (setq justp 1 justq 2) )
    ((= justp "MDestra")  (setq justp 2 justq 2) )
    ((= justp "BSinistra")   (setq justp 0 justq 1) )
    ((= justp "BCentro") (setq justp 1 justq 1) )
    ((= justp "BDestra")  (setq justp 2 justq 1) )
    ((= justp "?")       (setq justp nil)       )
    (T                   (setq justp nil)       )
  )
  (if justp
    (justpt) ; Process them...
    (justpn) ; List options...
  )
  (command)
)
;;;
;;; Get alignment points for "aligned" or "fit" text.
;;;
(defun justpt ()
  (while (> sslen 0)
    (setq ent (entget(ssname sset (setq sslen (1- sslen))))
          ent (subst (cons 72 justp) (assoc 72 ent) ent)
          opt (trans (list (cadr (assoc 11 ent))
                           (caddr (assoc 11 ent))
                           (cadddr (assoc 11 ent)))
                     (cdr(assoc -1 ent)) ; from ECS
                     1)               ; to current UCS
    )
    (if (getvar "DIMCLRD")
      (setq ent (subst (cons 73 justq) (assoc 73 ent) ent))
    )
    (cond
      ((or (= justp 3) (= justp 5))
        (prompt "\nNuovi punti di allineamento testo: ")
        (if (= (setq orthom (getvar "orthomode")) 1)
          (setvar "orthomode" 0)
        )
        (redraw (cdr(assoc -1 ent)) 3)
        (initget 1)
        (setq loc (getpoint))
        (initget 1)
        (setq loc1 (getpoint loc))
        (redraw (cdr(assoc -1 ent)) 1)
        (setvar "orthomode" orthom)
        (setq ent (subst (cons 10 loc) (assoc 10 ent) ent))
        (setq ent (subst (cons 11 loc1) (assoc 11 ent) ent))
      )
      ((/= justp 0)
        (redraw (cdr(assoc -1 ent)) 3)
        (prompt "\nNuova locazione del testo: ")
        (if (= (setq orthom (getvar "orthomode")) 1)
          (setvar "orthomode" 0)
        )
        (setq loc (getpoint opt))
        (setvar "orthomode" orthom)
        (redraw (cdr(assoc -1 ent)) 1)
        (if (null loc)
          (setq loc opt)
          (setq loc (trans loc 1 (cdr(assoc -1 ent))))
        )
        (setq ent (subst (cons 11 loc) (assoc 11 ent) ent))
      )
    )
    (entmod ent)
  )
)
;;;
;;; List the options.
;;;
(defun justpn ()
  (if (getvar "DIMCLRD") (textpage))
  (princ "\nOpzioni d'allineamento: \n")
  (princ "\n\t ASinistra   ACentro   ADestra ")
  (princ "\n\t MSinistra   MCentro   MDestra ")
  (princ "\n\t BSinistra   BCentro   BDestra ")
  (princ "\n\t Sinistra    Centro    Destra")
  (princ "\n\t Lunghezza   Mezzo    Fisso")
  (if (not (getvar "DIMCLRD")) (textscr))
  (princ "\n\nPremere qualsiasi tasto per tornare al disegno. ")
  (grread)
  (princ "\r                                           ")
  (graphscr)
)
;;;
;;; Change the text of an entity.
;;;
(defun cht_te ()
  (setq sslen (sslength sset))
  (initget "Globalmente Individualmente Ridigitare")
  (setq ans (getkword
    "\nRicerca e sostituzione testo. 
Individualmente/Ridigitare/<Globalmente>:"))
  (setq cht_ot (getvar "texteval"))
  (setvar "texteval" 1)
  (cond
    ((= ans "Individualmente")
      (if (= (getvar "popups") 1)
        (progn
          (initget "Sì No")
          (setq ans (getkword "\nEditare il testo nel riquadro di dialogo ? 
<Sì>:"))
        )
        (setq ans "No")
      )
      (while (> sslen 0)
        (redraw (setq sn (ssname sset (setq sslen (1- sslen)))) 3)
        (setq ss (ssadd))
        (ssadd (ssname sset sslen) ss)
        (if (= ans "No")
          (chgtext ss)
          (command "ddedit" sn "")
        )
        (redraw sn 1)
      )
    )
    ((= ans "Ridigitare")
      (while (> sslen 0)
        (setq ent (entget(ssname sset (setq sslen (1- sslen)))))
        (redraw (cdr(assoc -1 ent)) 3)
        (prompt (strcat "\nTesto vecchio: " (cdr(assoc 1 ent))))
        (setq nt (getstring  T "\nTesto nuovo: "))
        (redraw (cdr(assoc -1 ent)) 1)
        (if (> (strlen nt) 0)
          (entmod (subst (cons 1 nt) (assoc 1 ent) ent))
        )
      )
    )
    (T
      (chgtext sset)                  ; Change 'em all
    )
  )
  (setvar "texteval" cht_ot)
)
;;;
;;; The old CHGTEXT command - rudimentary text editor
;;;
;;;
(defun C:CHGTEXT () (chgtext nil))
(defun chgtext (objs / last_o tot_o ent o_str n_str st s_temp
                       n_slen o_slen si chf chm cont ans)
  (if (null objs)
    (setq objs (ssget))               ; Select objects if running standalone
  )
  (setq chm 0)
  (if objs
    (progn                   ; If any objects selected
      (if (= (type objs) 'ENAME)
        (progn
          (setq ent (entget objs))
          (princ (strcat "\nStringa esistente  : " (cdr (assoc 1 ent))))
        )
        (if (= (sslength objs) 1)
          (progn
            (setq ent (entget (ssname objs 0)))
            (princ (strcat "\nStringa esistente  : " (cdr (assoc 1 ent))))
          )
        )
      )
      (setq o_str (getstring "\nStringa da cambiare: " t))
      (setq o_slen (strlen o_str))
      (if (/= o_slen 0)
        (progn
          (setq n_str (getstring "\nStringa nuova      : " t))
          (setq n_slen (strlen n_str))
          (setq last_o 0
                tot_o  (if (= (type objs) 'ENAME)
                         1
                         (sslength objs)
                       )
          )
          (while (< last_o tot_o)     ; For each selected object...
            (if (= "TEXT"             ; Look for TEXT entity type (group 0)
                   (cdr (assoc 0 (setq ent (entget (ssname objs last_o))))))
              (progn
                (setq chf nil si 1)
                (setq s_temp (cdr (assoc 1 ent)))
                (while (= o_slen (strlen (setq st (substr s_temp si 
o_slen))))
                  (if (= st o_str)
                    (progn
                      (setq s_temp (strcat
                                     (if (> si 1)
                                       (substr s_temp 1 (1- si))
                                       ""
                                     )
                                     n_str
                                     (substr s_temp (+ si o_slen))
                                   )
                      )
                      (setq chf t)    ; Found old string
                      (setq si (+ si n_slen))
                    )
                    (setq si (1+ si))
                  )
                )
                (if chf
                  (progn              ; Substitute new string for old
                    ; Modify the TEXT entity
                    (entmod (subst (cons 1 s_temp) (assoc 1 ent) ent))
                    (setq chm (1+ chm))
                  )
                )
              )
            )
            (setq last_o (1+ last_o))
          )
        )
        ;; else go on to the next line...
      )
    )
  )
  (if (/= (type objs) 'ENAME)
    (if (/= (sslength objs) 1)        ; Print total lines changed
      (princ (strcat "Cambiate "
                     (rtos chm 2 0)
                     " righe di testo."
             )
      )
    )
  )
  (terpri)
)
;;;
;;; Main procedure for manipulating text entities
;;; ARGUMENTS:
;;;   typ   -- Type of operation to perform
;;;   prmpt -- Partial prompt string to insert in standard prompt line
;;;   fld   -- Assoc field to be changed
;;; GLOBALS:
;;;   sset  -- The selection set of text entities
;;;
(defun cht_pe (typ prmpt fld / temp ow nw ent tw sty w hw lw
                              sslen n sn ssl)
  (if (= (sslength sset) 1)           ; Special case if there is only
                                      ; one entity selected
    ;; Process one entity.
    (cht_p1)
    ;; Else
    (progn
      ;; Set prompt string.
      (cht_sp)
      (if (= nw "Elenco")
        ;; Process Elenco request.
        (cht_pl)
        (if (= nw "Individuale")
          ;; Process Individuale request.
          (cht_pi)
          (if (= nw "Selezionare")
            ;; Process Select request.
            (cht_ps)
            ;; Else
            (progn
              (if (= typ "Rotazione")
                (setq nw (* (/ nw 180.0) pi))
              )
              (if (= (type nw) 'STR)
                (if (not (tblsearch "style" nw))
                  (progn
                    (princ (strcat "\nStile " nw " non trovato. "))
                  )
                  (cht_pa)
                )
                (cht_pa)
              )
            )
          )
        )
      )
    )
  )
)
;;;
;;; Change all of the entities in the selection set.
;;;
(defun cht_pa ()
  (setq sslen (sslength sset))
  (setq cht_oh (getvar "texteval"))
  (setvar "highlight" 0)
  (while (> sslen 0)
    (setq temp (ssname sset (setq sslen (1- sslen))))
    (entmod (subst (cons fld nw)
                   (assoc fld (setq ent (entget temp)))
                   ent
            )
    )
  )
  (setvar "highlight" cht_oh)
)
;;;
;;; Change one text entity.
;;;
(defun cht_p1 ()
  (setq temp (ssname sset 0))
  (setq ow (cdr(assoc fld (entget temp))))
  (if (= opt "Rotazione")
    (setq ow (/ (* ow 180.0) pi))
  )
  (redraw (cdr(assoc -1 (entget temp))) 3)
  (initget 0)
  (if (= opt "Stile")
    (setq nw (getstring (strcat "\nNuovo " prmpt ". <"
                              ow ">: ")))
    (setq nw (getreal (strcat "\nNuovo " prmpt ". <"
                              (rtos ow 2) ">: ")))
  )
  (if (or (= nw "") (= nw nil))
    (setq nw ow)
  )
  (redraw (cdr(assoc -1 (entget temp))) 1)
  (if (= opt "Rotazione")
    (setq nw (* (/ nw 180.0) pi))
  )
  (if (= opt "Stile")
    (if (null (tblsearch "style" nw))
      (princ (strcat "\nStile " nw " non trovato. "))
      (entmod (subst (cons fld nw)
                     (assoc fld (setq ent (entget temp)))
                     ent
              )
      )
    )
    (entmod (subst (cons fld nw)
                   (assoc fld (setq ent (entget temp)))
                   ent
            )
    )
  )
)
;;;
;;; Set the prompt string.
;;;
(defun cht_sp ()
  (if (= typ "Stile")
    (progn
      (initget "Individuale Elenco Nuovo Selezionare ")
      (setq nw (getkword (strcat "\nIndividuale/Elenco/Selezionare 
stile/<Nuovo "
                                 prmpt
                                 " per tutte le entità>: ")))
      (if (or (= nw "") (= nw nil) (= nw "Enter"))
        (setq nw (getstring (strcat "\nNuovo "
                                    prmpt
                                    " per tutte le entità: ")))
      )
    )
    (progn
      (initget "Elenco Individuale" 1)
      (setq nw (getreal (strcat "\nIndividuale/Elenco/<Nuovo "
                                 prmpt
                                 " per tutte le entità>: ")))
    )
  )
)
;;;
;;; Process List request.
;;;
(defun cht_pl ()
  (setq unctr (1- unctr))
  (setq sslen (sslength sset))
  (setq tw 0)
  (while (> sslen 0)
    (setq temp (ssname sset (setq sslen (1- sslen))))
    (if (= typ "Stile")
      (progn
        (if (= tw 0)
          (setq tw (list (cdr(assoc fld (entget temp)))))
          (progn
            (setq sty (cdr(assoc fld (entget temp))))
            (if (not (member sty tw))
              (setq tw (append tw (list sty)))
            )
          )
        )
      )
      (progn
        (setq tw (+ tw (setq w (cdr(assoc fld (entget temp))))))
        (if (= (sslength sset) (1+ sslen)) (setq lw w hw w))
        (if (< hw w) (setq hw w))
        (if (> lw w) (setq lw w))
      )
    )
  )
  (if (= typ "Rotazione")
    (setq tw (* (/ tw pi) 180.0)
          lw (* (/ lw pi) 180.0)
          hw (* (/ hw pi) 180.0))
  )
  (if (= typ "Stile")
    (progn
      (princ (strcat "\n"
                     typ
                     "(i) -- "))
      (princ tw)
    )
    (princ (strcat "\n"
                     typ
                     " -- Minima: "
                     (rtos lw 2)
                     "\t Massima: "
                     (rtos hw 2)
                     "\t Media: "
                     (rtos (/ tw (sslength sset)) 2) ))
  )
)
;;;
;;; Process Individual request.
;;;
(defun cht_pi ()
  (setq sslen (sslength sset))
  (while (> sslen 0)
    (setq temp (ssname sset (setq sslen (1- sslen))))
    (setq ow (cdr(assoc fld (entget temp))))
    (if (= typ "Rotazione")
      (setq ow (/ (* ow 180.0) pi))
    )
    (initget 0)
    (redraw (cdr(assoc -1 (entget temp))) 3)
    (if (= typ "Stile")
      (progn
        (setq nw (getstring (strcat "\nNuovo "
                                   prmpt
                                   ". <"
                                   ow ">: ")))
      )
      (progn
        (setq nw (getreal (strcat "\nNuovo "
                                   prmpt
                                   ". <"
                                (rtos ow 2) ">: ")))
      )
    )
    (if (or (= nw "") (= nw nil))
      (setq nw ow)
    )
    (if (= typ "Rotazione")
      (setq nw (* (/ nw 180.0) pi))
    )
    (entmod (subst (cons fld nw)
                   (assoc fld (setq ent (entget temp)))
                   ent
            )
    )
    (redraw (cdr(assoc -1 (entget temp))) 1)
  )
)
;;;
;;; Process the Select option.
;;;
(defun cht_ps ()
  (princ "\nRicerca dello stile ?  <*>: ")
  (setq sn  (strcase (getstring))
        n   -1
        sset nsset
        nsset (ssadd)
        ssl (1- (sslength sset))
        )
  (if (or (= sn "*") (null sn) (= sn ""))
    (setq nsset sset sn "*")
    (while (and sn (< n ssl))
      (setq temp (ssname sset (setq n (1+ n))))
      (if (= (cdr(assoc 7 (entget temp))) sn)
        (ssadd temp nsset)
      )
    )
  )
  (setq ssl (sslength nsset))
  (princ "\nTrovate ")
  (princ ssl)
  (princ " entità di testo con STILE di ")
  (princ sn)
  (princ ". ")
  (setq sset nsset)
)
;;;
;;; The C: function definition.
;;;
(defun c:cht    () (chtxt))
(princ "\n\tC:CHangeText caricato.      Lanciare il comando con CHT")
(princ)
;----------------------------------------------------------------------------
; SF.LSP
;----------------------------------------------------------------------------
; DESCRIZIONE
;
; Routine per cambiare il foglio corrente, quando i fogli sono piani
; che hanno come nome "D_xxxxxx" (xxxxxx=numero del foglio - tipo CADELET)
;
;----------------------------------------------------------------------------
;
(defun C:SF (/ olderr ocmd)
  (setq olderr *error*
        *error* dellerr)
  (setq ocmd (getvar "CMDECHO"))
  (setvar "CMDECHO" 0)
  (setq numpag (getstring "Nuovo foglio: "))
  (while (< (strlen numpag) 6)
    (setq numpag (strcat "0" numpag))
  )
  (setq nomep (strcat "D_" numpag))
  (command "LAYER" "T" "0" "S" "0" "F" "D_*" "T" nomep "S" nomep "")
  (setvar "CMDECHO" ocmd)
  (setq *error* olderr)
  (princ)
)
(princ)
(princ "\n\tC:SelezionaFoglio caricato. Lanciare il comando con SF")
(princ)
;----------------------------------------------------------------------------
; MOF.LSP
;----------------------------------------------------------------------------
; DESCRIZIONE
;
; Routine per spostare entita' da un foglio ad un altro, con piani
; che hanno come nome "D_xxxxxx" (xxxxxx=numero del foglio - tipo CADELET)
;
;----------------------------------------------------------------------------
;
(defun C:MOF (/ olderr ocmd)
  (setq olderr *error*
        *error* dellerr)
  (setq ocmd (getvar "CMDECHO"))
  (setvar "CMDECHO" 0)
  (setq numpag (getstring "Foglio destinazione: "))
  (while (< (strlen numpag) 6)
    (setq numpag (strcat "0" numpag))
  )
  (setq nomep (strcat "D_" numpag))
  (setq gsel (ssget))
  (command "CHPROP" gsel  "" "LA" nomep "")
  (command "LAYER" "T" "0" "S" "0" "F" "D_*" "T" nomep "S" nomep "")
  (princ "\nspostamento effettuato.")
  (setvar "CMDECHO" ocmd)
  (setq *error* olderr)
  (princ)
)
(princ)
(princ "\n\tC:MuOveFoglio caricato.     Lanciare il comando con MOF")
(princ)
;----------------------------------------------------------------------------
; COF.LSP
;----------------------------------------------------------------------------
; DESCRIZIONE
;
; Routine per copiare entita' da un foglio ad un altro, con piani
; che hanno come nome "D_xxxxxx" (xxxxxx=numero del foglio - tipo CADELET)
;
;----------------------------------------------------------------------------
;
(defun C:COF (/ olderr ocmd)
  (setq olderr *error*
        *error* dellerr)
  (setq ocmd (getvar "CMDECHO"))
  (setvar "CMDECHO" 0)
  (setq numpag (getstring "Foglio destinazione: "))
  (while (< (strlen numpag) 6)
    (setq numpag (strcat "0" numpag))
  )
  (setq nomep (strcat "D_" numpag))
  (setq gsel (ssget))
  (command "COPY" gsel "" "0,0" "0,0")
  (command "CHPROP" "P" "" "LA" nomep "")
  (command "LAYER" "T" "0" "S" "0" "F" "D_*" "T" nomep "S" nomep "")
  (princ "\ncopia effettuata.")
  (setvar "CMDECHO" ocmd)
  (setq *error* olderr)
  (princ)
)
(princ)
(princ "\n\tC:COpiaFoglio caricato.     Lanciare il comando con COF")
(princ)
;----------------------------------------------------------------------------
; COFM.LSP
;----------------------------------------------------------------------------
; DESCRIZIONE
;
; Come COF ma per fogli multipli
;
;----------------------------------------------------------------------------
;
(defun C:COFM (/ olderr ocmd)
  (setq olderr *error*
        *error* dellerr)
  (setq ocmd (getvar "CMDECHO"))
  (setvar "CMDECHO" 0)
  (setq numpin (getreal "Primo foglio destinazione: "))
  (setq numpfi (getreal "Ultimo foglio destinazione: "))
  (setq gsel (ssget))
  (setq pagcor numpin)
  (while (< pagcor (+ numpfi 1))
    (setq numpag (rtos pagcor 2 0))
    (while (< (strlen numpag) 6)
      (setq numpag (strcat "0" numpag))
    )
  (setq nomep (strcat "D_" numpag))
  (command "COPY" gsel "" "0,0" "0,0")
  (command "CHPROP" "P" "" "LA" nomep "")
  (setq pagcor (+ pagcor 1))
  )
  (princ "\ncopia effettuata.")
  (setvar "CMDECHO" ocmd)
  (setq *error* olderr)
  (princ)
)
(princ)
(princ "\n\tC:COpiaFoglioMulti caricato.Lanciare il comando con COFM")
(princ)
;----------------------------------------------------------------------------
; NUF.LSP
;----------------------------------------------------------------------------
; DESCRIZIONE
;
; creazione nuovi fogli in automatico
;
;----------------------------------------------------------------------------
;
(defun C:NUF (/ olderr ocmd)
  (setq olderr *error*
        *error* dellerr)
  (setq ocmd (getvar "CMDECHO"))
  (setvar "CMDECHO" 0)
  (setq numpin (getreal "Primo nuovo foglio: "))
  (setq numpfi (getreal "Ultimo nuovo foglio: "))
  (setq colpia (getreal "Numero colore: "))
  (setq pagcor numpin)
  (while (< pagcor (+ numpfi 1))
    (setq numpag (rtos pagcor 2 0))
    (while (< (strlen numpag) 6)
      (setq numpag (strcat "0" numpag))
    )
  (setq nomep (strcat "D_" numpag))
  (command "LAYER" "n" nomep "c" (rtos colpia 2 0) nomep "")
  (setq pagcor (+ pagcor 1))
;  (princ "\nfoglio ")
;  (princ nomep)
;  (princ " creato")
  )
  (setvar "CMDECHO" ocmd)
  (setq *error* olderr)
  (princ)
)
(princ)
(princ "\n\tC:NUovi Fogli caricato.     Lanciare il comando con NUF")
(princ)
;----------------------------------------------------------------------------
; PAG.LSP
;----------------------------------------------------------------------------
; DESCRIZIONE
;
; scrittura dei numeri di pagina in automatico
;
;----------------------------------------------------------------------------
;
(defun C:PAG (/ olderr ocmd)
  (setq olderr *error*
        *error* dellerr)
  (setq ocmd (getvar "CMDECHO"))
  (setvar "CMDECHO" 0)
  (setq numpin (getreal "Primo foglio: "))
  (setq numpfi (getreal "Ultimo foglio: "))
  (setq numini (getreal "Numero iniziale: "))
  (setq giust (getstring "Giustificazione 
Align/Fit/Center/Middle/Right/TL/TC/TR/ML/MC/MR/BL/BC/BR: "))
  (setq punins (getpoint "Punto di inserimento: "))
  (setq stile (getstring "Stile testo: "))
  (setq altz (getreal "Altezza testo: "))
  (setq ango (getreal "Angolo di rotazione: "))
  (setq pagcor numpin)
  (setq numero numini)
  (while (< pagcor (+ numpfi 1))
    (setq numpag (rtos pagcor 2 0))
    (while (< (strlen numpag) 6)
      (setq numpag (strcat "0" numpag))
    )
  (setq nomep (strcat "D_" numpag))
  (command "LAYER" "T" nomep "S" nomep "")
  (command "TEXT" "S" stile "J" giust punins altz ango (rtos numero 2 0))
  (command "LAYER" "T" "0" "S" "0" "F" nomep "")
  (setq pagcor (+ pagcor 1))
  (setq numero (+ numero 1))
;  (princ "\nfoglio ")
;  (princ nomep)
;  (princ " numerato")
  )
  (setvar "CMDECHO" ocmd)
  (setq *error* olderr)
  (princ)
)
(princ)
(princ "\n\tC:PAGinazione caricato.     Lanciare il comando con PAG")
(princ)
;----------------------------------------------------------------------------
; STAF.LSP
;----------------------------------------------------------------------------
; DESCRIZIONE
;
; stampa fogli in automatico
;
;----------------------------------------------------------------------------
;
(defun C:STAF (/ olderr ocmd)
  (setq olderr *error*
        *error* dellerr)
  (setq ocmd (getvar "CMDECHO"))
  (setvar "CMDECHO" 0)
  (setq numpin (getreal "Primo foglio da stampare: "))
  (setq numpfi (getreal "Ultimo foglio da stampare: "))
  (setq oddi (getvar "CMDDIA"))
  (setvar "CMDDIA" 0)
  (setq pagcor numpin)
  (while (< pagcor (+ numpfi 1))
    (setq numpag (rtos pagcor 2 0))
    (while (< (strlen numpag) 6)
      (setq numpag (strcat "0" numpag))
    )
  (setq nomep (strcat "D_" numpag))
  (command "LAYER" "T" "0" "S" "0" "F" "D_*" "T" nomep "S" nomep "")
  (command "PLOT" "" "" "" "" "" "" "")
  (setq pagcor (+ pagcor 1))
;  (princ "\nfoglio ")
;  (princ nomep)
;  (princ " stampato")
  )
  (setvar "CMDDIA" oddi)
  (setvar "CMDECHO" ocmd)
  (setq *error* olderr)
  (princ)
)
(princ)
(princ "\n\tC:STAmpa Fogli caricato.    Lanciare il comando con STAF")
(princ)
;----------------------------------------------------------------------------
; LO.LSP
;----------------------------------------------------------------------------
; DESCRIZIONE
;
; disegna due linee ortogonali
;
;----------------------------------------------------------------------------
;
(defun C:LO (/ olderr ocmd)
  (setq olderr *error*
        *error* dellerr)
  (setq ocmd (getvar "CMDECHO"))
  (setvar "CMDECHO" 0)
  (setq pt1 (getpoint "Dal punto: "))
  (setq pt2 (getpoint "Al punto: "))
  (setq pti (list (car pt2) (cadr pt1)))
  (command "LINE" pt1 pti pt2 "")
  (setvar "CMDECHO" ocmd)
  (setq *error* olderr)
  (princ)
)
(princ)
(princ "\n\tC:Linee Ortogonali caricato.Lanciare il comando con LO")
(princ)
;----------------------------------------------------------------------------
; SER.LSP
;----------------------------------------------------------------------------
; DESCRIZIONE
;
; disegna una serie orizzontale di numeri
;
;----------------------------------------------------------------------------
;
(defun C:SER (/ olderr ocmd)
  (setq olderr *error*
        *error* dellerr)
  (setq ocmd (getvar "CMDECHO"))
  (setvar "CMDECHO" 0)
  (setq punpar (getpoint "Punto di partenza della serie: "))
  (setq distan (getdist "Distanza tra gli elementi: "))
  (setq numele (getreal "Numero di elementi: "))
  (setq numini (getreal "Numero iniziale: "))
  (setq increm (getreal "Incremento: "))
  (setq stile (getstring "Stile testo: "))
  (setq altz (getreal "Altezza testo: "))
  (setq giust (getstring "Giustificazione testo 
Align/Fit/Center/Middle/Right/TL/TC/TR/ML/MC/MR/BL/BC/BR: "))
  (setq ango (getreal "Angolo di rotazione testo: "))
  (setq numero numini)
  (setq coordx (car punpar))
  (setq contat 0)
  (while (< contat (+ numele 1))
    (setq punins (list coordx (cadr punpar)))
    (command "TEXT" "S" stile "J" giust punins altz ango (rtos numero 2 0))
    (setq coordx (+ coordx distan))
    (setq numero (+ numero increm))
    (setq contat (+ contat 1))
  )
  (setvar "CMDECHO" ocmd)
  (setq *error* olderr)
  (princ)
)
(princ)
(princ "\n\tC:SERie caricato.           Lanciare il comando con SER")
(princ "\n")
(princ)
Questo è il file in questione Acad.lsp. Se qualcuno mi vuole dare una mano 
lo ringrazio tantissimo. I comandi che mi servirebbero veramente sono i 
seguenti :
CHTEXT, SF, MOF, COF, STAF gli altri si posso tranquillamente cancellare 
cosi mi snellisco il file.
Grazie 1000
egittologo 

Segui le indicazioni che ti hanno dato Emiliano e Liber.
Fai una copia di sicurezza del file, rinominala ACAD.LSP.OLD e apri 
ACAD.LSP con notepad.
Cerca tutte le volte che è inserita la parola "command" (usa la funzione 
  "trova" di notepad).
Tutte le volte che trovi un "command" preceduto da una parentesi, 
controlla se dopo c'è un argomento racchiuso tra virgolette; se c'è (e 
non è numerico) anteponi il carattere undrescore _ all'argomento.
Alcuni esempi tratti dal tuo lisp
     *****
(command "CHANGE" sset "" "")
   diventa
(command "_CHANGE" sset "" "")
     *****
(command "LAYER" "T" "0" "S" "0" "F" "D_*" "T" nomep "S" nomep "")
   diventa
(command "_LAYER" "_T" "_0" "_S" "_0" "_F" "_D_*" "_T" nomep "_S" nomep "")
   nota che nomep non è stato modificato, così come l'ultimo argomento 
nullo "".
     *****
(command "UNDO" "2")
   diventa
(command "_UNDO" "2")
   il valore 2 non viene modificato
     *****
(command)
(command pause)
(command style hgt rot txt)
   non vanno modificati, perché non hanno argomenti racchiusi tra 
virgolette, ma solo variabili o comandi
     *****
(defun cht_er (s)                 ; If an error (such as CTRL-C) occurs
                                   ; while this command is active...
   quello che trovi dopo un punto e virgola è un commento, quindi 
nessuna modifica.
Ho contato circa 23 "command" su cui intervenire: in un attimo risolvi 
tutto.
Ciao
Maci

Grazie mille per la risposta. Ho fatto esattamente come dici tu. Ma non ci 
sono riuscito. Mi da dei problemi a riconoscere il layer, secondo me 
l'errore sta in questa stringa di linea
(command "_LAYER" "_T" "_0" "_S" "_0" "_F" "_D_*" "_T" nomep "_S" nomep "")
ho provato anche a mettere
(command "_LAYER" "_T" "_0" "_S" "_0" "_F" "D_*" "_T" nomep "_S" nomep "")
cioè "D_*" senza underscore, perchè D_ è il nome del layer, cioè D_000001, 
D_000002, D_000003 ecc. ecc.
Non so che pesci prendere.
Grazie 1000
egittologo
"Maci" <maci...@pippo.pip> ha scritto nel messaggio 
news:WoGBf.49261$av6....@tornado.fastwebnet.it...


 
Sorry, sono andato un po' troppo di fretta e non ho analizzato tutti i 
casi in cui c'era il command.
L'underscore è da mettere solo su "T" (thaw = scongela), "S" (set = 
corrente), "F" (frozen = congela).
Lo "0" è il nome del layer zero, ovviamente da mantenere inalterato; 
giustamente anche "D_*" non vuole l'underscore.
Occhio che hai anche un paio di comandi "COPY" che passano il valore 
"0,0", ovviamente anch'esso da non modificare.
Ciao
Maci

Mille volte grazie 1000. Ho risolto grazie ai vostri consigli. Sono 
felicissimo, funziona tutto alla grande.
Pace e bene
egittologo