]> git.saurik.com Git - apt.git/blobdiff - cmdline/apt-cache.cc
Updated error messages to reflect host/ip
[apt.git] / cmdline / apt-cache.cc
index 5317445466164f7a1a981bd03583f65dfc0d82c7..de5fc615beaf30675935fd434b062d0e602c7561 100644 (file)
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
-// $Id: apt-cache.cc,v 1.10 1998/10/19 23:45:35 jgg Exp $
+// $Id: apt-cache.cc,v 1.36 1999/05/14 02:51:36 jgg Exp $
 /* ######################################################################
    
    apt-cache - Manages the cache files
@@ -8,7 +8,7 @@
    apt-cache provides some functions fo manipulating the cache files.
    It uses the command line interface common to all the APT tools. The
    only really usefull function right now is dumpavail which is used
-   by the dselect method. Everything else is ment as a debug aide.
+   by the dselect method. Everything else is meant as a debug aide.
    
    Returns 100 on failure, 0 on success.
    
 #include <apt-pkg/progress.h>
 #include <apt-pkg/sourcelist.h>
 #include <apt-pkg/cmndline.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/pkgrecords.h>
+#include <config.h>
 
 #include <iostream.h>
-#include <config.h>
+#include <unistd.h>
+#include <errno.h>
+#include <regex.h>
                                                                        /*}}}*/
 
+pkgCache *GCache = 0;
+
+// UnMet - Show unmet dependencies                                     /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool UnMet(CommandLine &CmdL)
+{
+   pkgCache &Cache = *GCache;
+   bool Important = _config->FindB("APT::Cache::Important",false);
+   
+   for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
+   {
+      for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
+      {
+        bool Header = false;
+        for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)
+        {
+           // Collect or groups
+           pkgCache::DepIterator Start;
+           pkgCache::DepIterator End;
+           D.GlobOr(Start,End);
+           
+/*         cout << "s: Check " << Start.TargetPkg().Name() << ',' <<
+              End.TargetPkg().Name() << endl;*/
+              
+           // Skip conflicts and replaces
+           if (End->Type != pkgCache::Dep::PreDepends &&
+               End->Type != pkgCache::Dep::Depends && 
+               End->Type != pkgCache::Dep::Suggests &&
+               End->Type != pkgCache::Dep::Recommends)
+              continue;
+
+           // Important deps only
+           if (Important == true)
+              if (End->Type != pkgCache::Dep::PreDepends &&
+                  End->Type != pkgCache::Dep::Depends)
+                 continue;
+           
+           // Verify the or group
+           bool OK = false;
+           pkgCache::DepIterator RealStart = Start;
+           do
+           {
+              // See if this dep is Ok
+              pkgCache::Version **VList = Start.AllTargets();
+              if (*VList != 0)
+              {
+                 OK = true;
+                 delete [] VList;
+                 break;
+              }
+              delete [] VList;
+              
+              if (Start == End)
+                 break;
+              Start++;
+           }
+           while (1);
+
+           // The group is OK
+           if (OK == true)
+              continue;
+           
+           // Oops, it failed..
+           if (Header == false)
+                 cout << "Package " << P.Name() << " version " << 
+              V.VerStr() << " has an unmet dep:" << endl;
+           Header = true;
+           
+           // Print out the dep type
+           cout << " " << End.DepType() << ": ";
+
+           // Show the group
+           Start = RealStart;
+           do
+           {
+              cout << Start.TargetPkg().Name();
+              if (Start.TargetVer() != 0)
+                 cout << " (" << Start.CompType() << " " << Start.TargetVer() <<
+                 ")";
+              if (Start == End)
+                 break;
+              cout << " | ";
+              Start++;
+           }
+           while (1);
+           
+           cout << endl;
+        }       
+      }
+   }   
+   return true;
+}
+                                                                       /*}}}*/
 // DumpPackage - Show a dump of a package record                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool DumpPackage(pkgCache &Cache,CommandLine &CmdL)
+bool DumpPackage(CommandLine &CmdL)
 {   
+   pkgCache &Cache = *GCache;
    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
    {
       pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
@@ -44,7 +144,13 @@ bool DumpPackage(pkgCache &Cache,CommandLine &CmdL)
       cout << "Package: " << Pkg.Name() << endl;
       cout << "Versions: ";
       for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
-        cout << Cur.VerStr() << ',';
+      {
+        cout << Cur.VerStr();
+        for (pkgCache::VerFileIterator Vf = Cur.FileList(); Vf.end() == false; Vf++)
+           cout << "(" << Vf.File().FileName() << ")";
+        cout << ',';
+      }
+      
       cout << endl;
       
       cout << "Reverse Depends: " << endl;
@@ -70,8 +176,7 @@ bool DumpPackage(pkgCache &Cache,CommandLine &CmdL)
       }
       cout << "Reverse Provides: " << endl;
       for (pkgCache::PrvIterator Prv = Pkg.ProvidesList(); Prv.end() != true; Prv++)
-        cout << Prv.OwnerPkg().Name() << " " << Prv.OwnerVer().VerStr();
-      cout << endl;
+        cout << Prv.OwnerPkg().Name() << " " << Prv.OwnerVer().VerStr() << endl;            
    }
 
    return true;
