cstsql.cpp

Go to the documentation of this file.

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

using namespace std;

void usage() {
  cerr << "cstsql [-def=definitionfile1 -def=definitionfile2 ... -def=definitionfileN] [-i=inputfile] -c=outputclass [-o=outputfile] [-a=appendfile] [-lower_case_mysql_names=false]" << endl;
  cerr << "      [-f=outputformat] [-help|-?|?]" << 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 << "outputformat <- [init_static_attributes | " << endl;
  cerr << "                 exists                 | " << endl;
  cerr << "                 singleton_select       | " << endl;
  cerr << "                 insert                 | " << endl;
  cerr << "                 update                 | " << endl;
  cerr << "                 read_binary            | " << endl;
  cerr << "                 write_binary           | " << endl;
  cerr << "                 map_by_offset          | " << endl;
  cerr << "                 send_binary            | " << endl;
  cerr << "                 recv_binary            | " << endl;
}

const char *get_inputfile( int argc, const char *argv[], int *argmask) {
  int i;
  for (i=0;i<argc;i++) {
    if (memcmp( argv[i], "-i=", 3)==0) {
       argmask[i] = 1;
       return argv[i]+3;
    }
  }
  return NULL;
}

const char *get_deffile( int argc, const char *argv[], int *argmask) {
  int i;
  for (i=0;i<argc;i++) {
    if (argmask[i]==0 && memcmp( argv[i], "-def=", 3)==0) {
       argmask[i] = 1;
       return argv[i]+5;
    }
  }
  return NULL;
}

const char *get_help( int argc, const char *argv[], int *argmask) {
  int i;
  for (i=0;i<argc;i++) {
    if (memcmp( argv[i], "-h", 2)==0 || memcmp( argv[i], "-?", 2)==0 || argv[i][0]=='?') {
       argmask[i] = 1;
       return argv[i]+3;
    }
  }
  return NULL;
}

const char *get_outputfile( int argc, const char *argv[], int *argmask) {
  int i;
  for (i=0;i<argc;i++) {
    if (memcmp( argv[i], "-o=", 3)==0) {
       argmask[i] = 1;
       return argv[i]+3;
    }
  }
  return NULL;
}

const char *get_appendfile( int argc, const char *argv[], int *argmask) {
  int i;
  for (i=0;i<argc;i++) {
    if (memcmp( argv[i], "-a=", 3)==0) {
       argmask[i] = 1;
       return argv[i]+3;
    }
  }
  return NULL;
}

const char *get_outputformat( int argc, const char *argv[], int *argmask) {
  int i;
  for (i=0;i<argc;i++) {
    if (memcmp( argv[i], "-f=", 3)==0) {
       argmask[i] = 1;
       return argv[i]+3;
    }
  }
  return NULL;
}

const char *get_lower_case_mysql_names( int argc, const char *argv[], int *argmask) {
  int i;
  const char *tag = "-lower_case_mysql_names=";
  int ln = strlen( tag);
  for (i=0;i<argc;i++) {
    if (memcmp( argv[i], tag, ln)==0) {
       argmask[i] = 1;
       return argv[i]+ln;
    }
  }
  return "false";
}

const char *get_outputclass( int argc, const char *argv[], int *argmask) {
  int i;
  for (i=0;i<argc;i++) {
    if (memcmp( argv[i], "-c=", 3)==0) {
       argmask[i] = 1;
       return argv[i]+3;
    }
  }
  return NULL;
}

int main( int argc, const char *argv[]) {
  class_def::class_definition *_class_definition;
  const char *infile, *outputclass, *outfile, *appfile, *outputformat, *deffile, *lower_case_mysql_names;
  istream *in, *def;
  ostream *out;
  ifstream fin;
  ofstream fout;
  int argmask[10], i, k, errflag, class_found;
  vector<string> deffiles;

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

  if (argc>10 || get_help( argc, argv, argmask)!=NULL) {
    usage();
    return 1;
  }

  infile       = get_inputfile(    argc, argv, argmask);

  deffile = get_deffile( argc, argv, argmask);
  while (deffile!=NULL) {
    deffiles.push_back( deffile);
    deffile = get_deffile( argc, argv, argmask);
  }

  outputformat           = get_outputformat( argc, argv, argmask);
  lower_case_mysql_names = get_lower_case_mysql_names( argc, argv, argmask);
  outputclass            = get_outputclass(  argc, argv, argmask);
  outfile                = get_outputfile(   argc, argv, argmask);
  appfile                = get_appendfile(   argc, argv, argmask);

  if (outfile!=NULL && appfile!=NULL) {
    cerr << "outputfile and appendfile are mutually exclusive" << endl;
    class_def::error();
  }

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

  class_def::attribute::put_allow_custom_classes( 1);

  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 (appfile!=NULL) {
    fout.open( appfile, ios::app | ios::binary);
    if (!fout.is_open()) {
      cerr << "can't open " << outfile << endl;
      return 4;
    }
    out = &fout;
  }

  if (outputformat==NULL) {
    cerr << "output format must be specified" << endl;
    return 5;
  }

  if (outputclass==NULL) {
    cerr << "output class must be specified" << endl;
    return 5;
  }

  class_def::class_definition::set_output_format( outputformat);

  if (lower_case_mysql_names != NULL && strcmp( lower_case_mysql_names, "true")==0) {
    class_def::class_definition::set_lower_case_mysql_names( true);
  }

  class_found = 0;
  while (*in && class_found==0) {
    try {
      _class_definition = new class_def::class_definition();
      *in >> *_class_definition;
      class_def::class_definition::_univ.push_back( _class_definition);
      //i++;
    } catch (std::exception& xpt) {
      cerr << xpt.what();
      return 5;
    } catch (class_def::comment cm) {
      continue;
    } catch (class_def::end_of_input) {
      break;
    } catch (...) {
      cerr << "unknown exception was thrown" << endl;
      break;
    }

    if (strcmp( _class_definition->_name.c_str(), outputclass)==0) {
      try {
        *out << *_class_definition;
        class_found = 1;
      } catch (std::exception& xpt) {
        cerr << xpt.what();
        return 5;
      } catch (...) {
        cerr << "unknown exception was thrown" << endl;
        break;
      }
    }
  }

  if (class_found==0) {
    cerr << "class = " << outputclass << " was not found" << endl;
    class_def::error();
  }

  return 0;
}

---