Fonction LISP pour purger

[(gile)]

Salut,

 

En LISP, qu'on utilise (command "_.purge ...) ou (vla-PurgeAll ...), il est difficile de savoir si tous les objets imbriqués seront effectivement purgés.

 

.NET fournit la méthode Datase.Purge() qu,i pour une collection d'ObjectId passée comme argument, retourne la collection de ceux qui ne sont pas référencés.

Utilisée dans une boucle, cela permet de garantir une purge de tous les éléments imbriqués.

 

J'ai implémenté cette méthode pour définir une nouvelle fonction LISP : gc-purge et j'en ai profité pour ajouter quelques types d'objets qui n'existent pas dans la commande native :

les groupes non référencés et, à partir de 2008 les échelles non référencées

 

Nouvelle version (1.1)

Cette fonction requiert un argument, un entier qui est la somme des code binaires suivants :

1 Blocs

2 Calques

4 Formes

8 Matériaux

16 Styles de cote

32 Styles de ligne de repère multiple

64 Styles de mligne

128 Styles de tableau

256 Styles de texte

512 Styles de tracé

1024 Styles visuels

2048 Type de ligne

4096 Applications enregistrées

8192 Goupes

16384 Echelles

32768 Textes vides

65536 Entités de longueur nulle

131072 Images raster

262144 DWF sous-jacents

524288 PDF sous-jacents

1048576 DGN sous-jacents

 

Exemples

(gc-purge 1) purge les blocs

(gc-purge 19) ou (gc-purge (+ 1 2 16)) purge les blocs, les calques et les style de cote

(gc-purge 2097151) purge tout

 

Nota l'utilisation de code représentant des options non accessibles dans la version courante (ex : 32 sur une 2007) est sans conséquence.

 

: correction d'un bug avec les mtexts formatés

: correction d'un bug avec les styles de ligne de repère multiple, les images et les calques sous-jascents.

LispPurge.zip

[bseb67]

Salut (Gile)

 

Le nettoyage de printemps ou "osterputz" est fini ;)

 

Ca ne sera pas plus simple de faire une seule dll dans laquelle tu testes la version

d'autocad pour savoir quel argument mettre ?

 

Je viens d'essayer sur un fichier pris au hasard (sous autocad mep 2008) :

 

Commande: (GC-PURGE)

System.ArgumentException: Erreur lors de la liaison avec la méthode cible.

à System.Delegate.CreateDelegate(Type type, Object firstArgument, MethodInfo

method, Boolean throwOnBindFailure)

à AcMgCommandClass.InvokeWorker(AcMgCommandClass* , MethodInfo mi, Object

commandObject, Boolean bLispFunction)

à AcMgCommandClass.InvokeWorkerWithExceptionFilter(AcMgCommandClass* ,

MethodInfo mi, Object commandObject, Boolean bLispFunction)

à AcMgPerDocumentCommandClass.Invoke(AcMgPerDocumentCommandClass* ,

gcroot* mi, Boolean bLispFunction)

à AcMgCommandClass.CommandThunk.InvokeLisp(CommandThunk* ); erreur: une

erreur est survenue dans la fonction *erreur*paramètre de la variable AutoCAD

rejeté: "edgemode" nil

 

Alors pour la variable edgemode, depuis que j'ai installé autofluid 2009, si une fonction lisp

plante, j'ai à chaque fois ce message...

[(gile)]

Ca ne sera pas plus simple de faire une seule dll dans laquelle tu testes la version

d'autocad pour savoir quel argument mettre ?

 

Ce n'est toujours aussi simple, le code ne compile pas si tu appelles des propriétés ou méthodes qui n'existent pas dans le SDK courant.

Mais, dans le cas présent, j'ai réussi à feinter, il n'y a plus qu'une seule dll qui devrait être compatible de 2007 à 2011 (et peut-être même 2006, je n'ai testé que sur 2007 et 2010).

 

Il faut fournir un argument à la fonction gc-purge : la somme des codes binaires énumérés ci dessus pour lesquels tu veux faire la purge exemple :

(gc-purge 1) ne purge que les blocs

