cstpp.cpp File Reference

---

Detailed Description

This file creates the executable cstpp.

Definition in file cstpp.cpp.

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

Include dependency graph for cstpp.cpp:

Go to the source code of this file.

Functions
void	usage ()
int	main (int argc, const char *argv[])

---

Function Documentation

int main	(	int	argc,
		const char *	argv[]
	)

main This is the main function for cstpp.

Definition at line 34 of file cstpp.cpp.

References class_def::comment::_data, class_def::class_definition::_univ, class_def::find_tag(), class_def::get_tag(), class_def::print_stringify(), class_def::attribute::put_allow_custom_classes(), class_def::attribute::put_check_attributes(), class_def::attribute::put_copy_constructor(), class_def::class_definition::set_back_white(), class_def::class_definition::set_domain_error(), class_def::class_definition::set_error_function(), class_def::class_definition::set_output_format(), and usage().

                                        {
  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;
}

Here is the call graph for this function:

---