compbench-devel

[Frederic T. <xf...@us...>]

Update of /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv19223

Modified Files:
	Benchmark-BZIP2.cpp Benchmark-BZIP2.h 
	Benchmark-BZIP2.libwrapper.h Benchmark-GZIP.cpp 
	Benchmark-GZIP.h Benchmark-GZIP.libwrapper.h 
	Benchmark-NBENCH.cpp Benchmark-NBENCH.h 
	Benchmark-NBENCH.libwrapper.h Benchmark-SCIMARK2.libwrapper.h 
	benchmarks-genlibwrapper.pl 
Log Message:
CBM namespace.

Index: Benchmark-NBENCH.h
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/Benchmark-NBENCH.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** Benchmark-NBENCH.h	3 Jan 2007 22:06:27 -0000	1.3
--- Benchmark-NBENCH.h	18 Jan 2007 18:44:36 -0000	1.4
***************
*** 13,237 ****
  #include <Benchmark/Package.h>
  
! /** \brief Defines the nbench package.
!  */
! class CBMPackageNBENCH : public CBMPackage
! {
!  public:
!  private:
!   virtual std::string downloadURL(void);
!   virtual std::string expectedMD5(void);
  
!   virtual std::string packageName(void);
  
!   virtual std::string packageVersion(void);
!   virtual int packageSize(void); /* in bytes */
!   virtual std::string packageComments(void);
!   virtual std::string localPackageName(void);
  		
  
!  protected:
!   virtual std::string language(void);
  
!   virtual char* extractDirectory(void);
  
!   virtual int extract(int _force = 0);
!   virtual int preConfigure(int _force);
!   virtual int configure(CBMCompiler        *_currentCompiler,
! 			CBMCompilerOptions *_currentOptions);
  
!   virtual int make(void);
!   virtual int release(void);
  
!  public:
!   CBMPackageNBENCH(class CBMSystem *_system);
!   DLPackageWrapper_declare();
  
!   virtual std::string license(void);
!   virtual std::string homePage(void);
!   virtual std::string author(void);
  
!   virtual int benchmarkSize(void);
!   virtual ~CBMPackageNBENCH();
  		
! };
  