(gc-purge 7) ou (gc-purge (+ 1 2 4)) purge les blocs, les calques, les styles de cote.

(gc-purge 16383) purge tout.

 

Les codes, pour ceux que ça intéresse

 

La classe LispFun

using System;
using System.Collections.Generic;
using System.Text;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.GraphicsInterface;
using Autodesk.AutoCAD.Runtime;
using LispExtensionTools;

namespace LispPurge
{
   public class LispFun
   {
       /* 1	    Blocs
        * 2	    Calques
        * 4	    Formes
        * 8	    Matériaux
        * 16	    Styles de cote
        * 32	    Styles de ligne de repère multiple
        * 64	    Styles de mligne
        * 128	    Styles de tableau
        * 256	    Styles de texte
        * 512	    Styles de tracé
        * 1024	    Styles visuels
        * 2048	    Type de ligne
        * 4096     Applications enregistrées
        * 8192	    Goupes
        * 16384	Echelles
        * 32768	Textes vides
        * 65536	Entités de longueur nulle
        * 131072   Images raster
        * 262144	DWF sous-jascents
        * 524288	PDF sous-jascents
        * 1048576	DGN sous-jascents
       */

       [LispFunction("gc-purge")]
       public TypedValue Purge(ResultBuffer resbuf)
       {
           TypedValue nil = new TypedValue((int)LispDataType.Nil);
           if (resbuf == null)
           {
               LispErrorMsg.TooFew();
               return nil;
           }
           TypedValue[] tvs = resbuf.AsArray();
           if (tvs.Length == 0)
           {
               LispErrorMsg.TooFew();
               return nil;
           }
           if (tvs.Length > 1)
           {
               LispErrorMsg.TooMuch();
               return nil;
           }
           TypedValue tv = tvs[0];
           if (tv.TypeCode != (int)LispDataType.Int16 && tv.TypeCode != (int)LispDataType.Int32)
           {
               LispErrorMsg.BadType("fixnump", tv);
               return nil;
           }
           int flag = Convert.ToInt32(tv.Value);
           try
           {
               PurgeAll(HostApplicationServices.WorkingDatabase, flag);
               return new TypedValue((int)LispDataType.T_atom);
           }
           catch (Autodesk.AutoCAD.Runtime.Exception ex)
           {
               Application.DocumentManager.MdiActiveDocument.Editor.WriteMessage(
                   "\nErreur application: " + ex.Message + ex.StackTrace);
               return nil;
           }
           catch (System.Exception ex)
           {
               Application.DocumentManager.MdiActiveDocument.Editor.WriteMessage(
                   "\nErreur système: " + ex.Message + ex.StackTrace);
               return nil;
           }
       }

