ExtractValueBytes.C

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

// Last modified on Sun Feb 16 10:06:07 EST 2003 by ken@xorian.net  
//      modified on Sat Feb 12 13:11:57 PST 2000 by mann  
//      modified on Sun Aug 23 11:38:57 PDT 1998 by heydon

// ExtractValueBytes -- print the contents of a MultiPKFile

#include <Basics.H>
#include <FS.H>
#include <CacheArgs.H>
#include <CacheConfig.H>
#include <SMultiPKFileRep.H>

static bool OpenFile(const Text fname, /*OUT*/ ifstream &ifs)
  throw (FS::Failure)
/* Open the file named "fname" for reading. If successful, set "ifs" to a
   stream on the file and return true. If the file does not exist, print an
   error message and return false. If any other error occurs, throw
   "FS::Failure".
*/
{
    try {
        FS::OpenReadOnly(fname, ifs);
    }
    catch (FS::DoesNotExist) {
        cerr << "Error: unable to open '" << fname << "' for reading." << endl;
        return false;
    }
    return true;
}

static void WriteValueFile(CacheEntry::Index ci, const VestaVal::T *value)
{
  assert(value != 0);
  assert(value->bytes != 0);

  char vale_fname[100];
  sprintf(vale_fname, "value.ci%d", ci);

  ofstream value_file;
  FS::OpenForWriting(vale_fname, value_file);

  FS::Write(value_file, value->bytes, value->len);

  FS::Close(value_file);
}

static void ExtarctFromFile(const char *nm, const char *func = 0)
  throw (SMultiPKFileRep::BadMPKFile, FS::EndOfFile, FS::Failure)
/* Open and read the MultiPKFile named by the file "nm", and extarct
   the bytes of each cache entry into a file named
   "value.ci<index>". */
{
    // form the filename
    Text fname(nm);
    if (nm[0] != '/') {
        fname = Config_SCachePath + '/' + fname;
    }

    // open the file
    ifstream ifs;
    if (!OpenFile(fname, /*OUT*/ ifs)) return;

    try {
        // read it (including the PKFiles)
        SMultiPKFileRep::Header hdr(ifs);
        hdr.ReadEntries(ifs);
        hdr.ReadPKFiles(ifs);
        FS::Close(ifs);

        // Loop over the PKFiles
        for (int i = 0; i < hdr.num; i++) {
            SMultiPKFileRep::HeaderEntry *he;
            bool inTbl = hdr.pkTbl.Get(*(hdr.pkSeq[i]), he);
            assert(inTbl);

            if (he->pkfile != (SPKFile *)NULL) {

              // If a function limiter was specified, only proceed if
              // this PKFile matches it.
              if((func != 0) &&
                 ((he->pkfile->SourceFunc() == 0) ||
                  (he->pkfile->SourceFunc()->FindText(func) == -1)))
                {
                  continue;
                }

              // Loop over the CFP groups in the PKFile
              SPKFile::CFPEntryIter cfp_it(he->pkfile->OldEntries());
              FP::Tag cfp;
              CE::List *entries;
              while(cfp_it.Next(cfp, entries))
                {
                  // Loop over the entries in the CFP group
                  while(entries != 0)
                    {
                      CE::T *entry = entries->Head();
                      assert(entry != 0);

                      // Write out the bytes for this value into a new
                      // file.
                      WriteValueFile(entry->CI(), entry->Value());

                      entries = entries->Tail();
                    }
                }
            }
        }
    } catch (...) {
        FS::Close(ifs);
        throw;
    }
}

static const char *g_program_name = 0;

static void ExitProgram(char *msg) throw ()
{
    cerr << "Fatal error: " << msg << endl;
    cerr << "Syntax: " << g_program_name << " [-func <function>] file ..." << endl;
    exit(1);
}

int main(int argc, char *argv[])
{
  g_program_name = argv[0];

    // process command-line switch(es). (@@@ Should allow the user to
    // specify the CIs to be extracted.)
    int arg = 1;
    const char *func = 0;

    for (/*SKIP*/; arg < argc && *argv[arg] == '-'; arg++) {
        if (CacheArgs::StartsWith(argv[arg], "-func")) {
          if(func != 0)
            {
              ExitProgram("only one -func allowed");
            }
          func = argv[++arg];
        } else {
            ExitProgram("unrecognized command-line option");
        }
    }


    // process file arguments
    if (argc - arg < 1) {
        ExitProgram("no file arguments specified");
    }
    bool firstFile = true; // determines whether to print a separating newline
    for (/*SKIP*/; arg < argc; arg++) {
        try {
            if (firstFile) firstFile = false; else cout << endl;
            ExtarctFromFile(argv[arg], func);
        }
        catch (SMultiPKFileRep::BadMPKFile) {
            cerr << "Error: '" << argv[arg]
                 << "' is a bad MultiPKFile" << endl;
        }
        catch (FS::EndOfFile) {
            cerr << "Fatal error: unexpected end-of-file" << endl;
        }
        catch (const FS::Failure &f) {
            cerr << f;
        }
    }
    return 0;
}

---