! /** \brief Abstract benchmark for CBMPackageNBENCH package.
!  */
! class CBMBenchmarkNBENCH : public CBMBenchmark
! {
!  protected:
  
!   virtual int nbyteWriteDatFile(void);
  
!   virtual std::string benchmarkComments(void);
!   virtual std::string nbyteBenchmark(void) = 0;
!   virtual std::string nbyteBenchmarkLabel(void) = 0;
!   virtual std::string benchmarkNBENCHComments(void) = 0;
    
!   virtual std::string bench(void);
  
!   CBMBenchmarkNBENCH(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH();
! };
  
! /** \brief Defines the numsort benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_NUMSORT : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_NUMSORT(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_NUMSORT();
! };
  
! /** \brief Defines the stringsort benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_STRINGSORT : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_STRINGSORT(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_STRINGSORT();
! };
  
! /** \brief Defines the bitfield benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_BITFIELD : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_BITFIELD(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_BITFIELD();
! };
  
! /** \brief Defines the emf benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_EMF : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_EMF(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_EMF();
! };
  
! /** \brief Defines the fourier benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_FOURIER : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_FOURIER(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_FOURIER();
! };
  
! /** \brief Defines the assign benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_ASSIGN : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_ASSIGN(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_ASSIGN();
! };
  
! /** \brief Defines the huffman benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_HUFFMAN : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_HUFFMAN(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_HUFFMAN();
! };
  
! /** \brief Defines the idea benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_IDEA : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_IDEA(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_IDEA();
! };
  
! /** \brief Defines the nnet benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_NNET : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_NNET(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_NNET();
! };
  
! /** \brief Defines the lu benchmark within nbench package.
!  */
! class CBMBenchmarkNBENCH_LU : public CBMBenchmarkNBENCH
! {
!  protected:
!   virtual std::string benchmarkName(void);
!   virtual std::string benchmarkNBENCHComments(void);
  
!   virtual std::string nbyteBenchmark(void);
!   virtual std::string nbyteBenchmarkLabel(void);
  
!  public:
!   CBMBenchmarkNBENCH_LU(CBMPackage *_package);
!   virtual ~CBMBenchmarkNBENCH_LU();
! };
  
  DLdeclare();
--- 13,239 ----
  #include <Benchmark/Package.h>
  
! namespace CBM {
!   /** \brief Defines the nbench package.
!    */
!   class PackageNBENCH : public Package
!   {
!   public:
!   private:
!     virtual std::string downloadURL(void);
!     virtual std::string expectedMD5(void);
  
!     virtual std::string packageName(void);
  
!     virtual std::string packageVersion(void);
!     virtual int packageSize(void); /* in bytes */
!     virtual std::string packageComments(void);
!     virtual std::string localPackageName(void);
  		
  
!   protected:
!     virtual std::string language(void);
  
!     virtual char* extractDirectory(void);
  
!     virtual int extract(int _force = 0);
!     virtual int preConfigure(int _force);
!     virtual int configure(Compiler        *_currentCompiler,
! 			  CompilerOptions *_currentOptions);
  
!     virtual int make(void);
!     virtual int release(void);
  
!   public:
!     PackageNBENCH(class System *_system);
!     DLPackageWrapper_declare();
  
!     virtual std::string license(void);
!     virtual std::string homePage(void);
!     virtual std::string author(void);
  
!     virtual int benchmarkSize(void);
!     virtual ~PackageNBENCH();
  		
!   };
  
!   /** \brief Abstract benchmark for PackageNBENCH package.
!    */
!   class BenchmarkNBENCH : public Benchmark
!   {
!   protected:
  
!     virtual int nbyteWriteDatFile(void);
  
!     virtual std::string benchmarkComments(void);
!     virtual std::string nbyteBenchmark(void) = 0;
!     virtual std::string nbyteBenchmarkLabel(void) = 0;
!     virtual std::string benchmarkNBENCHComments(void) = 0;
    
!     virtual std::string bench(void);
  
!     BenchmarkNBENCH(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH();
!   };
  
!   /** \brief Defines the numsort benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_NUMSORT : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_NUMSORT(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_NUMSORT();
!   };
  
!   /** \brief Defines the stringsort benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_STRINGSORT : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_STRINGSORT(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_STRINGSORT();
!   };
  
!   /** \brief Defines the bitfield benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_BITFIELD : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_BITFIELD(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_BITFIELD();
!   };
  
!   /** \brief Defines the emf benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_EMF : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_EMF(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_EMF();
!   };
  
!   /** \brief Defines the fourier benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_FOURIER : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_FOURIER(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_FOURIER();
!   };
  
!   /** \brief Defines the assign benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_ASSIGN : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_ASSIGN(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_ASSIGN();
!   };
  
!   /** \brief Defines the huffman benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_HUFFMAN : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_HUFFMAN(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_HUFFMAN();
!   };
  
!   /** \brief Defines the idea benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_IDEA : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_IDEA(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_IDEA();
!   };
  
!   /** \brief Defines the nnet benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_NNET : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_NNET(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_NNET();
!   };
  
!   /** \brief Defines the lu benchmark within nbench package.
!    */
!   class BenchmarkNBENCH_LU : public BenchmarkNBENCH
!   {
!   protected:
!     virtual std::string benchmarkName(void);
!     virtual std::string benchmarkNBENCHComments(void);
  
!     virtual std::string nbyteBenchmark(void);
!     virtual std::string nbyteBenchmarkLabel(void);
  
!   public:
!     BenchmarkNBENCH_LU(CBM::Package *_package);
!     virtual ~BenchmarkNBENCH_LU();
!   };
! }
  
  DLdeclare();

Index: Benchmark-NBENCH.libwrapper.h
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/Benchmark-NBENCH.libwrapper.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** Benchmark-NBENCH.libwrapper.h	15 Jan 2007 20:07:21 -0000	1.3
--- Benchmark-NBENCH.libwrapper.h	18 Jan 2007 18:44:36 -0000	1.4
***************
*** 2,10 ****
  #include <UI/UI.h>
  
! int CBMPackageNBENCH::benchmarkNumber(void) {
    return(10);
  }
  
! BenchmarkVector& CBMPackageNBENCH::Benchmarks(void) {
    if (benchmarks.size()) return(benchmarks);
    benchmarks.push_back("nbench-stringsort");
--- 2,12 ----
  #include <UI/UI.h>
  
! using namespace CBM;
! 
! int PackageNBENCH::benchmarkNumber(void) {
    return(10);
  }
  
! CBM::BenchmarkVector& PackageNBENCH::Benchmarks(void) {
    if (benchmarks.size()) return(benchmarks);
    benchmarks.push_back("nbench-stringsort");
***************
*** 21,64 ****
  }
  
! CBMBenchmark *CBMPackageNBENCH::Benchmark(std::string bid) {
    if (bid == "nbench-stringsort") {
!      return(new CBMBenchmarkNBENCH_STRINGSORT(this));
    }
    if (bid == "nbench-lu") {
!      return(new CBMBenchmarkNBENCH_LU(this));
    }
    if (bid == "nbench-assign") {
!      return(new CBMBenchmarkNBENCH_ASSIGN(this));
    }
    if (bid == "nbench-numsort") {
!      return(new CBMBenchmarkNBENCH_NUMSORT(this));
    }
    if (bid == "nbench-fourier") {
!      return(new CBMBenchmarkNBENCH_FOURIER(this));
    }
    if (bid == "nbench-bitfield") {
!      return(new CBMBenchmarkNBENCH_BITFIELD(this));
    }
    if (bid == "nbench-emf") {
!      return(new CBMBenchmarkNBENCH_EMF(this));
    }
    if (bid == "nbench-huffman") {
!      return(new CBMBenchmarkNBENCH_HUFFMAN(this));
    }
    if (bid == "nbench-nnet") {
!      return(new CBMBenchmarkNBENCH_NNET(this));
    }
    if (bid == "nbench-idea") {
!      return(new CBMBenchmarkNBENCH_IDEA(this));
    }
!   UI->Fatal("Unknown benchmark");
    return(0);
  }
  
! CBMPackage *package_NBENCH = 0;
! CBMPackage *cbmlib_getPackage(void) {
    if (!package_NBENCH) {
!      package_NBENCH=new CBMPackageNBENCH(cbmSystem);
!      cbmlib_packages.push_back(package_NBENCH);
    }
    return(package_NBENCH);
--- 23,66 ----
  }
  
! CBM::Benchmark *PackageNBENCH::Benchmark(std::string bid) {
    if (bid == "nbench-stringsort") {
!      return(new CBM::BenchmarkNBENCH_STRINGSORT(this));
    }
    if (bid == "nbench-lu") {
!      return(new CBM::BenchmarkNBENCH_LU(this));
    }
    if (bid == "nbench-assign") {
!      return(new CBM::BenchmarkNBENCH_ASSIGN(this));
    }
    if (bid == "nbench-numsort") {
!      return(new CBM::BenchmarkNBENCH_NUMSORT(this));
    }
    if (bid == "nbench-fourier") {
!      return(new CBM::BenchmarkNBENCH_FOURIER(this));
    }
    if (bid == "nbench-bitfield") {
!      return(new CBM::BenchmarkNBENCH_BITFIELD(this));
    }
    if (bid == "nbench-emf") {
!      return(new CBM::BenchmarkNBENCH_EMF(this));
    }
    if (bid == "nbench-huffman") {
!      return(new CBM::BenchmarkNBENCH_HUFFMAN(this));
    }
    if (bid == "nbench-nnet") {
!      return(new CBM::BenchmarkNBENCH_NNET(this));
    }
    if (bid == "nbench-idea") {
!      return(new CBM::BenchmarkNBENCH_IDEA(this));
    }
!   CBM::cbmUI->Fatal("Unknown benchmark");
    return(0);
  }
  
! CBM::Package *package_NBENCH = 0;
! CBM::Package *cbmlib_getPackage(void) {
    if (!package_NBENCH) {
!      package_NBENCH=new PackageNBENCH(CBM::cbmSystem);
!      CBM::cbmlib_packages.push_back(package_NBENCH);
    }
    return(package_NBENCH);

Index: Benchmark-GZIP.libwrapper.h
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/Benchmark-GZIP.libwrapper.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** Benchmark-GZIP.libwrapper.h	15 Jan 2007 20:07:20 -0000	1.3
--- Benchmark-GZIP.libwrapper.h	18 Jan 2007 18:44:36 -0000	1.4
***************
*** 2,10 ****
  #include <UI/UI.h>
  
! int CBMPackageGZIP::benchmarkNumber(void) {
    return(2);
  }
  
! BenchmarkVector& CBMPackageGZIP::Benchmarks(void) {
    if (benchmarks.size()) return(benchmarks);
    benchmarks.push_back("gzip-9c");
--- 2,12 ----
  #include <UI/UI.h>
  
! using namespace CBM;
! 
! int PackageGZIP::benchmarkNumber(void) {
    return(2);
  }
  
! CBM::BenchmarkVector& PackageGZIP::Benchmarks(void) {
    if (benchmarks.size()) return(benchmarks);
    benchmarks.push_back("gzip-9c");
***************
*** 13,32 ****
  }
  
! CBMBenchmark *CBMPackageGZIP::Benchmark(std::string bid) {
    if (bid == "gzip-9c") {
!      return(new CBMBenchmarkGZIP9(this));
    }
    if (bid == "gzip-1c") {
!      return(new CBMBenchmarkGZIP1(this));
    }
!   UI->Fatal("Unknown benchmark");
    return(0);
  }
  
! CBMPackage *package_GZIP = 0;
! CBMPackage *cbmlib_getPackage(void) {
    if (!package_GZIP) {
!      package_GZIP=new CBMPackageGZIP(cbmSystem);
!      cbmlib_packages.push_back(package_GZIP);
    }
    return(package_GZIP);
--- 15,34 ----
  }
  
! CBM::Benchmark *PackageGZIP::Benchmark(std::string bid) {
    if (bid == "gzip-9c") {
!      return(new CBM::BenchmarkGZIP9(this));
    }
    if (bid == "gzip-1c") {
!      return(new CBM::BenchmarkGZIP1(this));
    }
!   CBM::cbmUI->Fatal("Unknown benchmark");
    return(0);
  }
  
! CBM::Package *package_GZIP = 0;
! CBM::Package *cbmlib_getPackage(void) {
    if (!package_GZIP) {
!      package_GZIP=new PackageGZIP(CBM::cbmSystem);
!      CBM::cbmlib_packages.push_back(package_GZIP);
    }
    return(package_GZIP);

Index: benchmarks-genlibwrapper.pl
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/benchmarks-genlibwrapper.pl,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** benchmarks-genlibwrapper.pl	15 Jan 2007 20:07:21 -0000	1.2
--- benchmarks-genlibwrapper.pl	18 Jan 2007 18:44:36 -0000	1.3
***************
*** 31,42 ****
    print "#include <Benchmark/Benchmark-DLLoader.h>\n";
    print "#include <UI/UI.h>\n\n";
  
    my $n = (keys %{$DATA{$PACKAGE}})+0;
  
    
!   print "int CBMPackage$PACKAGE\::benchmarkNumber(void) {\n";
    print "  return($n);\n}\n\n";
  
!   print "BenchmarkVector& CBMPackage$PACKAGE\::Benchmarks(void) {\n";
    print "  if (benchmarks.size()) return(benchmarks);\n";
    foreach(keys %{$DATA{$PACKAGE}}) {
--- 31,43 ----
    print "#include <Benchmark/Benchmark-DLLoader.h>\n";
    print "#include <UI/UI.h>\n\n";
+   print "using namespace CBM;\n\n";
  
    my $n = (keys %{$DATA{$PACKAGE}})+0;
  
    
!   print "int Package$PACKAGE\::benchmarkNumber(void) {\n";
    print "  return($n);\n}\n\n";
  
!   print "CBM::BenchmarkVector& Package$PACKAGE\::Benchmarks(void) {\n";
    print "  if (benchmarks.size()) return(benchmarks);\n";
    foreach(keys %{$DATA{$PACKAGE}}) {
***************
*** 46,64 ****
    print "}\n\n";
  
!   print "CBMBenchmark *CBMPackage$PACKAGE\::Benchmark(std::string bid) {\n";
    foreach(keys %{$DATA{$PACKAGE}}) {
      print "  if (bid == \"$_\") {\n";
!     print "     return(new CBMBenchmark$DATA{$PACKAGE}->{$_}(this));\n";
      print "  }\n";
    }
!   print "  UI->Fatal(\"Unknown benchmark\");\n";
    print "  return(0);\n";
    print "}\n\n";
  
!   print "CBMPackage *package_$PACKAGE = 0;\n";
!   print "CBMPackage *cbmlib_getPackage(void) {\n";
    print "  if (!package_$PACKAGE) {\n";
!   print "     package_$PACKAGE=new CBMPackage$PACKAGE(cbmSystem);\n";
!   print "     cbmlib_packages.push_back(package_$PACKAGE);\n";
    print "  }\n";
    print "  return(package_$PACKAGE);\n";
--- 47,65 ----
    print "}\n\n";
  
!   print "CBM::Benchmark *Package$PACKAGE\::Benchmark(std::string bid) {\n";
    foreach(keys %{$DATA{$PACKAGE}}) {
      print "  if (bid == \"$_\") {\n";
!     print "     return(new CBM::Benchmark$DATA{$PACKAGE}->{$_}(this));\n";
      print "  }\n";
    }
!   print "  CBM::cbmUI->Fatal(\"Unknown benchmark\");\n";
    print "  return(0);\n";
    print "}\n\n";
  
!   print "CBM::Package *package_$PACKAGE = 0;\n";
!   print "CBM::Package *cbmlib_getPackage(void) {\n";
    print "  if (!package_$PACKAGE) {\n";
!   print "     package_$PACKAGE=new Package$PACKAGE(CBM::cbmSystem);\n";
!   print "     CBM::cbmlib_packages.push_back(package_$PACKAGE);\n";
    print "  }\n";
    print "  return(package_$PACKAGE);\n";

Index: Benchmark-NBENCH.cpp
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/Benchmark-NBENCH.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** Benchmark-NBENCH.cpp	3 Jan 2007 18:53:17 -0000	1.2
--- Benchmark-NBENCH.cpp	18 Jan 2007 18:44:36 -0000	1.3
***************
*** 7,61 ****
  #include <SupportedBenchmarks/Benchmark-NBENCH.libwrapper.h>
  
! CBMPackageNBENCH::CBMPackageNBENCH(CBMSystem *_system)
!   : CBMPackage(_system)
  {
  }
  
! std::string CBMPackageNBENCH::downloadURL(void)
  {
    return("http://www.tux.org/~mayer/linux/nbench-byte-2.2.2.tar.gz");
  }
  
! std::string CBMPackageNBENCH::expectedMD5(void)
  {
    return("174c1917eea8f74bd3e78522592e0658");
  }
  
! std::string CBMPackageNBENCH::packageName(void)
  {
    return("nbench");
  }
  
! std::string CBMPackageNBENCH::packageVersion(void)
  {
    return("2.2.2");
  }
  
! int CBMPackageNBENCH::packageSize(void)
  {
    return(111751);
  }
  
! std::string CBMPackageNBENCH::packageComments(void)
  {
    return("Uwe F. Mayer's UNIX port of BYTE Magazine's BYTEmark benchmark program");
  }
  
! std::string CBMPackageNBENCH::localPackageName(void)
  {
    return("nbench-byte-2.2.2.tar.gz");
  }
  
! std::string CBMPackageNBENCH::language(void)
  {
    return("C");
  }
  
! char* CBMPackageNBENCH::extractDirectory(void)
  {
    return("nbench-byte-2.2.2");
  }
  
! int CBMPackageNBENCH::extract(int _force)
  {
    std::string localFile = localPackageAbsoluteName();
--- 7,63 ----
  #include <SupportedBenchmarks/Benchmark-NBENCH.libwrapper.h>
  
! using namespace CBM;
! 
! PackageNBENCH::PackageNBENCH(CBM::System *_system)
!   : Package(_system)
  {
  }
  
! std::string PackageNBENCH::downloadURL(void)
  {
    return("http://www.tux.org/~mayer/linux/nbench-byte-2.2.2.tar.gz");
  }
  
! std::string PackageNBENCH::expectedMD5(void)
  {
    return("174c1917eea8f74bd3e78522592e0658");
  }
  
! std::string PackageNBENCH::packageName(void)
  {
    return("nbench");
  }
  
! std::string PackageNBENCH::packageVersion(void)
  {
    return("2.2.2");
  }
  
! int PackageNBENCH::packageSize(void)
  {
    return(111751);
  }
  
! std::string PackageNBENCH::packageComments(void)
  {
    return("Uwe F. Mayer's UNIX port of BYTE Magazine's BYTEmark benchmark program");
  }
  
! std::string PackageNBENCH::localPackageName(void)
  {
    return("nbench-byte-2.2.2.tar.gz");
  }
  
! std::string PackageNBENCH::language(void)
  {
    return("C");
  }
  
! char* PackageNBENCH::extractDirectory(void)
  {
    return("nbench-byte-2.2.2");
  }
  
! int PackageNBENCH::extract(int _force)
  {
    std::string localFile = localPackageAbsoluteName();
***************
*** 64,68 ****
  
    cmd+="cd ";
!   cmd+=system->temporaryDirectory(CBMSystem::Extract);
    cmd+=" && ";
    cmd+=CBM_PROG_ZCAT;
--- 66,70 ----
  
    cmd+="cd ";
!   cmd+=system->temporaryDirectory(CBM::System::Extract);
    cmd+=" && ";
    cmd+=CBM_PROG_ZCAT;
***************
*** 76,80 ****
  }
  
! int CBMPackageNBENCH::preConfigure(int _force)
  {
    /* !!! */
--- 78,82 ----
  }
  
! int PackageNBENCH::preConfigure(int _force)
  {
    /* !!! */
***************
*** 82,92 ****
  }
  
! int CBMPackageNBENCH::configure(CBMCompiler        *_currentCompiler,
! 				  CBMCompilerOptions *_currentOptions)
  {
    return(1);
  }
  
! int CBMPackageNBENCH::make(void)
  {
    std::string cmd;
--- 84,94 ----
  }
  
! int PackageNBENCH::configure(CBM::Compiler        *_currentCompiler,
! 			     CBM::CompilerOptions *_currentOptions)
  {
    return(1);
  }
  
! int PackageNBENCH::make(void)
  {
    std::string cmd;
***************
*** 126,130 ****
  }
  
! int CBMPackageNBENCH::release(void)
  {
    std::string cmd;
--- 128,132 ----
  }
  
! int PackageNBENCH::release(void)
  {
    std::string cmd;
***************
*** 140,173 ****
  }
  
! std::string CBMPackageNBENCH::license(void)
  {
    return("Not specified");
  }
  
! std::string CBMPackageNBENCH::homePage(void)
  {
    return("http://www.tux.org/~mayer/linux/bmark.html");
  }
  
! std::string CBMPackageNBENCH::author(void)
  {
    return("Uwe F. Mayer");
  }
  
! int CBMPackageNBENCH::benchmarkSize(void)
  {
    return(packageSize());
  }
  
! CBMPackageNBENCH::~CBMPackageNBENCH()
  {
  }
  
! CBMBenchmarkNBENCH::CBMBenchmarkNBENCH(CBMPackage *_package)
!   : CBMBenchmark(_package)
  {
  }
  
! int CBMBenchmarkNBENCH::nbyteWriteDatFile(void)
  {
    std::ofstream OUT;
--- 142,175 ----
  }
  
! std::string PackageNBENCH::license(void)
  {
    return("Not specified");
  }
  
! std::string PackageNBENCH::homePage(void)
  {
    return("http://www.tux.org/~mayer/linux/bmark.html");
  }
  
! std::string PackageNBENCH::author(void)
  {
    return("Uwe F. Mayer");
  }
  
! int PackageNBENCH::benchmarkSize(void)
  {
    return(packageSize());
  }
  
! PackageNBENCH::~PackageNBENCH()
  {
  }
  
! BenchmarkNBENCH::BenchmarkNBENCH(CBM::Package *_package)
!   : Benchmark(_package)
  {
  }
  
! int BenchmarkNBENCH::nbyteWriteDatFile(void)
  {
    std::ofstream OUT;
***************
*** 188,192 ****
  }
  
! std::string CBMBenchmarkNBENCH::benchmarkComments(void)
  {
    std::string comment;
--- 190,194 ----
  }
  
! std::string BenchmarkNBENCH::benchmarkComments(void)
  {
    std::string comment;
***************
*** 198,202 ****
  }
  
! std::string CBMBenchmarkNBENCH::bench(void)
  {
    std::string cmd;
--- 200,204 ----
  }
  
! std::string BenchmarkNBENCH::bench(void)
  {
    std::string cmd;
***************
*** 221,249 ****
  }
  
! CBMBenchmarkNBENCH::~CBMBenchmarkNBENCH()
  {
  }
  
! CBMBenchmarkNBENCH_NUMSORT::CBMBenchmarkNBENCH_NUMSORT(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_NUMSORT::nbyteBenchmark(void)
  {
    return("DONUMSORT");
  }
  
! std::string CBMBenchmarkNBENCH_NUMSORT::benchmarkName(void)
  {
    return("nbench-numsort");
  }
  
! std::string CBMBenchmarkNBENCH_NUMSORT::nbyteBenchmarkLabel(void)
  {
    return("NUMERIC SORT");
  }
  
! std::string CBMBenchmarkNBENCH_NUMSORT::benchmarkNBENCHComments(void)
  {
    return("Generic integer performance.  Should " \
--- 223,251 ----
  }
  
! BenchmarkNBENCH::~BenchmarkNBENCH()
  {
  }
  
! BenchmarkNBENCH_NUMSORT::BenchmarkNBENCH_NUMSORT(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_NUMSORT::nbyteBenchmark(void)
  {
    return("DONUMSORT");
  }
  
! std::string BenchmarkNBENCH_NUMSORT::benchmarkName(void)
  {
    return("nbench-numsort");
  }
  
! std::string BenchmarkNBENCH_NUMSORT::nbyteBenchmarkLabel(void)
  {
    return("NUMERIC SORT");
  }
  
! std::string BenchmarkNBENCH_NUMSORT::benchmarkNBENCHComments(void)
  {
    return("Generic integer performance.  Should " \
***************
*** 254,282 ****
  }
  
! CBMBenchmarkNBENCH_NUMSORT::~CBMBenchmarkNBENCH_NUMSORT()
  {
  }
  
! CBMBenchmarkNBENCH_STRINGSORT::CBMBenchmarkNBENCH_STRINGSORT(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_STRINGSORT::nbyteBenchmark(void)
  {
    return("DOSTRINGSORT");
  }
  
! std::string CBMBenchmarkNBENCH_STRINGSORT::benchmarkName(void)
  {
    return("nbench-stringsort");
  }
  
! std::string CBMBenchmarkNBENCH_STRINGSORT::nbyteBenchmarkLabel(void)
  {
    return("STRING SORT");
  }
  
! std::string CBMBenchmarkNBENCH_STRINGSORT::benchmarkNBENCHComments(void)
  {
    return("Tests memory-move performance. " \
--- 256,284 ----
  }
  
! BenchmarkNBENCH_NUMSORT::~BenchmarkNBENCH_NUMSORT()
  {
  }
  
! BenchmarkNBENCH_STRINGSORT::BenchmarkNBENCH_STRINGSORT(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_STRINGSORT::nbyteBenchmark(void)
  {
    return("DOSTRINGSORT");
  }
  
! std::string BenchmarkNBENCH_STRINGSORT::benchmarkName(void)
  {
    return("nbench-stringsort");
  }
  
! std::string BenchmarkNBENCH_STRINGSORT::nbyteBenchmarkLabel(void)
  {
    return("STRING SORT");
  }
  
! std::string BenchmarkNBENCH_STRINGSORT::benchmarkNBENCHComments(void)
  {
    return("Tests memory-move performance. " \
***************
*** 291,319 ****
  }
  
! CBMBenchmarkNBENCH_STRINGSORT::~CBMBenchmarkNBENCH_STRINGSORT()
  {
  }
  
! CBMBenchmarkNBENCH_BITFIELD::CBMBenchmarkNBENCH_BITFIELD(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_BITFIELD::nbyteBenchmark(void)
  {
    return("DOBITFIELD");
  }
  
! std::string CBMBenchmarkNBENCH_BITFIELD::benchmarkName(void)
  {
    return("nbench-bitfield");
  }
  
! std::string CBMBenchmarkNBENCH_BITFIELD::nbyteBenchmarkLabel(void)
  {
    return("BITFIELD");
  }
  
! std::string CBMBenchmarkNBENCH_BITFIELD::benchmarkNBENCHComments(void)
  {
    return("Exercises \"bit twiddling\" performance. " \
--- 293,321 ----
  }
  
! BenchmarkNBENCH_STRINGSORT::~BenchmarkNBENCH_STRINGSORT()
  {
  }
  
! BenchmarkNBENCH_BITFIELD::BenchmarkNBENCH_BITFIELD(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_BITFIELD::nbyteBenchmark(void)
  {
    return("DOBITFIELD");
  }
  
! std::string BenchmarkNBENCH_BITFIELD::benchmarkName(void)
  {
    return("nbench-bitfield");
  }
  
! std::string BenchmarkNBENCH_BITFIELD::nbyteBenchmarkLabel(void)
  {
    return("BITFIELD");
  }
  
! std::string BenchmarkNBENCH_BITFIELD::benchmarkNBENCHComments(void)
  {
    return("Exercises \"bit twiddling\" performance. " \
***************
*** 327,355 ****
  }
  
! CBMBenchmarkNBENCH_BITFIELD::~CBMBenchmarkNBENCH_BITFIELD()
  {
  }
  
! CBMBenchmarkNBENCH_EMF::CBMBenchmarkNBENCH_EMF(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_EMF::nbyteBenchmark(void)
  {
    return("DOEMF");
  }
  
! std::string CBMBenchmarkNBENCH_EMF::benchmarkName(void)
  {
    return("nbench-emf");
  }
  
! std::string CBMBenchmarkNBENCH_EMF::nbyteBenchmarkLabel(void)
  {
    return("FP EMULATION");
  }
  
! std::string CBMBenchmarkNBENCH_EMF::benchmarkNBENCHComments(void)
  {
    return("Past experience has shown this test " \
--- 329,357 ----
  }
  
! BenchmarkNBENCH_BITFIELD::~BenchmarkNBENCH_BITFIELD()
  {
  }
  
! BenchmarkNBENCH_EMF::BenchmarkNBENCH_EMF(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_EMF::nbyteBenchmark(void)
  {
    return("DOEMF");
  }
  
! std::string BenchmarkNBENCH_EMF::benchmarkName(void)
  {
    return("nbench-emf");
  }
  
! std::string BenchmarkNBENCH_EMF::nbyteBenchmarkLabel(void)
  {
    return("FP EMULATION");
  }
  
! std::string BenchmarkNBENCH_EMF::benchmarkNBENCHComments(void)
  {
    return("Past experience has shown this test " \
***************
*** 358,386 ****
  }
  
! CBMBenchmarkNBENCH_EMF::~CBMBenchmarkNBENCH_EMF()
  {
  }
  
! CBMBenchmarkNBENCH_FOURIER::CBMBenchmarkNBENCH_FOURIER(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_FOURIER::nbyteBenchmark(void)
  {
    return("DOFOUR");
  }
  
! std::string CBMBenchmarkNBENCH_FOURIER::benchmarkName(void)
  {
    return("nbench-fourier");
  }
  
! std::string CBMBenchmarkNBENCH_FOURIER::nbyteBenchmarkLabel(void)
  {
    return("FOURIER");
  }
  
! std::string CBMBenchmarkNBENCH_FOURIER::benchmarkNBENCHComments(void)
  {
    return("Good measure of transcendental and " \
--- 360,388 ----
  }
  
! BenchmarkNBENCH_EMF::~BenchmarkNBENCH_EMF()
  {
  }
  
! BenchmarkNBENCH_FOURIER::BenchmarkNBENCH_FOURIER(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_FOURIER::nbyteBenchmark(void)
  {
    return("DOFOUR");
  }
  
! std::string BenchmarkNBENCH_FOURIER::benchmarkName(void)
  {
    return("nbench-fourier");
  }
  
! std::string BenchmarkNBENCH_FOURIER::nbyteBenchmarkLabel(void)
  {
    return("FOURIER");
  }
  
! std::string BenchmarkNBENCH_FOURIER::benchmarkNBENCHComments(void)
  {
    return("Good measure of transcendental and " \
***************
*** 391,420 ****
  }
  
! CBMBenchmarkNBENCH_FOURIER::~CBMBenchmarkNBENCH_FOURIER()
  {
  }
  
  
! CBMBenchmarkNBENCH_ASSIGN::CBMBenchmarkNBENCH_ASSIGN(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_ASSIGN::nbyteBenchmark(void)
  {
    return("DOASSIGN");
  }
  
! std::string CBMBenchmarkNBENCH_ASSIGN::benchmarkName(void)
  {
    return("nbench-assign");
  }
  
! std::string CBMBenchmarkNBENCH_ASSIGN::nbyteBenchmarkLabel(void)
  {
    return("ASSIGNMENT");
  }
  
! std::string CBMBenchmarkNBENCH_ASSIGN::benchmarkNBENCHComments(void)
  {
    return("The test moves through large integer " \
--- 393,422 ----
  }
  
! BenchmarkNBENCH_FOURIER::~BenchmarkNBENCH_FOURIER()
  {
  }
  
  
! BenchmarkNBENCH_ASSIGN::BenchmarkNBENCH_ASSIGN(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_ASSIGN::nbyteBenchmark(void)
  {
    return("DOASSIGN");
  }
  
! std::string BenchmarkNBENCH_ASSIGN::benchmarkName(void)
  {
    return("nbench-assign");
  }
  
! std::string BenchmarkNBENCH_ASSIGN::nbyteBenchmarkLabel(void)
  {
    return("ASSIGNMENT");
  }
  
! std::string BenchmarkNBENCH_ASSIGN::benchmarkNBENCHComments(void)
  {
    return("The test moves through large integer " \
***************
*** 430,458 ****
  }
  
! CBMBenchmarkNBENCH_ASSIGN::~CBMBenchmarkNBENCH_ASSIGN()
  {
  }
  
! CBMBenchmarkNBENCH_HUFFMAN::CBMBenchmarkNBENCH_HUFFMAN(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_HUFFMAN::nbyteBenchmark(void)
  {
    return("DOHUFF");
  }
  
! std::string CBMBenchmarkNBENCH_HUFFMAN::benchmarkName(void)
  {
    return("nbench-huffman");
  }
  
! std::string CBMBenchmarkNBENCH_HUFFMAN::nbyteBenchmarkLabel(void)
  {
    return("HUFFMAN");
  }
  
! std::string CBMBenchmarkNBENCH_HUFFMAN::benchmarkNBENCHComments(void)
  {
    return("A combination of byte operations, " \
--- 432,460 ----
  }
  
! BenchmarkNBENCH_ASSIGN::~BenchmarkNBENCH_ASSIGN()
  {
  }
  
! BenchmarkNBENCH_HUFFMAN::BenchmarkNBENCH_HUFFMAN(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_HUFFMAN::nbyteBenchmark(void)
  {
    return("DOHUFF");
  }
  
! std::string BenchmarkNBENCH_HUFFMAN::benchmarkName(void)
  {
    return("nbench-huffman");
  }
  
! std::string BenchmarkNBENCH_HUFFMAN::nbyteBenchmarkLabel(void)
  {
    return("HUFFMAN");
  }
  
! std::string BenchmarkNBENCH_HUFFMAN::benchmarkNBENCHComments(void)
  {
    return("A combination of byte operations, " \
***************
*** 462,490 ****
  }
  
! CBMBenchmarkNBENCH_HUFFMAN::~CBMBenchmarkNBENCH_HUFFMAN()
  {
  }
  
! CBMBenchmarkNBENCH_IDEA::CBMBenchmarkNBENCH_IDEA(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_IDEA::nbyteBenchmark(void)
  {
    return("DOIDEA");
  }
  
! std::string CBMBenchmarkNBENCH_IDEA::benchmarkName(void)
  {
    return("nbench-idea");
  }
  
! std::string CBMBenchmarkNBENCH_IDEA::nbyteBenchmarkLabel(void)
  {
    return("IDEA");
  }
  
! std::string CBMBenchmarkNBENCH_IDEA::benchmarkNBENCHComments(void)
  {
    return("Moves through data sequentally in " \
--- 464,492 ----
  }
  
! BenchmarkNBENCH_HUFFMAN::~BenchmarkNBENCH_HUFFMAN()
  {
  }
  
! BenchmarkNBENCH_IDEA::BenchmarkNBENCH_IDEA(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_IDEA::nbyteBenchmark(void)
  {
    return("DOIDEA");
  }
  
! std::string BenchmarkNBENCH_IDEA::benchmarkName(void)
  {
    return("nbench-idea");
  }
  
! std::string BenchmarkNBENCH_IDEA::nbyteBenchmarkLabel(void)
  {
    return("IDEA");
  }
  
! std::string BenchmarkNBENCH_IDEA::benchmarkNBENCHComments(void)
  {
    return("Moves through data sequentally in " \
***************
*** 493,521 ****
  }
  
! CBMBenchmarkNBENCH_IDEA::~CBMBenchmarkNBENCH_IDEA()
  {
  }
  
! CBMBenchmarkNBENCH_NNET::CBMBenchmarkNBENCH_NNET(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_NNET::nbyteBenchmark(void)
  {
    return("DONNET");
  }
  
! std::string CBMBenchmarkNBENCH_NNET::benchmarkName(void)
  {
    return("nbench-nnet");
  }
  
! std::string CBMBenchmarkNBENCH_NNET::nbyteBenchmarkLabel(void)
  {
    return("NEURAL NET");
  }
  
! std::string CBMBenchmarkNBENCH_NNET::benchmarkNBENCHComments(void)
  {
    return("Small-array floating-point test " \
--- 495,523 ----
  }
  
! BenchmarkNBENCH_IDEA::~BenchmarkNBENCH_IDEA()
  {
  }
  
! BenchmarkNBENCH_NNET::BenchmarkNBENCH_NNET(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_NNET::nbyteBenchmark(void)
  {
    return("DONNET");
  }
  
! std::string BenchmarkNBENCH_NNET::benchmarkName(void)
  {
    return("nbench-nnet");
  }
  
! std::string BenchmarkNBENCH_NNET::nbyteBenchmarkLabel(void)
  {
    return("NEURAL NET");
  }
  
! std::string BenchmarkNBENCH_NNET::benchmarkNBENCHComments(void)
  {
    return("Small-array floating-point test " \
***************
*** 527,555 ****
  }
  
! CBMBenchmarkNBENCH_NNET::~CBMBenchmarkNBENCH_NNET()
  {
  }
  
! CBMBenchmarkNBENCH_LU::CBMBenchmarkNBENCH_LU(CBMPackage *_package)
!   : CBMBenchmarkNBENCH(_package)
  {
  }
  
! std::string CBMBenchmarkNBENCH_LU::nbyteBenchmark(void)
  {
    return("DOLU");
  }
  
! std::string CBMBenchmarkNBENCH_LU::benchmarkName(void)
  {
    return("nbench-lu");
  }
  
! std::string CBMBenchmarkNBENCH_LU::nbyteBenchmarkLabel(void)
  {
    return("LU DECOMPOSITION");
  }
  
! std::string CBMBenchmarkNBENCH_LU::benchmarkNBENCHComments(void)
  {
    return("A floating-point test that moves " \
--- 529,557 ----
  }
  
! BenchmarkNBENCH_NNET::~BenchmarkNBENCH_NNET()
  {
  }
  
! BenchmarkNBENCH_LU::BenchmarkNBENCH_LU(CBM::Package *_package)
!   : BenchmarkNBENCH(_package)
  {
  }
  
! std::string BenchmarkNBENCH_LU::nbyteBenchmark(void)
  {
    return("DOLU");
  }
  
! std::string BenchmarkNBENCH_LU::benchmarkName(void)
  {
    return("nbench-lu");
  }
  
! std::string BenchmarkNBENCH_LU::nbyteBenchmarkLabel(void)
  {
    return("LU DECOMPOSITION");
  }
  
! std::string BenchmarkNBENCH_LU::benchmarkNBENCHComments(void)
  {
    return("A floating-point test that moves " \
***************
*** 560,564 ****
  }
  
! CBMBenchmarkNBENCH_LU::~CBMBenchmarkNBENCH_LU()
  {
  }
--- 562,566 ----
  }
  
! BenchmarkNBENCH_LU::~BenchmarkNBENCH_LU()
  {
  }

Index: Benchmark-GZIP.cpp
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/Benchmark-GZIP.cpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -d -r1.4 -r1.5
*** Benchmark-GZIP.cpp	3 Jan 2007 22:06:26 -0000	1.4
--- Benchmark-GZIP.cpp	18 Jan 2007 18:44:36 -0000	1.5
***************
*** 7,62 ****
  
  #include <SupportedBenchmarks/Benchmark-GZIP.libwrapper.h>
  
! CBMPackageGZIP::CBMPackageGZIP(CBMSystem *_system)
!   : CBMPackagexZIP(_system)
  {
  }
  
! std::string CBMPackageGZIP::downloadURL(void)
  {
    return("ftp://ftp.netscape.com/pub/unsupported/gnu/gzip-1.2.4.tar.Z");
  }
  
! std::string CBMPackageGZIP::expectedMD5(void)
  {
    return("bfc104a6eaf1704be524c879bc9d29bc");
  }
  
! std::string CBMPackageGZIP::packageName(void)
  {
    return("gzip");
  }
  
! std::string CBMPackageGZIP::packageVersion(void)
  {
    return("1.2.4");
  }
  
! int CBMPackageGZIP::packageSize(void)
  {
    return(327865);
  }
  
! std::string CBMPackageGZIP::packageComments(void)
  {
    return("Official gzip-1.2.4 source package.");
  }
  
! std::string CBMPackageGZIP::localPackageName(void)
  {
    return("gzip-1.2.4.tar.Z");
  }
  
! std::string CBMPackageGZIP::language(void)
  {
    return("C");
  }
  
! int CBMPackageGZIP::hasTest(void)
  {
    return(1);
  }
  
! int CBMPackageGZIP::test(void)
  {
    std::string cmd;
--- 7,66 ----
  
  #include <SupportedBenchmarks/Benchmark-GZIP.libwrapper.h>
+ #include <Benchmark/Benchmark-DLLoader.h>
+ #include <UI/UI.h>
  
! using namespace CBM;
! 
! PackageGZIP::PackageGZIP(CBM::System *_system)
!   : PackagexZIP(_system)
  {
  }
  
! std::string PackageGZIP::downloadURL(void)
  {
    return("ftp://ftp.netscape.com/pub/unsupported/gnu/gzip-1.2.4.tar.Z");
  }
  
! std::string PackageGZIP::expectedMD5(void)
  {
    return("bfc104a6eaf1704be524c879bc9d29bc");
  }
  
! std::string PackageGZIP::packageName(void)
  {
    return("gzip");
  }
  
! std::string PackageGZIP::packageVersion(void)
  {
    return("1.2.4");
  }
  
! int PackageGZIP::packageSize(void)
  {
    return(327865);
  }
  
! std::string PackageGZIP::packageComments(void)
  {
    return("Official gzip-1.2.4 source package.");
  }
  
! std::string PackageGZIP::localPackageName(void)
  {
    return("gzip-1.2.4.tar.Z");
  }
  
! std::string PackageGZIP::language(void)
  {
    return("C");
  }
  
! int PackageGZIP::hasTest(void)
  {
    return(1);
  }
  
! int PackageGZIP::test(void)
  {
    std::string cmd;
***************
*** 72,163 ****
  }
  
! char* CBMPackageGZIP::extractDirectory(void)
  {
    return("gzip-1.2.4");
  }
  
! std::string CBMPackageGZIP::license(void)
  {
    return("GPL v2");
  }
  
! std::string CBMPackageGZIP::homePage(void)
  {
    return("http://www.gzip.org");
  }
  
! std::string CBMPackageGZIP::author(void)
  {
    return("Jean-loup Gailly & Mark Adler");
  }
  
! int CBMPackageGZIP::benchmarkSize(void)
  {
    return(76546048);
  }
  
! CBMPackageGZIP::~CBMPackageGZIP()
  {
  }
  
! CBMBenchmarkGZIP::CBMBenchmarkGZIP(CBMPackage *_package)
!   : CBMBenchmarkxZIP(_package)
  {
  }
  
! std::string CBMBenchmarkGZIP::benchmarkProgram(void)
  {
    return("gzip");
  }
  
! CBMBenchmarkGZIP::~CBMBenchmarkGZIP()
  {
  }
  
! CBMBenchmarkGZIP1::CBMBenchmarkGZIP1(CBMPackage *_package)
!   : CBMBenchmarkGZIP(_package)
  {
  }
  
! std::string CBMBenchmarkGZIP1::benchmarkName(void)
  {
    return("gzip-1c");
  }
  
! char* CBMBenchmarkGZIP1::compressionLevel(void)
  {
    return("1");
  }
  
! std::string CBMBenchmarkGZIP1::benchmarkComments(void)
  {
    return("Uses generated gzip binary with fastest compression");
  }
  
! CBMBenchmarkGZIP1::~CBMBenchmarkGZIP1()
  {
  }
  
! CBMBenchmarkGZIP9::CBMBenchmarkGZIP9(CBMPackage *_package)
!   : CBMBenchmarkGZIP(_package)
  {
  }
  
! std::string CBMBenchmarkGZIP9::benchmarkName(void)
  {
    return("gzip-9c");
  }
  
! char* CBMBenchmarkGZIP9::compressionLevel(void)
  {
    return("9");
  }
  
! std::string CBMBenchmarkGZIP9::benchmarkComments(void)
  {
    return("Uses generated gzip binary with maximum compression");
  }
  
! CBMBenchmarkGZIP9::~CBMBenchmarkGZIP9()
  {
  }
--- 76,167 ----
  }
  
! char* PackageGZIP::extractDirectory(void)
  {
    return("gzip-1.2.4");
  }
  
! std::string PackageGZIP::license(void)
  {
    return("GPL v2");
  }
  
! std::string PackageGZIP::homePage(void)
  {
    return("http://www.gzip.org");
  }
  
! std::string PackageGZIP::author(void)
  {
    return("Jean-loup Gailly & Mark Adler");
  }
  
! int PackageGZIP::benchmarkSize(void)
  {
    return(76546048);
  }
  
! PackageGZIP::~PackageGZIP()
  {
  }
  
! BenchmarkGZIP::BenchmarkGZIP(CBM::Package *_package)
!   : BenchmarkxZIP(_package)
  {
  }
  
! std::string BenchmarkGZIP::benchmarkProgram(void)
  {
    return("gzip");
  }
  
! BenchmarkGZIP::~BenchmarkGZIP()
  {
  }
  
! BenchmarkGZIP1::BenchmarkGZIP1(CBM::Package *_package)
!   : BenchmarkGZIP(_package)
  {
  }
  
! std::string BenchmarkGZIP1::benchmarkName(void)
  {
    return("gzip-1c");
  }
  
! char* BenchmarkGZIP1::compressionLevel(void)
  {
    return("1");
  }
  
! std::string BenchmarkGZIP1::benchmarkComments(void)
  {
    return("Uses generated gzip binary with fastest compression");
  }
  
! BenchmarkGZIP1::~BenchmarkGZIP1()
  {
  }
  
! BenchmarkGZIP9::BenchmarkGZIP9(CBM::Package *_package)
!   : BenchmarkGZIP(_package)
  {
  }
  
! std::string BenchmarkGZIP9::benchmarkName(void)
  {
    return("gzip-9c");
  }
  
! char* BenchmarkGZIP9::compressionLevel(void)
  {
    return("9");
  }
  
! std::string BenchmarkGZIP9::benchmarkComments(void)
  {
    return("Uses generated gzip binary with maximum compression");
  }
  
! BenchmarkGZIP9::~BenchmarkGZIP9()
  {
  }

Index: Benchmark-BZIP2.libwrapper.h
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/Benchmark-BZIP2.libwrapper.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** Benchmark-BZIP2.libwrapper.h	15 Jan 2007 20:07:20 -0000	1.3
--- Benchmark-BZIP2.libwrapper.h	18 Jan 2007 18:44:36 -0000	1.4
***************
*** 2,10 ****
  #include <UI/UI.h>
  
! int CBMPackageBZIP2::benchmarkNumber(void) {
    return(2);
  }
  
! BenchmarkVector& CBMPackageBZIP2::Benchmarks(void) {
    if (benchmarks.size()) return(benchmarks);
    benchmarks.push_back("bzip2-1c");
--- 2,12 ----
  #include <UI/UI.h>
  
! using namespace CBM;
! 
! int PackageBZIP2::benchmarkNumber(void) {
    return(2);
  }
  
! CBM::BenchmarkVector& PackageBZIP2::Benchmarks(void) {
    if (benchmarks.size()) return(benchmarks);
    benchmarks.push_back("bzip2-1c");
***************
*** 13,32 ****
  }
  
! CBMBenchmark *CBMPackageBZIP2::Benchmark(std::string bid) {
    if (bid == "bzip2-1c") {
!      return(new CBMBenchmarkBZIP21(this));
    }
    if (bid == "bzip2-9c") {
!      return(new CBMBenchmarkBZIP29(this));
    }
!   UI->Fatal("Unknown benchmark");
    return(0);
  }
  
! CBMPackage *package_BZIP2 = 0;
! CBMPackage *cbmlib_getPackage(void) {
    if (!package_BZIP2) {
!      package_BZIP2=new CBMPackageBZIP2(cbmSystem);
!      cbmlib_packages.push_back(package_BZIP2);
    }
    return(package_BZIP2);
--- 15,34 ----
  }
  
! CBM::Benchmark *PackageBZIP2::Benchmark(std::string bid) {
    if (bid == "bzip2-1c") {
!      return(new CBM::BenchmarkBZIP21(this));
    }
    if (bid == "bzip2-9c") {
!      return(new CBM::BenchmarkBZIP29(this));
    }
!   CBM::cbmUI->Fatal("Unknown benchmark");
    return(0);
  }
  
! CBM::Package *package_BZIP2 = 0;
! CBM::Package *cbmlib_getPackage(void) {
    if (!package_BZIP2) {
!      package_BZIP2=new PackageBZIP2(CBM::cbmSystem);
!      CBM::cbmlib_packages.push_back(package_BZIP2);
    }
    return(package_BZIP2);

Index: Benchmark-BZIP2.cpp
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/Benchmark-BZIP2.cpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -d -r1.4 -r1.5
*** Benchmark-BZIP2.cpp	3 Jan 2007 22:06:26 -0000	1.4
--- Benchmark-BZIP2.cpp	18 Jan 2007 18:44:36 -0000	1.5
***************
*** 6,64 ****
  #include <fstream>
  
- 
  #include <SupportedBenchmarks/Benchmark-BZIP2.libwrapper.h>
  
! CBMPackageBZIP2::CBMPackageBZIP2(CBMSystem *_system)
!   : CBMPackagexZIP(_system)
  {
  }
  
! std::string CBMPackageBZIP2::downloadURL(void)
  {
    return("http://www.bzip.org/1.0.3/bzip2-1.0.3.tar.gz");
  }
  
! std::string CBMPackageBZIP2::expectedMD5(void)
  {
    return("8a716bebecb6e647d2e8a29ea5d8447f");
  }
  
! std::string CBMPackageBZIP2::packageName(void)
  {
    return("bzip2");
  }
  
! std::string CBMPackageBZIP2::packageVersion(void)
  {
    return("1.0.3");
  }
  
! int CBMPackageBZIP2::packageSize(void)
  {
    return(669075);
  }
  
! std::string CBMPackageBZIP2::packageComments(void)
  {
    return("Official bzip2-1.0.3 source package.");
  }
  
! std::string CBMPackageBZIP2::localPackageName(void)
  {
    return("bzip2-1.0.3.tar.Z");
  }
  
! std::string CBMPackageBZIP2::language(void)
  {
    return("C");
  }
  
! int CBMPackageBZIP2::configure(CBMCompiler        *_currentCompiler,
! 				 CBMCompilerOptions *_currentOptions)
  {
    return(1);
  }
  
! int CBMPackageBZIP2::make(void)
  {
    std::string cmd;
--- 6,65 ----
  #include <fstream>
  
  #include <SupportedBenchmarks/Benchmark-BZIP2.libwrapper.h>
  
! using namespace CBM;
! 
! PackageBZIP2::PackageBZIP2(CBM::System *_system)
!   : PackagexZIP(_system)
  {
  }
  
! std::string PackageBZIP2::downloadURL(void)
  {
    return("http://www.bzip.org/1.0.3/bzip2-1.0.3.tar.gz");
  }
  
! std::string PackageBZIP2::expectedMD5(void)
  {
    return("8a716bebecb6e647d2e8a29ea5d8447f");
  }
  
! std::string PackageBZIP2::packageName(void)
  {
    return("bzip2");
  }
  
! std::string PackageBZIP2::packageVersion(void)
  {
    return("1.0.3");
  }
  
! int PackageBZIP2::packageSize(void)
  {
    return(669075);
  }
  
! std::string PackageBZIP2::packageComments(void)
  {
    return("Official bzip2-1.0.3 source package.");
  }
  
! std::string PackageBZIP2::localPackageName(void)
  {
    return("bzip2-1.0.3.tar.Z");
  }
  
! std::string PackageBZIP2::language(void)
  {
    return("C");
  }
  
! int PackageBZIP2::configure(Compiler        *_currentCompiler,
! 			    CompilerOptions *_currentOptions)
  {
    return(1);
  }
  
! int PackageBZIP2::make(void)
  {
    std::string cmd;
***************
*** 98,107 ****
  }
  
! int CBMPackageBZIP2::hasTest(void)
  {
    return(1);
  }
  
! int CBMPackageBZIP2::test(void)
  {
    std::string cmd;
--- 99,108 ----
  }
  
! int PackageBZIP2::hasTest(void)
  {
    return(1);
  }
  
! int PackageBZIP2::test(void)
  {
    std::string cmd;
***************
*** 117,208 ****
  }
  
! char* CBMPackageBZIP2::extractDirectory(void)
  {
    return("bzip2-1.0.3");
  }
  
! std::string CBMPackageBZIP2::license(void)
  {
    return("BSD-style");
  }
  
! std::string CBMPackageBZIP2::homePage(void)
  {
    return("http://www.bzip.org");
  }
  
! std::string CBMPackageBZIP2::author(void)
  {
    return("Julian Seward");
  }
  
! int CBMPackageBZIP2::benchmarkSize(void)
  {
    return(76546048);
  }
  
! CBMPackageBZIP2::~CBMPackageBZIP2()
  {
  }
  
! CBMBenchmarkBZIP2::CBMBenchmarkBZIP2(CBMPackage *_package)
!   : CBMBenchmarkxZIP(_package)
  {
  }
  
! std::string CBMBenchmarkBZIP2::benchmarkProgram(void)
  {
    return("bzip2");
  }
  
! CBMBenchmarkBZIP2::~CBMBenchmarkBZIP2()
  {
  }
    
! CBMBenchmarkBZIP21::CBMBenchmarkBZIP21(CBMPackage *_package)
!   : CBMBenchmarkBZIP2(_package)
  {
  }
  
! std::string CBMBenchmarkBZIP21::benchmarkName(void)
  {
    return("bzip2-1c");
  }
  
! char* CBMBenchmarkBZIP21::compressionLevel(void)
  {
    return("1");
  }
  
! std::string CBMBenchmarkBZIP21::benchmarkComments(void)
  {
    return("Uses generated bzip2 binary with fastest compression");
  }
  
! CBMBenchmarkBZIP21::~CBMBenchmarkBZIP21()
  {
  }
  
! CBMBenchmarkBZIP29::CBMBenchmarkBZIP29(CBMPackage *_package)
!   : CBMBenchmarkBZIP2(_package)
  {
  }
  
! std::string CBMBenchmarkBZIP29::benchmarkName(void)
  {
    return("bzip2-9c");
  }
  
! char* CBMBenchmarkBZIP29::compressionLevel(void)
  {
    return("9");
  }
  
! std::string CBMBenchmarkBZIP29::benchmarkComments(void)
  {
    return("Uses generated bzip2 binary with maximum compression");
  }
  
! CBMBenchmarkBZIP29::~CBMBenchmarkBZIP29()
  {
  }
--- 118,209 ----
  }
  
! char* PackageBZIP2::extractDirectory(void)
  {
    return("bzip2-1.0.3");
  }
  
! std::string PackageBZIP2::license(void)
  {
    return("BSD-style");
  }
  
! std::string PackageBZIP2::homePage(void)
  {
    return("http://www.bzip.org");
  }
  
! std::string PackageBZIP2::author(void)
  {
    return("Julian Seward");
  }
  
! int PackageBZIP2::benchmarkSize(void)
  {
    return(76546048);
  }
  
! PackageBZIP2::~PackageBZIP2()
  {
  }
  
! BenchmarkBZIP2::BenchmarkBZIP2(CBM::Package *_package)
!   : BenchmarkxZIP(_package)
  {
  }
  
! std::string BenchmarkBZIP2::benchmarkProgram(void)
  {
    return("bzip2");
  }
  
! BenchmarkBZIP2::~BenchmarkBZIP2()
  {
  }
    
! BenchmarkBZIP21::BenchmarkBZIP21(CBM::Package *_package)
!   : BenchmarkBZIP2(_package)
  {
  }
  
! std::string BenchmarkBZIP21::benchmarkName(void)
  {
    return("bzip2-1c");
  }
  
! char* BenchmarkBZIP21::compressionLevel(void)
  {
    return("1");
  }
  
! std::string BenchmarkBZIP21::benchmarkComments(void)
  {
    return("Uses generated bzip2 binary with fastest compression");
  }
  
! BenchmarkBZIP21::~BenchmarkBZIP21()
  {
  }
  
! BenchmarkBZIP29::BenchmarkBZIP29(CBM::Package *_package)
!   : BenchmarkBZIP2(_package)
  {
  }
  
! std::string BenchmarkBZIP29::benchmarkName(void)
  {
    return("bzip2-9c");
  }
  
! char* BenchmarkBZIP29::compressionLevel(void)
  {
    return("9");
  }
  
! std::string BenchmarkBZIP29::benchmarkComments(void)
  {
    return("Uses generated bzip2 binary with maximum compression");
  }
  
! BenchmarkBZIP29::~BenchmarkBZIP29()
  {
  }

Index: Benchmark-GZIP.h
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/Benchmark-GZIP.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** Benchmark-GZIP.h	3 Jan 2007 22:06:27 -0000	1.3
--- Benchmark-GZIP.h	18 Jan 2007 18:44:36 -0000	1.4
***************
*** 12,88 ****
  #include <Benchmark/Benchmark-xZIP.h>
  
! /** \brief Defines the gzip package.
!  */
! class CBMPackageGZIP : public CBMPackagexZIP
! {
!  private:
  
  
!   virtual std::string downloadURL(void);
!   virtual std::string expectedMD5(void);
  
!   virtual std::string packageName(void);
!   virtual std::string packageVersion(void);
!   virtual int         packageSize(void); /* in bytes */
!   virtual std::string packageComments(void);
!   virtual std::string localPackageName(void);
  		
!   virtual char* extractDirectory(void);
!   virtual std::string language(void);
  
!  protected:
!   virtual int hasTest(void);
!   virtual int test(void);
  
!  public:
!   CBMPackageGZIP(class CBMSystem *_system);
!   DLPackageWrapper_declare();
  
!   virtual std::string license(void);
!   virtual std::string homePage(void);
!   virtual std::string author(void);
  
!   virtual int benchmarkSize(void);
!   virtual ~CBMPackageGZIP();
  		
! };
  
! /** \brief Abstract class for gzip benchmarks */
! class CBMBenchmarkGZIP : public CBMBenchmarkxZIP
! {
!  protected:
!   CBMBenchmarkGZIP(CBMPackage *_package);
!   virtual std::string benchmarkProgram(void);
!   virtual ~CBMBenchmarkGZIP();
! };
  
! /** \brief Defines the gzip benchmark using fastest compression level.
!  */
! class CBMBenchmarkGZIP1 : public CBMBenchmarkGZIP
! {
!  protected:
!   virtual char*       compressionLevel(void);
!   virtual std::string benchmarkComments(void);
  
!  public:
!   CBMBenchmarkGZIP1(CBMPackage *_package);
!   virtual std::string benchmarkName(void);
!   virtual ~CBMBenchmarkGZIP1();
! };
  
! /** \brief Defines the gzip benchmark using maximum compression level.
!  */
! class CBMBenchmarkGZIP9 : public CBMBenchmarkGZIP
! {
!  protected:
!   virtual char*       compressionLevel(void);
!   virtual std::string benchmarkComments(void);
!  public:
  
!   CBMBenchmarkGZIP9(CBMPackage *_package);
  
!   virtual std::string benchmarkName(void);
!   virtual ~CBMBenchmarkGZIP9();
! };
  
  DLdeclare();
--- 12,90 ----
  #include <Benchmark/Benchmark-xZIP.h>
  
! namespace CBM {
!   /** \brief Defines the gzip package.
!    */
!   class PackageGZIP : public PackagexZIP
!   {
!   private:
  
  
!     virtual std::string downloadURL(void);
!     virtual std::string expectedMD5(void);
  
!     virtual std::string packageName(void);
!     virtual std::string packageVersion(void);
!     virtual int         packageSize(void); /* in bytes */
!     virtual std::string packageComments(void);
!     virtual std::string localPackageName(void);
  		
!     virtual char* extractDirectory(void);
!     virtual std::string language(void);
  
!   protected:
!     virtual int hasTest(void);
!     virtual int test(void);
  
!   public:
!     PackageGZIP(class System *_system);
!     DLPackageWrapper_declare();
  
!     virtual std::string license(void);
!     virtual std::string homePage(void);
!     virtual std::string author(void);
  
!     virtual int benchmarkSize(void);
!     virtual ~PackageGZIP();
  		
!   };
  
!   /** \brief Abstract class for gzip benchmarks */
!   class BenchmarkGZIP : public BenchmarkxZIP
!   {
!   protected:
!     BenchmarkGZIP(CBM::Package *_package);
!     virtual std::string benchmarkProgram(void);
!     virtual ~BenchmarkGZIP();
!   };
  
!   /** \brief Defines the gzip benchmark using fastest compression level.
!    */
!   class BenchmarkGZIP1 : public BenchmarkGZIP
!   {
!   protected:
!     virtual char*       compressionLevel(void);
!     virtual std::string benchmarkComments(void);
  
!   public:
!     BenchmarkGZIP1(CBM::Package *_package);
!     virtual std::string benchmarkName(void);
!     virtual ~BenchmarkGZIP1();
!   };
  
!   /** \brief Defines the gzip benchmark using maximum compression level.
!    */
!   class BenchmarkGZIP9 : public BenchmarkGZIP
!   {
!   protected:
!     virtual char*       compressionLevel(void);
!     virtual std::string benchmarkComments(void);
!   public:
  
!     BenchmarkGZIP9(CBM::Package *_package);
  
!     virtual std::string benchmarkName(void);
!     virtual ~BenchmarkGZIP9();
!   };
! }
  
  DLdeclare();

Index: Benchmark-SCIMARK2.libwrapper.h
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks/Benchmark-SCIMARK2.libwrapper.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** Benchmark-SCIMARK2.libwrapper.h	15 Jan 2007 20:07:21 -0000	1.3
--- Benchmark-SCIMARK2.libwrapper.h	18 Jan 2007 18:44:36 -0000	1.4
***************
*** 2,10 ****
  #include <UI/UI.h>
  
! int CBMPackageSCIMARK2::benchmarkNumber(void) {
    return(5);
  }
  
! BenchmarkVector& CBMPackageSCIMARK2::Benchmarks(void) {
    if (benchmarks.size()) return(benchmarks);
    benchmarks.push_back("scimark2-smm");
--- 2,12 ----
  #include <UI/UI.h>
  
! using namespace CBM;
! 
! int PackageSCIMARK2::benchmarkNumber(void) {
    return(5);
  }
  
! CBM::BenchmarkVector& PackageSCIMARK2::Benchmarks(void) {
    if (benchmarks.size()) return(benchmarks);
    benchmarks.push_back("scimark2-smm");
***************
*** 16,44 ****
  }
  
! CBMBenchmark *CBMPackageSCIMARK2::Benchmark(std::string bid) {
    if (bid == "scimark2-smm") {
!      return(new CBMBenchmarkSCIMARK2_SMM(this));
    }
    if (bid == "scimark2-lu") {
!      return(new CBMBenchmarkSCIMARK2_LU(this));
    }
    if (bid == "scimark2-fourier") {
!      return(new CBMBenchmarkSCIMARK2_FOURIER(this));
    }
    if (bid == "scimark2-mc") {
!      return(new CBMBenchmarkSCIMARK2_MC(this));
    }
    if (bid == "scimark2-sor") {
!...
 
[truncated message content]