       private void PurgeAll(Database db, int flag)
       {
           ObjectIdCollection tableIds = new ObjectIdCollection();
           ObjectIdCollection dictIds = new ObjectIdCollection();
           if ((flag & 1) == 1)
               tableIds.Add(db.BlockTableId);
           if ((flag & 2) == 2)
               tableIds.Add(db.LayerTableId);
           if ((flag & 16) == 16)
               tableIds.Add(db.DimStyleTableId);
           if ((flag & 8) == 8)
               tableIds.Add(db.LinetypeTableId);
           if ((flag & 256) == 256)
               tableIds.Add(db.TextStyleTableId);
           if ((flag & 4096) == 4096)
               tableIds.Add(db.RegAppTableId);
           if ((flag & 64) == 64)
               dictIds.Add(db.MLStyleDictionaryId);
           if ((flag & 512) == 512)
               dictIds.Add(db.PlotStyleNameDictionaryId);
           if ((flag & 128) == 128)
               dictIds.Add(db.TableStyleDictionaryId);
           bool emptyTxt = (flag & 32768) == 32768;
           bool zeroLength = (flag & 65536) == 65536;
           if (emptyTxt || zeroLength)
           {
               using (Transaction tr = db.TransactionManager.StartTransaction())
               {
                   List locked = new List();
                   LayerTable lt = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead);
                   foreach (ObjectId layerId in lt)
                   {
                       LayerTableRecord ltr = (LayerTableRecord)tr.GetObject(layerId, OpenMode.ForRead);
                       if (ltr.IsLocked == true)
                       {
                           ltr.UpgradeOpen();
                           ltr.IsLocked = false;
                           locked.Add(ltr);
                       }
                   }
                   BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
                   foreach (ObjectId btrId in bt)
                   {
                       BlockTableRecord btr =
                           (BlockTableRecord)tr.GetObject(btrId, OpenMode.ForRead);
                       if (!btr.IsLayout)
                           continue;
                       foreach (ObjectId id in btr)
                       {
                           if (zeroLength)
                           {
                               Curve crv = tr.GetObject(id, OpenMode.ForRead) as Curve;
                               if (crv != null)
                               {
                                   if (crv.GetDistanceAtParameter(crv.EndParam) == 0.0)
                                   {
                                       crv.UpgradeOpen();
                                       crv.Erase();
                                   }
                                   continue;
                               }
                           }
                           if (emptyTxt)
                           {
                               DBText txt = tr.GetObject(id, OpenMode.ForRead) as DBText;
                               if (txt != null)
                               {
                                   if (txt.TextString.Trim() == string.Empty)
                                   {
                                       txt.UpgradeOpen();
                                       txt.Erase();
                                   }
                                   continue;
                               }
                               MText mTxt = tr.GetObject(id, OpenMode.ForRead) as MText;
                               if (mTxt != null && GetStripedMtextContents(mTxt).Trim() == string.Empty)
                               {
                                   mTxt.UpgradeOpen();
                                   mTxt.Erase();
                               }
                           }
                       }
                   }
                   foreach (LayerTableRecord ltr in locked)
                   {
                       ltr.IsLocked = true;
                   }
                   tr.Commit();
               }
           }
           while (PurgeDatabase(db, tableIds, dictIds, flag))
               continue;
       }


       private string m_str;

       private string GetStripedMtextContents(MText mt)
       {
           m_str = string.Empty;
           mt.ExplodeFragments(new MTextFragmentCallback(FragmentCallback));
           return m_str;
       }

       private MTextFragmentCallbackStatus FragmentCallback(MTextFragment fragment, object obj)
       {
           m_str += fragment.Text;
           return MTextFragmentCallbackStatus.Continue;
       }

