cstpp.cpp

Go to the documentation of this file.

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <sstream>
#include <stdlib.h>
#include "clssdf.h"

using namespace std;
using namespace class_def;

void usage() {
  cerr << "cstpp [-def=definitionfile1 -def=definitionfile2 ... -def=definitionfileN] [-i=inputfile] [-o=outputfile] [-f=outputformat]" << endl;
  cerr << "[-help|-?|?] [-e] [-b] [-c] [-nocopy] [-no_check_attributes]" << endl;
  cerr << "definitionsfileI is the name if the Ith file of definitions of parent classes. This is " << endl;
  cerr << "used in cases where parent classes occur outside the input file" << endl;
  cerr << "inputfile is the filename of a valid input file" << endl;
  cerr << "outputfile is the name of the file which will be overwritten" << endl;
  cerr << "outputformat <- [simple_output | header_output]" << endl;
  cerr << "-def-definitionfile this file contains the definition of parent classes. There maybe multiple files." << endl;
  cerr << "-e is causes the function error,to be called, rather than throwing a class error" << endl;
  cerr << "-domain_error causes std::domain_error to be thrown, rather than throwing a class error" << endl;
  cerr << "-b causes padded white spaces at the end of strings to be removed" << endl;
  cerr << "-c allows custom classes" << endl;
  cerr << "-nocopy removes copy constructors from all classes" << endl;
  cerr << "-no_check_attributes removes calls to the check_attributes function, and the static members _erno and _err_msg" << endl;
}

int main( int argc, const char *argv[]) {
  class_def::class_definition *_class_definition;
  const char *infile, *outfile, *outputformat, *errorfunction, *backwhite, *domain_error, *deffile, *customclasses, *nocopy,
    *no_check_attributes;
  istream *in, *def;
  ostream *out;
  ifstream fin;
  ofstream fout;
  int argmask[10], i, errflag, j, k;
  vector<string> deffiles;

  argmask[0] = 1;
  for (i=1;i<10;i++) {
    argmask[i] = 0;
  }

  bool ask_help = find_tag( argc, argv, argmask, "-?")!=0 ||
    find_tag( argc, argv, argmask, "?")!=0;
  if (argc>10 || ask_help) {
    usage();
    return 1;
  }

  infile  = get_tag( argc, argv, argmask, "-i=", NULL);

  deffile = get_tag( argc, argv, argmask, "-def=", NULL);
  while (deffile!=0) {
    deffiles.push_back( deffile);
    deffile = get_tag( argc, argv, argmask, "-def=", NULL);
  }

  outfile = get_tag( argc, argv, argmask, "-o=", NULL);

  outputformat = get_tag( argc, argv, argmask, "-f=", NULL);

  errorfunction = find_tag( argc, argv, argmask, "-e");

  domain_error = find_tag( argc, argv, argmask, "-domain_error");

  customclasses = find_tag( argc, argv, argmask, "-c");

  nocopy = find_tag( argc, argv, argmask, "-nocopy");

  no_check_attributes = find_tag( argc, argv, argmask, "-no_check_attributes");

  backwhite = find_tag( argc, argv, argmask, "-b");

  if (errorfunction!=NULL) {
    class_def::class_definition::set_error_function( 1);
  }

  if (domain_error!=NULL) {
    class_def::class_definition::set_domain_error( 1);
  }
  
  if (customclasses!=NULL) {
    class_def::attribute::put_allow_custom_classes( 1);
  }

  if (nocopy != NULL) {
    class_def::attribute::put_copy_constructor( 0);
  }

  if (no_check_attributes != NULL) {
    class_def::attribute::put_check_attributes( 0);
  }

  if (backwhite!=NULL) {
    class_def::class_definition::set_back_white( 1);
  }

  for (errflag=0,i=1;i<argc;i++) {
    if (argmask[i]==0) {
      cerr << "error argument={" << argv[i] << "} was not recognized" << endl;
      errflag = 1;
    }
  }
  if (errflag) {
    return 2;
  }

  // read definition files to get definitions of parent classes
  for (i=k=0;k<deffiles.size();k++) {
    ifstream fdef( deffiles[k].c_str());

    if (!fdef.is_open()) {
      cerr << "can't open " << deffiles[i] << endl;
      return 3;
    }
    def = &fdef;
 
    while (*def) {
      try {
        _class_definition = new class_def::class_definition();
        *def >> *_class_definition;
        class_def::class_definition::_univ.push_back( _class_definition);
        i++;
      } catch (std::exception& xpt ) {
        cerr << xpt.what();
        return 5;
      } catch (class_def::end_of_input) {
        break;
      } catch (class_def::comment cm) {

      } catch (...) {
        cerr << "unknown exception was thrown" << endl;
        break;
      }
    }

    fdef.close();
    def = NULL;
  }
    
  if (infile==NULL) {
    in = &cin;
  } else {
    fin.open( infile);
    if (!fin.is_open()) {
      cerr << "can't open " << infile << endl;
      return 3;
    }
    in = &fin;
  }

  if (outfile==NULL) {
    out = &cout;
  } else {
    fout.open( outfile, ios::binary);
    if (!fout.is_open()) {
      cerr << "can't open " << outfile << endl;
      return 4;
    }
    out = &fout;
  }

  if (outputformat==NULL)
    outputformat = "header_output";

  class_def::class_definition::set_output_format( outputformat);
 
  j = 0;
  while (*in) {
    if (j==0 && domain_error != NULL) {
      j = 1;
      out->flush();
      *out << class_def::print_stringify() << endl;
    }

    try {
      _class_definition = new class_def::class_definition();
      *in >> *_class_definition;
      class_def::class_definition::_univ.push_back( _class_definition);

      *out << *(class_def::class_definition::_univ.back());
      //i++;

    } catch (std::exception& xpt) {
      cerr << xpt.what();
      return 5;
    } catch (class_def::end_of_input) {
      break;
    } catch (class_def::comment cm) {
      *out << cm._data << endl;
    } catch (...) {
      cerr << "unknown exception was thrown" << endl;
      break;
    }
  }

  for (j=0;j<i;j++) {
    _class_definition = class_def::class_definition::_univ[j];
    delete _class_definition;
  }

  return 0;
}

---