@@ -80,9 +185,11 @@ bool DumpPackage(pkgCache &Cache,CommandLine &CmdL)
 // Stats - Dump some nice statistics                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool Stats(pkgCache &Cache)
+bool Stats(CommandLine &Cmd)
 {
-   cout << "Total Package Names : " << Cache.Head().PackageCount << endl;
+   pkgCache &Cache = *GCache;
+   cout << "Total Package Names : " << Cache.Head().PackageCount << " (" <<
+      SizeToStr(Cache.Head().PackageCount*Cache.Head().PackageSz) << ')' << endl;
    pkgCache::PkgIterator I = Cache.PkgBegin();
    
    int Normal = 0;
@@ -127,16 +234,71 @@ bool Stats(pkgCache &Cache)
    cout << "  Mixed Virtual Packages: " << NVirt << endl;
    cout << "  Missing: " << Missing << endl;
    
-   cout << "Total Distinct Versions: " << Cache.Head().VersionCount << endl;
-   cout << "Total Dependencies: " << Cache.Head().DependsCount << endl;
+   cout << "Total Distinct Versions: " << Cache.Head().VersionCount << " (" <<
+      SizeToStr(Cache.Head().VersionCount*Cache.Head().VersionSz) << ')' << endl;
+   cout << "Total Dependencies: " << Cache.Head().DependsCount << " (" << 
+      SizeToStr(Cache.Head().DependsCount*Cache.Head().DependencySz) << ')' << endl;
+   
+   cout << "Total Ver/File relations: " << Cache.Head().VerFileCount << " (" <<
+      SizeToStr(Cache.Head().VerFileCount*Cache.Head().VerFileSz) << ')' << endl;
+   cout << "Total Provides Mappings: " << Cache.Head().ProvidesCount << " (" <<
+      SizeToStr(Cache.Head().ProvidesCount*Cache.Head().ProvidesSz) << ')' << endl;
+   
+   // String list stats
+   unsigned long Size = 0;
+   unsigned long Count = 0;
+   for (pkgCache::StringItem *I = Cache.StringItemP + Cache.Head().StringList;
+        I!= Cache.StringItemP; I = Cache.StringItemP + I->NextItem)
+   {
+      Count++;
+      Size += strlen(Cache.StrP + I->String);
+   }
+   cout << "Total Globbed Strings: " << Count << " (" << SizeToStr(Size) << ')' << endl;
+      
+   unsigned long Slack = 0;
+   for (int I = 0; I != 7; I++)
+      Slack += Cache.Head().Pools[I].ItemSize*Cache.Head().Pools[I].Count;
+   cout << "Total Slack space: " << SizeToStr(Slack) << endl;
+   
+   unsigned long Total = 0;
+   Total = Slack + Size + Cache.Head().DependsCount*Cache.Head().DependencySz + 
+           Cache.Head().VersionCount*Cache.Head().VersionSz +
+           Cache.Head().PackageCount*Cache.Head().PackageSz + 
+           Cache.Head().VerFileCount*Cache.Head().VerFileSz +
+           Cache.Head().ProvidesCount*Cache.Head().ProvidesSz;
+   cout << "Total Space Accounted for: " << SizeToStr(Total) << endl;
+   
+   return true;
+}
+                                                                       /*}}}*/
+// Check - Check some things about the cache                           /*{{{*/
+// ---------------------------------------------------------------------
+/* Debug aide mostly */
+bool Check(CommandLine &Cmd)
+{
+   pkgCache &Cache = *GCache;
+   pkgCache::PkgIterator Pkg = Cache.PkgBegin();
+   for (;Pkg.end() != true; Pkg++)
+   {
+      if (Pkg.Section() == 0 && Pkg->VersionList != 0)
+        cout << "Bad section " << Pkg.Name() << endl;
+      
+      for (pkgCache::VerIterator Cur = Pkg.VersionList(); 
+          Cur.end() != true; Cur++)
+      {
+        if (Cur->Priority < 1 || Cur->Priority > 5)
+           cout << "Bad prio " << Pkg.Name() << ',' << Cur.VerStr() << " == " << (int)Cur->Priority << endl;
+      }
+   }
    return true;
 }
                                                                        /*}}}*/
 // Dump - show everything                                              /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool Dump(pkgCache &Cache)