       private bool PurgeDatabase(Database db, ObjectIdCollection tableIds, ObjectIdCollection dictIds, int flag)
       {
           ObjectIdCollection ids = new ObjectIdCollection();
           using (Transaction tr = db.TransactionManager.StartTransaction())
           {
               if ((flag & 8192) == 8192)
               {
                   DBDictionary dict =
                       (DBDictionary)tr.GetObject(db.GroupDictionaryId, OpenMode.ForRead, false);
                   foreach (DBDictionaryEntry entry in dict)
                   {
                       Group grp = (Group)tr.GetObject(entry.Value, OpenMode.ForRead, false);
                       if (grp.NumEntities == 0)
                       {
                           grp.UpgradeOpen();
                           grp.Erase();
                       }
                   }
               }
               DBDictionary NOD =
                       (DBDictionary)tr.GetObject(db.NamedObjectsDictionaryId, OpenMode.ForRead);
               Dictionary dicts = new Dictionary();
               dicts.Add(32, "ACAD_MLEADERSTYLE");
               dicts.Add(262144, "ACAD_DWFDEFINITIONS");
               dicts.Add(524288, "ACAD_PDFDEFINITIONS");
               dicts.Add(1048576, "ACAD_DGNDEFINITIONS");
               foreach (KeyValuePair pair in dicts)
               {
                   if ((flag & pair.Key) == pair.Key && NOD.Contains(pair.Value))
                       dictIds.Add(NOD.GetAt(pair.Value));
               }
               foreach (ObjectId tableId in tableIds)
               {
                   SymbolTable table = (SymbolTable)tr.GetObject(tableId, OpenMode.ForRead, false);
                   foreach (ObjectId recordId in table)
                   {
                       ids.Add(recordId);
                   }
               }
               foreach (ObjectId dictId in dictIds)
               {
                   DBDictionary dict = (DBDictionary)tr.GetObject(dictId, OpenMode.ForRead, false);
                   foreach (DBDictionaryEntry entry in dict)
                   {
                       if (entry.Value.IsValid)
                       {
                           DBObject obj = (DBObject)tr.GetObject(entry.Value, OpenMode.ForRead);
                           if (!obj.IsAProxy)
                               ids.Add(entry.Value);
                       }
                   }
               }
               if ((flag & 131072) == 131072 && NOD.Contains("ACAD_IMAGE_DICT"))
               {
                   DBDictionary dict = (DBDictionary)tr.GetObject(NOD.GetAt("ACAD_IMAGE_DICT"), OpenMode.ForRead);
                   foreach (DBDictionaryEntry entry in dict)
                   {
                       if (entry.Value.IsValid)
                       {
                           bool lck;
                           RasterImageDef obj = (RasterImageDef)tr.GetObject(entry.Value, OpenMode.ForRead);
                           if (!obj.IsAProxy && obj.GetEntityCount(out lck) == 0)
                               ids.Add(entry.Value);
                       }
                   }
               }
               if ((flag & 16384) == 16384 && NOD.Contains("ACAD_SCALELIST"))
               {
                   DBDictionary dict = (DBDictionary)tr.GetObject(NOD.GetAt("ACAD_SCALELIST"), OpenMode.ForRead);
                   foreach (DBDictionaryEntry entry in dict)
                   {
                       if (entry.Key != "A0")
                       {
                           DBObject obj = (DBObject)tr.GetObject(entry.Value, OpenMode.ForRead);
                           if (!obj.IsAProxy)
                               ids.Add(entry.Value);
                       }
                   }
               }
               if ((flag & 8) == 8)
               {
                   DBDictionary matDict =
                       (DBDictionary)tr.GetObject(db.MaterialDictionaryId, OpenMode.ForRead, false);
                   foreach (DBDictionaryEntry entry in matDict)
                   {
                       string key = entry.Key;
                       if ((key != "ByBlock") && (key != "ByLayer") && (key != "Global"))
                       {
                           DBObject obj = (DBObject)tr.GetObject(entry.Value, OpenMode.ForRead);
                           if (!obj.IsAProxy)
                               ids.Add(entry.Value);
                       }
                   }
               }
               if ((flag & 1024) == 1024)
               {
                   DBDictionary vsDict =
                       (DBDictionary)tr.GetObject(db.VisualStyleDictionaryId, OpenMode.ForRead);
                   foreach (DBDictionaryEntry entry in vsDict)
                   {
                       DBVisualStyle vs = tr.GetObject(entry.Value, OpenMode.ForRead) as DBVisualStyle;
                       if (vs.Type == VisualStyleType.Custom)
                       {
                           DBObject obj = (DBObject)tr.GetObject(entry.Value, OpenMode.ForRead);
                           if (!obj.IsAProxy)
                               ids.Add(entry.Value);
                       }
                   }
               }
               if ((flag & 4) == 4)
               {
                   TextStyleTable tst =
                       (TextStyleTable)tr.GetObject(db.TextStyleTableId, OpenMode.ForRead);
                   foreach (ObjectId id in tst)
                   {
                       TextStyleTableRecord tstr =
                           (TextStyleTableRecord)tr.GetObject(id, OpenMode.ForRead);
                       if (tstr.IsShapeFile && !tstr.IsAProxy)
                           ids.Add(id);
                   }
               }
               db.Purge(ids);
               foreach (ObjectId id in ids)
               {
                   DBObject obj = (DBObject)tr.GetObject(id, OpenMode.ForWrite);
                   obj.Erase();
               }
               tr.Commit();
           }
           return ids.Count > 0;
       }
   }
}

 

La classe LispErrorMsg

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;

namespace LispExtensionTools
{
   public static class LispErrorMsg
   {
       static Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;

       internal static void TooFew()
       {
           ed.WriteMessage("\nErreur: nombre d'arguments insuffisants\n");
       }

       internal static void TooMuch()
       {
           ed.WriteMessage("\nErreur: nombre d'arguments trop important\n");
       }

       internal static void BadType(string T, TypedValue tV)
       {
           string msg = tV.TypeCode == (int)LispDataType.Nil ? "nil" : tV.Value.ToString();
           ed.WriteMessage("\nErreur: type d'argument incorrect: {0} {1}\n",T , msg);
       }

       internal static void Message(string msg)
       {
           ed.WriteMessage("\nErreur: {0}\n", msg);
       }
   }
}

[bseb67]

Il faut fournir un argument à la fonction gc-purge : la somme des codes binaires énumérés ci dessus pour lesquels tu veux faire la purge exemple :

(gc-purge 1) ne purge que les blocs

(gc-purge 7) ou (gc-purge (+ 1 2 4)) purge les blocs, les calques, les styles de cote.

(gc-purge 16383) purge tout.

 

J'avais zappé le fait de mettre l'argument (donc lors de l'appel)

je re-teste pour voir

 

...

 

et ca marche toujours pas :(

 

j'ai toujours le même message d'erreur super long...

même dans un fichier vide

 

Et tout ca à cause d'autofluid 2009 :mad:

 

car j'ai essayé avec autocad 2010 sans autofluid dessus, et là ca marche, pas de plantage

[(gile)]

j'ai toujours le même message d'erreur super long...

même dans un fichier vide

 

Et tout ca à cause d'autofluid 2009

 

Là, je ne vois pas ce que je peux faire...

Tu peux peut-être leur rapporter l'erreur (plus celle de la variable "edgemode").

[Patrick_35]

Salut (gile)

J'ai l'impression que mon nettoyeur t'as donné des idées ;)

 

@+

[(gile)]

Salut (gile)

J'ai l'impression que mon nettoyeur t'as donné des idées ;)

 

@+

 

En fait j'ai fait un nettoyeur pour le CADnorm_Tools de GitCAD. La prochaine version aura plus de 20 fonctions plus ou moins sophistiquées (de trucs genre supprimer les textes ou blocs vides à Edit_Bloc en passant par des convertisseurs de types de ligne, de couleur, etc.)

 

C'est cette lacune en LISP pour purger les objets imbriqués qui m'a motivé. J'en avais parlé avec Patrick ici et c'est vrai que la question du nombre de fois qu'il faut répéter la commande dans ton sujet a fini par me décider à définir cette fonction en LISP.

[(gile)]

J'ai modifié un peu la fonction :

 

- réparé une erreur avec les styles visuels non natifs, non référencés mais pourtant non purgeables, peut être issus de copier/coller (CF ce fichier)

 

- réparé un bug avec les mtextes sur les versions 2007

 

- ajouté deux nouvelles options : 16384 pour les textes et mtextes vides et 32768 pour les entités de longueur 0 (même s'il ne s'agit pas à proprement parler d'objets non référencés).

 

 

 

[(gile)]

Je mes suis aperçu que j'avais oublié de traiter les formes, j'en profite pour ajouter les objets sous-jacents (DWF, PDF, DGN) non référencés.

[lili2006]

Bonsoir à toutes et tous,

 

Est-ce testable directement en ligne de commande ?

 

A priori, oui puisque un argument et un entier

 

Car, moi, j'ai ça =>

 

Commande: (gc-purge 19)

System.ArgumentException: Erreur lors de la liaison avec la méthode cible.

à System.Delegate.CreateDelegate(Type type, Object firstArgument, MethodInfo

method, Boolean throwOnBindFailure)

à AcMgCommandClass.InvokeWorker(AcMgCommandClass* , MethodInfo mi, Object

commandObject, Boolean bLispFunction)

à AcMgCommandClass.InvokeWorkerWithExceptionFilter(AcMgCommandClass* ,

MethodInfo mi, Object commandObject, Boolean bLispFunction)

à AcMgPerDocumentCommandClass.Invoke(AcMgPerDocumentCommandClass* ,

gcroot<:reflection::methodinfo>* mi, Boolean bLispFunction)

à AcMgCommandClass.CommandThunk.InvokeLisp(CommandThunk* )*Annuler*

Commande:

erreur: Demande ADS erronée

 

Qu'as-tu testé sur le fichier pointé sur ta réponse 7 ?

 

Merci d'avance,

[(gile)]

Curieux, c'est le même message d'erreur que bseb67. Il l'attribue à AutoFluid.

 

Il semblerait que certaines applications ne supportent pas les fonctions LISP définies en .NET :casstet:

 

Sinon, ou c'est du LISP, donc ça peut s'utiliser en ligne de commande, mais la fonction ne retourne pas d'informations sur ce qu'elle a fait.

Elle retourne nil en cas d'erreur et T si tout c'est bien passé.

À part quelques exceptions, les objets sont traités indifféremment en boucle. Pour faire un rapport, il aurait fallu faire un compteur par type d'objet traité. Comme c'est plutôt destiné à des programmeurs que pour être utilisé comme commande, j'ai préféré privilégier la performance.

 

J'ai mis une nouvelle version avec quelques "pièges" pour attraper les erreurs et essayer de les situer plus précisément, mais d'après ton message, il semblerait qu'il refuse tout simplement de lancer la fonction LISP.

Si tu veux ré-essayer...

[lili2006]

Re,

 

Sur ma V2008 (Couplé avec covadis !)

 

Commande: (gc-purge 19)

System.ArgumentException: Erreur lors de la liaison avec la méthode cible.

à System.Delegate.CreateDelegate(Type type, Object firstArgument, MethodInfo

method, Boolean throwOnBindFailure)

à AcMgCommandClass.InvokeWorker(AcMgCommandClass* , MethodInfo mi, Object

commandObject, Boolean bLispFunction)

à AcMgCommandClass.InvokeWorkerWithExceptionFilter(AcMgCommandClass* ,

MethodInfo mi, Object commandObject, Boolean bLispFunction)

à AcMgPerDocumentCommandClass.Invoke(AcMgPerDocumentCommandClass* ,

gcroot<:reflection::methodinfo>* mi, Boolean bLispFunction)

à AcMgCommandClass.CommandThunk.InvokeLisp(CommandThunk* )*Annuler*

Commande:

erreur: Demande ADS erronée

Commande: (gc-purge 2097151)

System.ArgumentException: Erreur lors de la liaison avec la méthode cible.

à System.Delegate.CreateDelegate(Type type, Object firstArgument, MethodInfo

method, Boolean throwOnBindFailure)

à AcMgCommandClass.InvokeWorker(AcMgCommandClass* , MethodInfo mi, Object

commandObject, Boolean bLispFunction)

à AcMgCommandClass.InvokeWorkerWithExceptionFilter(AcMgCommandClass* ,

MethodInfo mi, Object commandObject, Boolean bLispFunction)

à AcMgPerDocumentCommandClass.Invoke(AcMgPerDocumentCommandClass* ,

gcroot<:reflection::methodinfo>* mi, Boolean bLispFunction)

à AcMgCommandClass.CommandThunk.InvokeLisp(CommandThunk* )*Annuler*

Commande:

erreur: Demande ADS erronée

 

Sur ma v2011 (AutoCAD base sans applicatifs) =>

 

Commande: (gc-purge 19)

Commande: (gc-purge 2097151)

 

Je ne sais pas ce qui se fait, mais ça se fait au vu du défilement en bas à gauche de l'écran (à coté des coordonnées)désolé, je ne connais pas le nom,...

 

Donc, les applicatifs semble poser pb,...

 

J'avais déjà testé sur ma v2008 après le message de bseb67, mais pas sur la 2011 !

 

Pour faire un rapport, il aurait fallu faire un compteur par type d'objet traité. Comme c'est plutôt destiné à des programmeurs que pour être utilisé comme commande, j'ai préféré privilégie la performance.

 

Que veux-tu dire exactement par là ? Que les programmeurs pourrait se servir de cette fonction comme sou-fonction dans un prog ,

 

Donc, c'est aussi possible de l'utiliser comme tel pour ceux qui ne voudrait l'utiliser que pour purger, une option qui serait surement apprécié de certains aussi, non ?

 

Pour faire un rapport, il aurait fallu faire un compteur par type d'objet traité.

 

Ça serait compliqué de créer une version avec cette option ?

 

Comme ça, on pourrait également "comparer" avec d'autres routines existantes,...

[(gile)]

Que veux-tu dire exactement par là ? Que les programmeurs pourrait se servir de cette fonction comme sou-fonction dans un prog ,

 

À part les problèmes de compatibilité que vous avez bseb67 et toi il s'agit d'une fonction LISP en tout point semblables aux fonction LISP natives (si tu l'utilises dans l'éditeur, tu verras qu'elle s'affiche en bleu comme les fonction native et pas en noir comme les fonctions définies en LISP).

 

Par exemple, Patrick_35 pourrait très bien l'utiliser dans son nettoyeur à la place de faire :

(repeat 3 (vla-purgeall doc))

il aurait la garantie detout purger quel que soit le niveau d'imbrication des objets non référencés.

 

PS: pour voir (en partie) ce que fait gc-purge, tu lance PURGER et tu regarde dans la boite de dialogue les éléments purgeables. puis tu annules tu lances gc-purge et tu ré-ouvres la boite de la commande PURGER.

Attention, il ne s'agit pas d'une fonction de nettoyage, mais de purge : uniquement la suppression des objets non référencés (excepté pour les textes et les entités de longueur nulle)

[(gile)]

gc-Purge est ajouté à LispExtension.

[lili2006]

Bonjour à toutes et tous,

 

Salut Gilles,

 

tu verras qu'elle s'affiche en bleu comme les fonction native et pas en noir comme les fonctions définies en LISP

 

Compris !

 

 

pour voir (en partie) ce que fait gc-purge, tu lance PURGER et tu regarde dans la boite de dialogue les éléments purgeables. puis tu annules tu lances gc-purge et tu ré-ouvres la boite de la commande PURGER.

 

Bah oui, tout simplement,.... :cool:

 

Attention, il ne s'agit pas d'une fonction de nettoyage, mais de purge : uniquement la suppression des objets non référencés (excepté pour les textes et les entités de longueur nulle)

 

Vu,

 

À part les problèmes de compatibilité que vous avez bseb67 et toi il s'agit d'une fonction LISP en tout point semblables aux fonction LISP natives

 

Étrange tout de même car je n'ai jamais rencontré ce pb avec les autres lisps,...ni, il me semble avec certaines fonctions lisps que tu as rajoutés,...

 

Merci encore de ces explications,

 

Par exemple, Patrick_35 pourrait très bien l'utiliser dans son nettoyeur à la place de faire :

(repeat 3 (vla-purgeall doc))

il aurait la garantie detout purger quel que soit le niveau d'imbrication des objets non référencés.

 

Patrick_35 si tu nous lis, ;)

[(gile)]

Étrange tout de même car je n'ai jamais rencontré ce pb avec les autres lisps,...ni, il me semble avec certaines fonctions lisps que tu as rajoutés,...

 

Il ne s'agit pas de problème avec les LISP mais avec des fonctions LISP définies en .NET.

As-tu essayé avec d'autres fonctions de LispExtension (tu peux utiliser les exemples fourni à la fin de chaque rubrique dans l'aide) ?

[lili2006]

Re,

 

Je comptais regarder dans l'AM, maintenant que j'y vois plus clair,...

 

Je reviens donc,. ;)

[(gile)]

Nouvelle version : correction d'un bug avec les mtexts formatés.

[(gile)]

Un nouveau bug m'a été signalé avec gc-purge.

C'est réparé (j'espère).

Nouvelle version en téléchargement dans le premier message.

[FREDCAD31]

Bonjour à tous,

 

J'ai réussi à charger le fichier dll avec netload mais maintenant comment je fais pour m'en servir ?

Je dois lancer quel commande ?

 

Merci,

[(gile)]

C'est une fonction LISP, regarde dans le premier message, il y a des exemples.

[FREDCAD31]

Ok merci Gile j'avais pas vu !

 

A+