+bool Dump(CommandLine &Cmd)
 {
+   pkgCache &Cache = *GCache;
    for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
    {
       cout << "Package: " << P.Name() << endl;
@@ -155,7 +317,13 @@ bool Dump(pkgCache &Cache)
       cout << " Size: " << F->Size << endl;
       cout << " ID: " << F->ID << endl;
       cout << " Flags: " << F->Flags << endl;
-      cout << " Time: " << ctime(&F->mtime) << endl;
+      cout << " Time: " << TimeRFC1123(F->mtime) << endl;
+      cout << " Archive: " << F.Archive() << endl;
+      cout << " Component: " << F.Component() << endl;
+      cout << " Version: " << F.Version() << endl;
+      cout << " Origin: " << F.Origin() << endl;
+      cout << " Label: " << F.Label() << endl;
+      cout << " Architecture: " << F.Architecture() << endl;
    }
 
    return true;
@@ -164,8 +332,9 @@ bool Dump(pkgCache &Cache)
 // DumpAvail - Print out the available list                            /*{{{*/
 // ---------------------------------------------------------------------
 /* This is needed to make dpkg --merge happy */
-bool DumpAvail(pkgCache &Cache)
+bool DumpAvail(CommandLine &Cmd)
 {
+   pkgCache &Cache = *GCache;
    unsigned char *Buffer = new unsigned char[Cache.HeaderP->MaxVerFileSize];
 
    for (pkgCache::PkgFileIterator I = Cache.FileBegin(); I.end() == false; I++)
@@ -190,22 +359,20 @@ bool DumpAvail(pkgCache &Cache)
          structure to find them */
       for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
       {
-        for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
+        // Find the proper version to use. We should probably use the DepCache.
+        pkgCache::VerIterator V = Cache.GetCandidateVer(P,false);
+
+        if (V.end() == true || V.FileList().File() != I)
+           continue;
+        
+        // Read the record and then write it out again.
+        if (PkgF.Seek(V.FileList()->Offset) == false ||
+            PkgF.Read(Buffer,V.FileList()->Size) == false ||
+            write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
         {
-           if (V->FileList == 0)
-              continue;
-           if (V.FileList().File() != I)
-              continue;
-           
-           // Read the record and then write it out again.
-           if (PkgF.Seek(V.FileList()->Offset) == false ||
-               PkgF.Read(Buffer,V.FileList()->Size) == false ||
-               write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
-           {
-              delete [] Buffer;
-              return false;
-           }       
-        }
+           delete [] Buffer;
+           return false;
+        }       
       }
    }
    
@@ -222,7 +389,7 @@ bool DoAdd(CommandLine &CmdL)
       return _error->Error("You must give at least one file name");
    
    // Open the cache
-   FileFd CacheF(_config->FindFile("Dir::Cache::srcpkgcache"),FileFd::WriteAny);
+   FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
    if (_error->PendingError() == true)
       return false;
    
@@ -239,7 +406,8 @@ bool DoAdd(CommandLine &CmdL)
    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
    {
       Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
-      
+      Progress.SubProgress(Length);
+
       // Do the merge
       FileFd TagF(*I,FileFd::ReadOnly);
       debListParser Parser(TagF);
@@ -254,15 +422,129 @@ bool DoAdd(CommandLine &CmdL)
    }
 
    Progress.Done();
-   Stats(Gen.GetCache());
+   GCache = &Gen.GetCache();
+   Stats(CmdL);
+   
+   return true;
+}
+                                                                       /*}}}*/
+// DisplayRecord - Displays the complete record for the package                /*{{{*/
+// ---------------------------------------------------------------------
+/* This displays the package record from the proper package index file. 
+   It is not used by DumpAvail for performance reasons. */
+bool DisplayRecord(pkgCache::VerIterator V)
+{
+   // Find an appropriate file
+   pkgCache::VerFileIterator Vf = V.FileList();
+   for (; Vf.end() == false; Vf++)
+      if ((Vf.File()->Flags & pkgCache::Flag::NotSource) == 0)
+        break;
+   if (Vf.end() == true)
+      Vf = V.FileList();
+      
+   // Check and load the package list file
+   pkgCache::PkgFileIterator I = Vf.File();
+   if (I.IsOk() == false)
+      return _error->Error("Package file %s is out of sync.",I.FileName());
+   
+   FileFd PkgF(I.FileName(),FileFd::ReadOnly);
+   if (_error->PendingError() == true)
+      return false;
+   
+   // Read the record and then write it out again.
+   unsigned char *Buffer = new unsigned char[GCache->HeaderP->MaxVerFileSize];
+   if (PkgF.Seek(V.FileList()->Offset) == false ||
+       PkgF.Read(Buffer,V.FileList()->Size) == false ||
+       write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
+   {
+      delete [] Buffer;
+      return false;
+   }
+   
+   delete [] Buffer;
+
+   return true;
+}
+                                                                       /*}}}*/
+// Search - Perform a search                                           /*{{{*/
+// ---------------------------------------------------------------------
+/* This searches the package names and pacakge descriptions for a pattern */
+bool Search(CommandLine &CmdL)
+{
+   pkgCache &Cache = *GCache;
+   bool ShowFull = _config->FindB("APT::Cache::ShowFull",false);
+   bool NamesOnly = _config->FindB("APT::Cache::NamesOnly",false);
+   
+   // Make sure there is at least one argument
+   if (CmdL.FileSize() != 2)
+      return _error->Error("You must give exactly one pattern");
+   
+   // Compile the regex pattern
+   regex_t Pattern;
+   if (regcomp(&Pattern,CmdL.FileList[1],REG_EXTENDED | REG_ICASE | 
+              REG_NOSUB) != 0)
+      return _error->Error("Regex compilation error");
+   
+   // Create the text record parser
+   pkgRecords Recs(Cache);
+   if (_error->PendingError() == true)
+      return false;
+   
+   // Search package names
+   pkgCache::PkgIterator I = Cache.PkgBegin();
+   for (;I.end() != true; I++)
+   {
+      // We search against the install version as that makes the most sense..
+      pkgCache::VerIterator V = Cache.GetCandidateVer(I);
+      if (V.end() == true)
+        continue;
+
+      pkgRecords::Parser &P = Recs.Lookup(V.FileList());
+      
+      if (regexec(&Pattern,I.Name(),0,0,0) == 0 ||
+         (NamesOnly == false && 
+          regexec(&Pattern,P.LongDesc().c_str(),0,0,0) == 0))
+      {
+        if (ShowFull == true)
+           DisplayRecord(V);
+        else
+           cout << I.Name() << " - " << P.ShortDesc() << endl;
+      }      
+   }
    
+   regfree(&Pattern);
+   return true;
+}
+                                                                       /*}}}*/
+// ShowPackage - Dump the package record to the screen                 /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool ShowPackage(CommandLine &CmdL)
+{   
+   pkgCache &Cache = *GCache;
+   for (const char **I = CmdL.FileList + 1; *I != 0; I++)
+   {
+      pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
+      if (Pkg.end() == true)
+      {
+        _error->Warning("Unable to locate package %s",*I);
+        continue;
+      }
+      
+      // Find the proper version to use. We should probably use the DepCache.
+      pkgCache::VerIterator V = Cache.GetCandidateVer(Pkg);
+      if (V.end() == true || V.FileList().end() == true)
+        continue;
+      if (DisplayRecord(V) == false)
+        return false;
+   }
    return true;
 }
                                                                        /*}}}*/
 // GenCaches - Call the main cache generator                           /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool GenCaches()
+bool GenCaches(CommandLine &Cmd)
 {
    OpTextProgress Progress(*_config);
    
@@ -274,10 +556,12 @@ bool GenCaches()
 // ShowHelp - Show a help screen                                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-int ShowHelp()
+bool ShowHelp(CommandLine &Cmd)
 {
    cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
        " compiled on " << __DATE__ << "  " << __TIME__ << endl;
+   if (_config->FindB("version") == true)
+      return 100;
    
    cout << "Usage: apt-cache [options] command" << endl;
    cout << "       apt-cache [options] add file1 [file1 ...]" << endl;
@@ -285,7 +569,7 @@ int ShowHelp()
    cout << endl;
    cout << "apt-cache is a low-level tool used to manipulate APT's binary" << endl;
    cout << "cache files stored in " << _config->FindFile("Dir::Cache") << endl;
-   cout << "It is not ment for ordinary use only as a debug aide." << endl;
+   cout << "It is not meant for ordinary use only as a debug aide." << endl;
    cout << endl;
    cout << "Commands:" << endl;
    cout << "   add - Add an package file to the source cache" << endl;
@@ -294,15 +578,20 @@ int ShowHelp()
    cout << "   stats - Show some basic statistics" << endl;
    cout << "   dump - Show the entire file in a terse form" << endl;
    cout << "   dumpavail - Print an available file to stdout" << endl;
+   cout << "   unmet - Show unmet dependencies" << endl;
+   cout << "   check - Check the cache a bit" << endl;
+   cout << "   search - Search the package list for a regex pattern" << endl;
+   cout << "   show - Show a readable record for the package" << endl;
    cout << endl;
    cout << "Options:" << endl;
    cout << "  -h   This help text." << endl;
    cout << "  -p=? The package cache. [" << _config->FindFile("Dir::Cache::pkgcache") << ']' << endl;
    cout << "  -s=? The source cache. [" << _config->FindFile("Dir::Cache::srcpkgcache") << ']' << endl;
-   cout << "  -q   Disable progress indicator. " << endl;
+   cout << "  -q   Disable progress indicator." << endl;
+   cout << "  -i   Show only important deps for the unmet command." << endl;
    cout << "  -c=? Read this configuration file" << endl;
-   cout << "  -o=? Set an arbitary configuration option, ie -o dir::cache=/tmp" << endl;
-   cout << "See the apt-cache(8) and apt.conf(8) manual pages for more information." << endl;
+   cout << "  -o=? Set an arbitary configuration option, eg -o dir::cache=/tmp" << endl;
+   cout << "See the apt-cache(8) and apt.conf(5) manual pages for more information." << endl;
    return 100;
 }
                                                                        /*}}}*/
@@ -320,12 +609,29 @@ int main(int argc,const char *argv[])
 {
    CommandLine::Args Args[] = {
       {'h',"help","help",0},
+      {'v',"version","version",0},
       {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
       {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
       {'q',"quiet","quiet",CommandLine::IntLevel},
+      {'i',"important","APT::Cache::Important",0},
+      {'f',"full","APT::Cache::ShowFull",0},
+      {0,"names-only","APT::Cache::NamesOnly",0},
       {'c',"config-file",0,CommandLine::ConfigFile},
       {'o',"option",0,CommandLine::ArbItem},
       {0,0,0,0}};
+   CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
+                                    {"add",&DoAdd},
+                                    {"gencaches",&GenCaches},
+                                    {0,0}};
+   CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
+                                    {"stats",&Stats},
+                                    {"dump",&Dump},
+                                    {"dumpavail",&DumpAvail},
+                                    {"unmet",&UnMet},
+                                    {"check",&Check},
+                                    {"search",&Search},
+                                    {"show",&ShowPackage},
+                                    {0,0}};
 
    CacheInitialize();
    
@@ -341,61 +647,29 @@ int main(int argc,const char *argv[])
    // See if the help should be shown
    if (_config->FindB("help") == true ||
        CmdL.FileSize() == 0)
-      return ShowHelp();
-   
-   while (1)
-   {
-      if (strcmp(CmdL.FileList[0],"add") == 0)
-      {
-        DoAdd(CmdL);
-        break;
-      }
+      return ShowHelp(CmdL);
 
-      if (strcmp(CmdL.FileList[0],"gencaches") == 0)
-      {
-        GenCaches();
-        break;
-      }
+   // Deal with stdout not being a tty
+   if (ttyname(STDOUT_FILENO) == 0 && _config->FindI("quiet",0) < 1)
+      _config->Set("quiet","1");
 
+   if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
+   {      
       // Open the cache file
-      FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::ReadOnly);
-      if (_error->PendingError() == true)
-        break;
-      
-      MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
-      if (_error->PendingError() == true)
-        break;
-      
-      pkgCache Cache(Map);   
-      if (_error->PendingError() == true)
-        break;
-    
-      if (strcmp(CmdL.FileList[0],"showpkg") == 0)
-      {
-        DumpPackage(Cache,CmdL);
-        break;
-      }
+      pkgSourceList List;
+      List.ReadMainList();
 
-      if (strcmp(CmdL.FileList[0],"stats") == 0)
+      // Generate it and map it
+      OpProgress Prog;
+      MMap *Map = pkgMakeStatusCacheMem(List,Prog);
+      if (_error->PendingError() == false)
       {
-        Stats(Cache);
-        break;
-      }
-      
-      if (strcmp(CmdL.FileList[0],"dump") == 0)
-      {
-        Dump(Cache);
-        break;
-      }
-      
-      if (strcmp(CmdL.FileList[0],"dumpavail") == 0)
-      {
-        DumpAvail(Cache);
-        break;
+        pkgCache Cache(*Map);   
+        GCache = &Cache;
+        if (_error->PendingError() == false)
+           CmdL.DispatchArg(CmdsB);
       }
-            
-      _error->Error("Invalid operation %s", CmdL.FileList[0]);
-      break;
+      delete Map;
    }
    
    // Print any errors or warnings found during parsing