PyObject* IcePy_loadSlice(PyObject* /*self*/, PyObject* args) { char* cmd; PyObject* list = 0; if(!PyArg_ParseTuple(args, STRCAST("s|O!"), &cmd, &PyList_Type, &list)) { return 0; } vector<string> argSeq; try { argSeq = IceUtilInternal::Options::split(cmd); } catch(const IceUtilInternal::BadOptException& ex) { PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str()); return 0; } catch(const IceUtilInternal::APIException& ex) { PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str()); return 0; } if(list) { if(!listToStringSeq(list, argSeq)) { return 0; } } IceUtilInternal::Options opts; opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); opts.addOpt("", "checksum"); opts.addOpt("", "all"); vector<string> files; try { argSeq.insert(argSeq.begin(), ""); // dummy argv[0] files = opts.parse(argSeq); if(files.empty()) { PyErr_Format(PyExc_RuntimeError, "no Slice files specified in `%s'", cmd); return 0; } } catch(const IceUtilInternal::BadOptException& ex) { PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str()); return 0; } catch(const IceUtilInternal::APIException& ex) { PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str()); return 0; } vector<string> cppArgs; Ice::StringSeq includePaths; bool debug = false; bool ice = true; // This must be true so that we can create Ice::Identity when necessary. bool underscore = opts.isSet("underscore"); bool all = false; bool checksum = false; if(opts.isSet("D")) { vector<string> optargs = opts.argVec("D"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } } if(opts.isSet("U")) { vector<string> optargs = opts.argVec("U"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } } if(opts.isSet("I")) { includePaths = opts.argVec("I"); for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i) { cppArgs.push_back("-I" + *i); } } debug = opts.isSet("d") || opts.isSet("debug"); all = opts.isSet("all"); checksum = opts.isSet("checksum"); bool ignoreRedefs = false; bool keepComments = true; for(vector<string>::const_iterator p = files.begin(); p != files.end(); ++p) { string file = *p; Slice::PreprocessorPtr icecpp = Slice::Preprocessor::create("icecpp", file, cppArgs); FILE* cppHandle = icecpp->preprocess(keepComments, "-D__SLICE2PY__"); if(cppHandle == 0) { PyErr_Format(PyExc_RuntimeError, "Slice preprocessing failed for `%s'", cmd); return 0; } UnitPtr u = Slice::Unit::createUnit(ignoreRedefs, all, ice, underscore); int parseStatus = u->parse(file, cppHandle, debug); if(!icecpp->close() || parseStatus == EXIT_FAILURE) { PyErr_Format(PyExc_RuntimeError, "Slice parsing failed for `%s'", cmd); u->destroy(); return 0; } // // Generate the Python code into a string stream. // ostringstream codeStream; IceUtilInternal::Output out(codeStream); out.setUseTab(false); // // Emit a Python magic comment to set the file encoding. // It must be the first or second line. // out << "# -*- coding: utf-8 -*-\n"; generate(u, all, checksum, includePaths, out); u->destroy(); string code = codeStream.str(); // // We need to invoke Ice.updateModules() so that all of the types we've just generated // are made "public". // code += "\nIce.updateModules()\n"; PyObjectHandle src = Py_CompileString(const_cast<char*>(code.c_str()), const_cast<char*>(file.c_str()), Py_file_input); if(!src.get()) { return 0; } PyObjectHandle globals = PyDict_New(); if(!globals.get()) { return 0; } PyDict_SetItemString(globals.get(), "__builtins__", PyEval_GetBuiltins()); #if PY_VERSION_HEX >= 0x03000000 PyObjectHandle val = PyEval_EvalCode(src.get(), globals.get(), 0); #else PyObjectHandle val = PyEval_EvalCode(reinterpret_cast<PyCodeObject*>(src.get()), globals.get(), 0); #endif if(!val.get()) { return 0; } } Py_INCREF(Py_None); return Py_None; }
int main(int argc, char* argv[]) { vector<string> cppArgs; //bool preprocess; //string include; //string output; //string dllExport; //bool impl; //bool depend; //bool debug; //bool ice; //bool checksum; //bool stream; //bool caseSensitive; string inputFilename; #ifdef false po::variables_map vm; //try //{ po::options_description hidden("Hidden options"); hidden.add_options() ("input-file", po::value< vector<string> >(), "input file") ; po::options_description allowed("Allowed options"); allowed.add_options() ("help", "produce help message") ("output", po::value<std::string>(), "output file name") ; po::options_description cmdline("Command line options"); cmdline.add(allowed).add(hidden); po::positional_options_description p; p.add("input-file", -1); po::store(po::command_line_parser(argc, argv). options(cmdline).positional(p).run(), vm); po::notify(vm); if (vm.count("help")) { cout << allowed << "\n"; return 1; } if ( vm.count("input-file")) { vector<string> sv = vm["input-file"].as<vector<string> >(); //for (vector<string>::iterator i=sv.begin(); i!=sv.end(); i++) //{ //cout << *i << "\n"; //} inputFilename = sv[0]; } if (vm.count("output")) { cout << "Output filename is " << vm["output"].as<std::string>() << "\n"; } //} //catch(...) //{ //cout << "CRAP!\n"; //} cout << "Input file is \"" << inputFilename << "\"\n"; #endif IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); vector<string> args; try { args = opts.parse(argc, argv); } catch(const IceUtilInternal::BadOptException& e) { cerr << argv[0] << ": " << e.reason << endl; usage(argv[0]); return EXIT_FAILURE; } if(opts.isSet("h") || opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } vector<string> includePaths; includePaths = opts.argVec("I"); for (vector<string>::const_iterator i=includePaths.begin(); i!=includePaths.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } if(args.empty()) { cerr << argv[0] << ": no input file" << endl; usage(argv[0]); return EXIT_FAILURE; } int status = EXIT_SUCCESS; vector<string>::const_iterator i = args.begin(); std::string filename = *i; #if ICE_INT_VERSION / 100 < 304 Preprocessor* icecpp = new Preprocessor(argv[0], *i, cppArgs); #else PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); #endif FILE* cppHandle = icecpp->preprocess(true); if (cppHandle == 0) { return EXIT_FAILURE; } //#if ICE_INT_VERSION / 100 < 304 bool ignRedefs = false; bool all = false; bool allowIcePrefix = false; bool caseSensitive = true; //StringList defaultGlobalMetadata; UnitPtr u = Unit::createUnit(ignRedefs, all, allowIcePrefix, caseSensitive); //#else // UnitPtr u = Unit::createUnit(false, false, false); //#endif int parseStatus = u->parse(*i, cppHandle, false); if ( parseStatus == EXIT_FAILURE ) { cerr << "Parsing failed"; exit(0); } if(!icecpp->close()) { u->destroy(); return EXIT_FAILURE; } BasicClassLinkHandler linker; RstGen rstGen(linker); u->visit(&rstGen, true); u->destroy(); return status; }
int compile(const vector<string>& argv) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("", "validate"); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("E"); opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg, "."); opts.addOpt("", "hdr", IceUtilInternal::Options::NeedArg); opts.addOpt("", "ftr", IceUtilInternal::Options::NeedArg); opts.addOpt("", "indexhdr", IceUtilInternal::Options::NeedArg); opts.addOpt("", "indexftr", IceUtilInternal::Options::NeedArg); opts.addOpt("", "index", IceUtilInternal::Options::NeedArg, "1"); opts.addOpt("", "image-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "logo-url", IceUtilInternal::Options::NeedArg); opts.addOpt("", "search", IceUtilInternal::Options::NeedArg); opts.addOpt("", "summary", IceUtilInternal::Options::NeedArg, "0"); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); bool validate = find(argv.begin(), argv.end(), "--validate") != argv.end(); vector<string> args; try { args = opts.parse(argv); } catch(const IceUtilInternal::BadOptException& e) { consoleErr << argv[0] << ": error: " << e.reason << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } if(opts.isSet("version")) { consoleErr << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } vector<string> cppArgs; vector<string> optargs = opts.argVec("D"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } optargs = opts.argVec("U"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } optargs = opts.argVec("I"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } bool preprocess = opts.isSet("E"); string output = opts.optArg("output-dir"); string header = opts.optArg("hdr"); string footer = opts.optArg("ftr"); string indexHeader = opts.optArg("indexhdr"); string indexFooter = opts.optArg("indexftr"); string ind = opts.optArg("index"); unsigned indexCount = 0; if(!ind.empty()) { istringstream s(ind); s >> indexCount; if(!s) { consoleErr << argv[0] << ": error: the --index operation requires a positive integer argument" << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } }
int compile(int argc, char* argv[]) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("E"); opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "depend"); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); opts.addOpt("", "all"); opts.addOpt("", "checksum"); opts.addOpt("n", "namespace"); vector<string> args; try { args = opts.parse(argc, (const char**)argv); } catch(const IceUtilInternal::BadOptException& e) { getErrorStream() << argv[0] << ": error: " << e.reason << endl; usage(argv[0]); return EXIT_FAILURE; } if(opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } if(opts.isSet("version")) { getErrorStream() << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } vector<string> cppArgs; vector<string> optargs = opts.argVec("D"); vector<string>::const_iterator i; for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } optargs = opts.argVec("U"); for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } vector<string> includePaths = opts.argVec("I"); for(i = includePaths.begin(); i != includePaths.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } bool preprocess = opts.isSet("E"); string output = opts.optArg("output-dir"); bool depend = opts.isSet("depend"); bool debug = opts.isSet("debug"); bool ice = opts.isSet("ice"); bool underscore = opts.isSet("underscore"); bool all = opts.isSet("all"); bool checksum = opts.isSet("checksum"); bool ns = opts.isSet("namespace"); if(args.empty()) { getErrorStream() << argv[0] << ": error: no input file" << endl; usage(argv[0]); return EXIT_FAILURE; } int status = EXIT_SUCCESS; IceUtil::CtrlCHandler ctrlCHandler; ctrlCHandler.setCallback(interruptedCallback); for(i = args.begin(); i != args.end(); ++i) { // // Ignore duplicates. // vector<string>::iterator p = find(args.begin(), args.end(), *i); if(p != i) { continue; } if(depend) { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(false); if(cppHandle == 0) { return EXIT_FAILURE; } UnitPtr u = Unit::createUnit(false, false, ice, underscore); int parseStatus = u->parse(*i, cppHandle, debug); u->destroy(); if(parseStatus == EXIT_FAILURE) { return EXIT_FAILURE; } if(!icecpp->printMakefileDependencies(Preprocessor::PHP, includePaths)) { return EXIT_FAILURE; } if(!icecpp->close()) { return EXIT_FAILURE; } } else { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(false); if(cppHandle == 0) { return EXIT_FAILURE; } if(preprocess) { char buf[4096]; while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL) { if(fputs(buf, stdout) == EOF) { return EXIT_FAILURE; } } if(!icecpp->close()) { return EXIT_FAILURE; } } else { UnitPtr u = Unit::createUnit(false, all, ice, underscore); int parseStatus = u->parse(*i, cppHandle, debug); if(!icecpp->close()) { u->destroy(); return EXIT_FAILURE; } if(parseStatus == EXIT_FAILURE) { status = EXIT_FAILURE; } else { string base = icecpp->getBaseName(); string::size_type pos = base.find_last_of("/\\"); if(pos != string::npos) { base.erase(0, pos + 1); } string file = base + ".php"; if(!output.empty()) { file = output + '/' + file; } try { IceUtilInternal::Output out; out.open(file.c_str()); if(!out) { ostringstream os; os << "cannot open`" << file << "': " << strerror(errno); throw FileException(__FILE__, __LINE__, os.str()); } FileTracker::instance()->addFile(file); out << "<?php\n"; printHeader(out); printGeneratedHeader(out, base + ".ice"); // // Generate the PHP mapping. // generate(u, all, checksum, ns, includePaths, out); out << "?>\n"; out.close(); } catch(const Slice::FileException& ex) { // If a file could not be created, then cleanup any // created files. FileTracker::instance()->cleanup(); u->destroy(); getErrorStream() << argv[0] << ": error: " << ex.reason() << endl; return EXIT_FAILURE; } catch(const string& err) { FileTracker::instance()->cleanup(); getErrorStream() << argv[0] << ": error: " << err << endl; status = EXIT_FAILURE; } } u->destroy(); } } { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(mutex); if(interrupted) { FileTracker::instance()->cleanup(); return EXIT_FAILURE; } } } return status; }
int compile(int argc, char* argv[]) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("E"); opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "tie"); opts.addOpt("", "impl"); opts.addOpt("", "impl-tie"); opts.addOpt("", "depend"); opts.addOpt("", "depend-xml"); opts.addOpt("", "list-generated"); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); opts.addOpt("", "checksum", IceUtilInternal::Options::NeedArg); opts.addOpt("", "stream"); opts.addOpt("", "meta", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); vector<string>args; try { args = opts.parse(argc, (const char**)argv); } catch(const IceUtilInternal::BadOptException& e) { getErrorStream() << argv[0] << ": error: " << e.reason << endl; usage(argv[0]); return EXIT_FAILURE; } if(opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } if(opts.isSet("version")) { getErrorStream() << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } vector<string> cppArgs; vector<string> optargs = opts.argVec("D"); vector<string>::const_iterator i; for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } optargs = opts.argVec("U"); for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } vector<string> includePaths = opts.argVec("I"); for(i = includePaths.begin(); i != includePaths.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } bool preprocess = opts.isSet("E"); string output = opts.optArg("output-dir"); bool tie = opts.isSet("tie"); bool impl = opts.isSet("impl"); bool implTie = opts.isSet("impl-tie"); bool depend = opts.isSet("depend"); bool dependxml = opts.isSet("depend-xml"); bool debug = opts.isSet("debug"); bool ice = opts.isSet("ice"); bool underscore = opts.isSet("underscore"); string checksumClass = opts.optArg("checksum"); bool stream = opts.isSet("stream"); bool listGenerated = opts.isSet("list-generated"); StringList globalMetadata; vector<string> v = opts.argVec("meta"); copy(v.begin(), v.end(), back_inserter(globalMetadata)); if(args.empty()) { getErrorStream() << argv[0] << ": error: no input file" << endl; usage(argv[0]); return EXIT_FAILURE; } if(impl && implTie) { getErrorStream() << argv[0] << ": error: cannot specify both --impl and --impl-tie" << endl; usage(argv[0]); return EXIT_FAILURE; } int status = EXIT_SUCCESS; ChecksumMap checksums; IceUtil::CtrlCHandler ctrlCHandler; ctrlCHandler.setCallback(interruptedCallback); if(dependxml) { cout << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<dependencies>" << endl; } for(i = args.begin(); i != args.end(); ++i) { // // Ignore duplicates. // vector<string>::iterator p = find(args.begin(), args.end(), *i); if(p != i) { continue; } if(depend || dependxml) { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(false); if(cppHandle == 0) { return EXIT_FAILURE; } UnitPtr u = Unit::createUnit(false, false, ice, underscore); int parseStatus = u->parse(*i, cppHandle, debug); u->destroy(); if(parseStatus == EXIT_FAILURE) { return EXIT_FAILURE; } if(!icecpp->printMakefileDependencies(depend ? Preprocessor::Java : Preprocessor::JavaXML, includePaths)) { return EXIT_FAILURE; } if(!icecpp->close()) { return EXIT_FAILURE; } } else { ostringstream os; if(listGenerated) { Slice::setErrorStream(os); } FileTracker::instance()->setSource(*i); PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(true); if(cppHandle == 0) { if(listGenerated) { FileTracker::instance()->setOutput(os.str(), true); } status = EXIT_FAILURE; break; } if(preprocess) { char buf[4096]; while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL) { if(fputs(buf, stdout) == EOF) { return EXIT_FAILURE; } } if(!icecpp->close()) { return EXIT_FAILURE; } } else { UnitPtr p = Unit::createUnit(false, false, ice, underscore, globalMetadata); int parseStatus = p->parse(*i, cppHandle, debug, Ice); if(!icecpp->close()) { p->destroy(); return EXIT_FAILURE; } if(parseStatus == EXIT_FAILURE) { p->destroy(); if(listGenerated) { FileTracker::instance()->setOutput(os.str(), true); } status = EXIT_FAILURE; } else { try { Gen gen(argv[0], icecpp->getBaseName(), includePaths, output); gen.generate(p, stream); if(tie) { gen.generateTie(p); } if(impl) { gen.generateImpl(p); } if(implTie) { gen.generateImplTie(p); } if(!checksumClass.empty()) { // // Calculate checksums for the Slice definitions in the unit. // ChecksumMap m = createChecksums(p); copy(m.begin(), m.end(), inserter(checksums, checksums.begin())); } if(listGenerated) { FileTracker::instance()->setOutput(os.str(), false); } } catch(const Slice::FileException& ex) { // // If a file could not be created then cleanup any files we've already created. // FileTracker::instance()->cleanup(); p->destroy(); getErrorStream() << argv[0] << ": error: " << ex.reason() << endl; if(listGenerated) { FileTracker::instance()->setOutput(os.str(), true); } status = EXIT_FAILURE; break; } } p->destroy(); } } { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(mutex); if(interrupted) { // // If the translator was interrupted then cleanup any files we've already created. // FileTracker::instance()->cleanup(); return EXIT_FAILURE; } } } if(dependxml) { cout << "</dependencies>\n"; } if(status == EXIT_SUCCESS && !checksumClass.empty()) { try { Gen::writeChecksumClass(checksumClass, output, checksums); } catch(const Slice::FileException& ex) { // If a file could not be created, then // cleanup any created files. FileTracker::instance()->cleanup(); getErrorStream() << argv[0] << ": error: " << ex.reason() << endl; return EXIT_FAILURE; } } if(listGenerated) { FileTracker::instance()->dumpxml(); } return status; }
int Client::run(StringSeq& originalArgs) { string commands; bool debug; IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("e", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("i", "instanceName", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat); opts.addOpt("H", "host", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat); opts.addOpt("P", "port", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat); opts.addOpt("u", "username", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat); opts.addOpt("p", "password", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat); opts.addOpt("S", "ssl"); opts.addOpt("d", "debug"); opts.addOpt("s", "server"); opts.addOpt("r", "replica", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat); vector<string> args; try { args = opts.parse(originalArgs); } catch(const IceUtilInternal::BadOptException& e) { cerr << e.reason << endl; usage(); return EXIT_FAILURE; } if(!args.empty()) { cerr << _appName << ": too many arguments" << endl; usage(); return EXIT_FAILURE; } if(opts.isSet("help")) { usage(); return EXIT_SUCCESS; } if(opts.isSet("version")) { cout << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } if(opts.isSet("server")) { ObjectAdapterPtr adapter = communicator()->createObjectAdapterWithEndpoints("FileParser", "tcp -h localhost"); adapter->activate(); ObjectPrx proxy = adapter->add(new FileParserI, communicator()->stringToIdentity("FileParser")); cout << proxy << endl; communicator()->waitForShutdown(); return EXIT_SUCCESS; } if(opts.isSet("e")) { vector<string> optargs = opts.argVec("e"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { commands += *i + ";"; } } debug = opts.isSet("debug"); bool ssl = communicator()->getProperties()->getPropertyAsInt("IceGridAdmin.AuthenticateUsingSSL"); if(opts.isSet("ssl")) { ssl = true; } string id = communicator()->getProperties()->getProperty("IceGridAdmin.Username"); if(!opts.optArg("username").empty()) { id = opts.optArg("username"); } string password = communicator()->getProperties()->getProperty("IceGridAdmin.Password"); if(!opts.optArg("password").empty()) { password = opts.optArg("password"); } string host = communicator()->getProperties()->getProperty("IceGridAdmin.Host"); if(!opts.optArg("host").empty()) { host = opts.optArg("host"); } string instanceName = communicator()->getProperties()->getProperty("IceGridAdmin.InstanceName"); if(!opts.optArg("instanceName").empty()) { instanceName = opts.optArg("instanceName"); } int port = communicator()->getProperties()->getPropertyAsInt("IceGridAdmin.Port"); if(!opts.optArg("port").empty()) { istringstream is(opts.optArg("port")); if(!(is >> port)) { cerr << _appName << ": given port number is not a numeric value" << endl; return EXIT_FAILURE; } }
static int run(const Ice::StringSeq& originalArgs, const Ice::CommunicatorPtr& communicator) { vector<string> oldCppArgs; vector<string> newCppArgs; bool debug; bool ice = true; // Needs to be true in order to create default definitions. bool underscore; string outputFile; bool ignoreTypeChanges; bool purgeObjects; bool catastrophicRecover; bool suppress; string inputFile; vector<string> oldSlice; vector<string> newSlice; bool evictor; string keyTypeNames; string valueTypeNames; string dbEnvName, dbName, dbEnvNameNew; bool allDb = false; IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("d", "debug"); opts.addOpt("", "underscore"); opts.addOpt("o", "", IceUtilInternal::Options::NeedArg); opts.addOpt("i"); opts.addOpt("p"); opts.addOpt("c"); opts.addOpt("w"); opts.addOpt("f", "", IceUtilInternal::Options::NeedArg); opts.addOpt("", "include-old", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("", "include-new", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("", "old", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("", "new", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("a"); opts.addOpt("e"); opts.addOpt("", "key", IceUtilInternal::Options::NeedArg); opts.addOpt("", "value", IceUtilInternal::Options::NeedArg); const string appName = originalArgs[0]; vector<string> args; try { args = opts.parse(originalArgs); } catch(const IceUtilInternal::BadOptException& e) { cerr << appName << ": " << e.reason << endl; usage(appName); return EXIT_FAILURE; } if(opts.isSet("help")) { usage(appName); return EXIT_SUCCESS; } if(opts.isSet("version")) { cout << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } if(opts.isSet("D")) { vector<string> optargs = opts.argVec("D"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { oldCppArgs.push_back("-D" + *i); newCppArgs.push_back("-D" + *i); } } if(opts.isSet("U")) { vector<string> optargs = opts.argVec("U"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { oldCppArgs.push_back("-U" + *i); newCppArgs.push_back("-U" + *i); } } debug = opts.isSet("debug"); underscore = opts.isSet("underscore"); if(opts.isSet("o")) { outputFile = opts.optArg("o"); } ignoreTypeChanges = opts.isSet("i"); purgeObjects = opts.isSet("p"); catastrophicRecover = opts.isSet("c"); suppress = opts.isSet("w"); if(opts.isSet("f")) { inputFile = opts.optArg("f"); } if(opts.isSet("include-old")) { vector<string> optargs = opts.argVec("include-old"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { oldCppArgs.push_back("-I" + *i); } } if(opts.isSet("include-new")) { vector<string> optargs = opts.argVec("include-new"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { newCppArgs.push_back("-I" + *i); } } if(opts.isSet("old")) { vector<string> optargs = opts.argVec("old"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { oldSlice.push_back(*i); } } if(opts.isSet("new")) { vector<string> optargs = opts.argVec("new"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { newSlice.push_back(*i); } } evictor = opts.isSet("e"); if(opts.isSet("key")) { keyTypeNames = opts.optArg("key"); } if(opts.isSet("value")) { valueTypeNames = opts.optArg("value"); } if(outputFile.empty()) { if(args.size() == 2) { allDb = true; } else if(args.size() != 3) { usage(appName); return EXIT_FAILURE; } } else { if(args.size() == 1) { allDb = true; } else if(args.size() != 0) { usage(appName); return EXIT_FAILURE; } } if(allDb && (!keyTypeNames.empty() || !valueTypeNames.empty())) { usage(appName); return EXIT_FAILURE; } if(inputFile.empty() && !allDb && !evictor && (keyTypeNames.empty() || valueTypeNames.empty())) { usage(appName); return EXIT_FAILURE; } if(args.size() > 0) { dbEnvName = args[0]; } if(args.size() > 1) { if(allDb) { dbEnvNameNew = args[1]; } else { dbName = args[1]; } } if(args.size() > 2) { dbEnvNameNew = args[2]; } if(args.size() > 3) { cerr << appName << ": too many arguments" << endl; usage(appName); return EXIT_FAILURE; } // // Freeze creates a lock file by default to prevent multiple processes from opening // the same database environment simultaneously. In the case of a read-only program // such as transformdb, however, we still want to be able to open the environment despite // the lock. This assumes of course that the other process has opened the environment // with DbPrivate=0. If DbPrivate=0 is also set for dumpdb, we disable the lock. // if(!catastrophicRecover && outputFile.empty()) { Ice::PropertiesPtr props = communicator->getProperties(); string prefix = "Freeze.DbEnv." + args[0]; if(props->getPropertyAsIntWithDefault(prefix + ".DbPrivate", 1) == 0) { props->setProperty(prefix + ".LockFile", "0"); } } Slice::UnitPtr oldUnit = Slice::Unit::createUnit(true, true, ice, underscore); FreezeScript::Destroyer<Slice::UnitPtr> oldD(oldUnit); if(!FreezeScript::parseSlice(appName, oldUnit, oldSlice, oldCppArgs, debug, "-D__TRANSFORMDB__")) { return EXIT_FAILURE; } Slice::UnitPtr newUnit = Slice::Unit::createUnit(true, true, ice, underscore); FreezeScript::Destroyer<Slice::UnitPtr> newD(newUnit); if(!FreezeScript::parseSlice(appName, newUnit, newSlice, newCppArgs, debug, "-D__TRANSFORMDB__")) { return EXIT_FAILURE; } // // Install the evictor types in the Slice units. // FreezeScript::createEvictorSliceTypes(oldUnit); FreezeScript::createEvictorSliceTypes(newUnit); // // Read the catalog if necessary. // FreezeScript::CatalogDataMap catalog; if(allDb) { try { catalog = FreezeScript::readCatalog(communicator, dbEnvName); } catch(const FreezeScript::FailureException& ex) { cerr << appName << ": " << ex.reason() << endl; return EXIT_FAILURE; } if(catalog.empty()) { cerr << appName << ": no databases in environment `" << dbEnvName << "'" << endl; return EXIT_FAILURE; } } // // If no input file was provided, then we need to analyze the Slice types. // string descriptors; if(inputFile.empty()) { ostringstream out; vector<string> missingTypes; vector<string> analyzeErrors; FreezeScript::TransformAnalyzer analyzer(oldUnit, newUnit, ignoreTypeChanges, out, missingTypes, analyzeErrors); const string evictorKeyName = "::Ice::Identity"; const string oldEvictorValueName = "::Freeze::ObjectRecord"; const string newEvictorValueName = "Object"; if(allDb) { // // Add a <database> element for each database in the catalog. // for(FreezeScript::CatalogDataMap::iterator p = catalog.begin(); p != catalog.end(); ++p) { string keyName, valueName; if(p->second.evictor) { keyName = p->second.key; valueName = p->second.value; if(keyName.empty()) { keyName = evictorKeyName; } if(valueName.empty()) { valueName = oldEvictorValueName; } } else { keyName = p->second.key; valueName = p->second.value; } // // Look up the key and value types in the old and new Slice definitions. // Slice::TypePtr oldKeyType = findType(oldUnit, keyName); if(!oldKeyType) { cerr << appName << ": type `" << keyName << "' from database `" << p->first << "' not found in old Slice definitions" << endl; } Slice::TypePtr newKeyType = findType(newUnit, keyName); if(!newKeyType) { cerr << appName << ": type `" << keyName << "' from database `" << p->first << "' not found in new Slice definitions" << endl; } Slice::TypePtr oldValueType = findType(oldUnit, valueName); if(!oldValueType) { cerr << appName << ": type `" << valueName << "' from database `" << p->first << "' not found in old Slice definitions" << endl; } Slice::TypePtr newValueType; if(p->second.evictor) { // // The new evictor does not keep stats // newValueType = findType(newUnit, newEvictorValueName); } else { newValueType = findType(newUnit, valueName); } if(!newValueType) { cerr << appName << ": type `" << valueName << "' from database `" << p->first << "' not found in new Slice definitions" << endl; } // // If we are generating an output file, we do not consider a missing type to be // an error. Since the type information comes from the catalog of the old // environment, it's possible that the key or value types are not present in // the new Slice definitions. Rather than abort at this point, we simply emit // a partially-defined <database> element that must be edited by the user. // // If we are not generating an output file, we have to stop now. // if(outputFile.empty() && (!oldKeyType || !newKeyType || !oldValueType || !newValueType)) { return EXIT_FAILURE; } analyzer.addDatabase(p->first, oldKeyType, newKeyType, oldValueType, newValueType); } } else { string oldKeyName, newKeyName, oldValueName, newValueName; string::size_type pos; if(!evictor && (keyTypeNames.empty() || valueTypeNames.empty())) { usage(appName); return EXIT_FAILURE; } if(!keyTypeNames.empty()) { pos = keyTypeNames.find(','); if(pos == 0 || pos == keyTypeNames.size()) { usage(appName); return EXIT_FAILURE; } if(pos == string::npos) { oldKeyName = keyTypeNames; newKeyName = keyTypeNames; } else { oldKeyName = keyTypeNames.substr(0, pos); newKeyName = keyTypeNames.substr(pos + 1); } } if(!valueTypeNames.empty()) { pos = valueTypeNames.find(','); if(pos == 0 || pos == valueTypeNames.size()) { usage(appName); return EXIT_FAILURE; } if(pos == string::npos) { oldValueName = valueTypeNames; newValueName = valueTypeNames; } else { oldValueName = valueTypeNames.substr(0, pos); newValueName = valueTypeNames.substr(pos + 1); } } if(evictor) { if(oldKeyName.empty()) { oldKeyName = evictorKeyName; } if(newKeyName.empty()) { newKeyName = evictorKeyName; } if(oldValueName.empty()) { oldValueName = newEvictorValueName; } if(newValueName.empty()) { newValueName = newEvictorValueName; } } // // Look up the key and value types in the old and new Slice definitions. // Slice::TypePtr oldKeyType = findType(oldUnit, oldKeyName); if(!oldKeyType) { cerr << appName << ": type `" << oldKeyName << "' not found in old Slice definitions" << endl; } Slice::TypePtr newKeyType = findType(newUnit, newKeyName); if(!newKeyType) { cerr << appName << ": type `" << newKeyName << "' not found in new Slice definitions" << endl; } Slice::TypePtr oldValueType = findType(oldUnit, oldValueName); if(!oldValueType) { cerr << appName << ": type `" << oldValueName << "' not found in old Slice definitions" << endl; } Slice::TypePtr newValueType = findType(newUnit, newValueName); if(!newValueType) { cerr << appName << ": type `" << newValueName << "' not found in new Slice definitions" << endl; } // // Stop now if any of the types could not be found. // if(!oldKeyType || !newKeyType || !oldValueType || !newValueType) { return EXIT_FAILURE; } analyzer.addDatabase("", oldKeyType, newKeyType, oldValueType, newValueType); } analyzer.finish(); if(!analyzeErrors.empty()) { for(vector<string>::const_iterator p = analyzeErrors.begin(); p != analyzeErrors.end(); ++p) { cerr << appName << ": " << *p << endl; } } if(!missingTypes.empty()) { sort(missingTypes.begin(), missingTypes.end()); unique(missingTypes.begin(), missingTypes.end()); if(!analyzeErrors.empty()) { cerr << endl; } cerr << "The following types had no matching definitions in the new Slice:" << endl; for(vector<string>::const_iterator p = missingTypes.begin(); p != missingTypes.end(); ++p) { cerr << " " << *p << endl; } } if(!analyzeErrors.empty()) { return EXIT_FAILURE; } descriptors = out.str(); if(!outputFile.empty()) { // // No nativeToUTF8 conversion necessary here, no string converter is installed // by wmain() on Windows and args are assumbed to be UTF8 on Unix platforms. // IceUtilInternal::ofstream of(outputFile); if(!of.good()) { cerr << appName << ": unable to open file `" << outputFile << "'" << endl; return EXIT_FAILURE; } of << descriptors; of.close(); return EXIT_SUCCESS; } } else { // // Read the input file. // // No nativeToUTF8 conversion necessary here, no string converter is installed // by wmain() on Windows and args are assumbed to be UTF8 on Unix platforms. // IceUtilInternal::ifstream in(inputFile); char buff[1024]; while(true) { in.read(buff, 1024); descriptors.append(buff, static_cast<size_t>(in.gcount())); if(in.gcount() < 1024) { break; } } in.close(); } if(dbEnvName == dbEnvNameNew) { cerr << appName << ": database environment names must be different" << endl; return EXIT_FAILURE; } FreezeScript::ObjectFactoryPtr objectFactory = new FreezeScript::ObjectFactory; communicator->addObjectFactory(objectFactory, ""); // // Transform the database. // DbEnv dbEnv(0); DbEnv dbEnvNew(0); Freeze::TransactionPtr txNew; Freeze::ConnectionPtr connection; Freeze::ConnectionPtr connectionNew; vector<Db*> dbs; int status = EXIT_SUCCESS; try { #ifdef _WIN32 // // Berkeley DB may use a different C++ runtime. // dbEnv.set_alloc(::malloc, ::realloc, ::free); dbEnvNew.set_alloc(::malloc, ::realloc, ::free); #endif // // Open the old database environment. Use DB_RECOVER_FATAL if -c is specified. // No transaction is created for the old environment. // // DB_THREAD is for compatibility with Freeze (the catalog) // { u_int32_t flags = DB_THREAD | DB_CREATE | DB_INIT_TXN | DB_INIT_MPOOL; if(catastrophicRecover) { flags |= DB_INIT_LOG | DB_RECOVER_FATAL; } dbEnv.open(dbEnvName.c_str(), flags, FREEZE_SCRIPT_DB_MODE); } // // We're creating a connection just to make sure the database environment // isn't locked. // connection = Freeze::createConnection(communicator, dbEnvName, dbEnv); // // Open the new database environment and start a transaction. // // // DB_THREAD is for compatibility with Freeze (the catalog) // { u_int32_t flags = DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER | DB_CREATE | DB_THREAD; dbEnvNew.open(dbEnvNameNew.c_str(), flags, FREEZE_SCRIPT_DB_MODE); } // // TODO: handle properly DbHome config (currently it will break if it's set for the new env) // // // Open the catalog of the new environment, and start a transaction. // connectionNew = Freeze::createConnection(communicator, dbEnvNameNew, dbEnvNew); txNew = connectionNew->beginTransaction(); DbTxn* txnNew = Freeze::getTxn(txNew); if(allDb) { // // Transform all databases in the old catalog. // for(FreezeScript::CatalogDataMap::iterator p = catalog.begin(); p != catalog.end(); ++p) { transformDb(p->second.evictor, communicator, objectFactory, dbEnv, dbEnvNew, p->first, connectionNew, dbs, oldUnit, newUnit, txnNew, purgeObjects, suppress, descriptors); } } else { transformDb(evictor, communicator, objectFactory, dbEnv, dbEnvNew, dbName, connectionNew, dbs, oldUnit, newUnit, txnNew, purgeObjects, suppress, descriptors); } } catch(const DbException& ex) { cerr << appName << ": database error: " << ex.what() << endl; status = EXIT_FAILURE; } catch(const IceUtil::FileLockException&) { cerr << appName << ": error: database environment is locked" << endl; status = EXIT_FAILURE; } catch(...) { try { if(txNew != 0) { txNew->rollback(); txNew = 0; } if(connectionNew) { connectionNew->close(); connectionNew = 0; } if(connection) { connection->close(); connection = 0; } for(vector<Db*>::iterator p = dbs.begin(); p != dbs.end(); ++p) { Db* db = *p; db->close(0); delete db; } try { dbEnv.close(0); } catch(const DbException&) { } try { dbEnvNew.close(0); } catch(const DbException&) { } } catch(const DbException& ex) { cerr << appName << ": database error: " << ex.what() << endl; } throw; } if(txNew != 0) { try { if(status == EXIT_FAILURE) { txNew->rollback(); } else { txNew->commit(); // // Checkpoint to migrate changes from the log to the database(s). // dbEnvNew.txn_checkpoint(0, 0, DB_FORCE); } for(vector<Db*>::iterator p = dbs.begin(); p != dbs.end(); ++p) { Db* db = *p; db->close(0); delete db; } } catch(const DbException& ex) { cerr << appName << ": database error: " << ex.what() << endl; status = EXIT_FAILURE; } } // Clear the transaction before closing the database environment. txNew = 0; if(connectionNew) { connectionNew->close(); connectionNew = 0; } if(connection) { connection->close(); connection = 0; } try { dbEnv.close(0); } catch(const DbException&) { } try { dbEnvNew.close(0); } catch(const DbException&) { } return status; }
int main(int argc, char* argv[]) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("", "header-ext", IceUtilInternal::Options::NeedArg, "h"); opts.addOpt("", "source-ext", IceUtilInternal::Options::NeedArg, "cpp"); opts.addOpt("", "add-header", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("E"); opts.addOpt("", "include-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "dll-export", IceUtilInternal::Options::NeedArg); opts.addOpt("", "impl"); opts.addOpt("", "depend"); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "case-sensitive"); vector<string> args; try { args = opts.parse(argc, (const char**)argv); } catch(const IceUtilInternal::BadOptException& e) { cerr << argv[0] << ": " << e.reason << endl; usage(argv[0]); return EXIT_FAILURE; } if(opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } if(opts.isSet("version")) { cout << ICEE_STRING_VERSION << endl; return EXIT_SUCCESS; } string headerExtension = opts.optArg("header-ext"); string sourceExtension = opts.optArg("source-ext"); vector<string>extraHeaders = opts.argVec("add-header"); vector<string> cppArgs; vector<string> optargs = opts.argVec("D"); vector<string>::const_iterator i; for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } optargs = opts.argVec("U"); for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } vector<string> includePaths = opts.argVec("I"); for(i = includePaths.begin(); i != includePaths.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } bool preprocess = opts.isSet("E"); string include = opts.optArg("include-dir"); string output = opts.optArg("output-dir"); string dllExport = opts.optArg("dll-export"); bool impl = opts.isSet("impl"); bool depend = opts.isSet("depend"); bool debug = opts.isSet("debug"); bool ice = opts.isSet("ice"); bool caseSensitive = opts.isSet("case-sensitive"); if(args.empty()) { cerr << argv[0] << ": no input file" << endl; usage(argv[0]); return EXIT_FAILURE; } int status = EXIT_SUCCESS; IceUtil::CtrlCHandler ctrlCHandler; ctrlCHandler.setCallback(interruptedCallback); for(i = args.begin(); i != args.end(); ++i) { if(depend) { Preprocessor icecpp(argv[0], *i, cppArgs); icecpp.printMakefileDependencies(Preprocessor::CPlusPlus, includePaths); } else { Preprocessor icecpp(argv[0], *i, cppArgs); FILE* cppHandle = icecpp.preprocess(false); if(cppHandle == 0) { return EXIT_FAILURE; } if(preprocess) { char buf[4096]; while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL) { if(fputs(buf, stdout) == EOF) { return EXIT_FAILURE; } } if(!icecpp.close()) { return EXIT_FAILURE; } } else { UnitPtr u = Unit::createUnit(false, false, ice, caseSensitive); int parseStatus = u->parse(*i, cppHandle, debug, Slice::IceE); if(!icecpp.close()) { u->destroy(); return EXIT_FAILURE; } if(parseStatus == EXIT_FAILURE) { status = EXIT_FAILURE; } else { Gen gen(argv[0], icecpp.getBaseName(), headerExtension, sourceExtension, extraHeaders, include, includePaths, dllExport, output, impl, ice); if(!gen) { u->destroy(); return EXIT_FAILURE; } gen.generate(u); } u->destroy(); } } { IceUtil::StaticMutex::Lock lock(_mutex); if(_interrupted) { return EXIT_FAILURE; } } } return status; }
static int run(const Ice::StringSeq& originalArgs, const Ice::CommunicatorPtr& communicator, const FreezeScript::CompactIdResolverIPtr& resolver) { vector<string> cppArgs; bool debug; bool ice = true; // Needs to be true in order to create default definitions. bool underscore; string outputFile; string inputFile; vector<string> slice; bool evictor; string keyTypeName; string valueTypeName; string selectExpr; string dbEnvName, dbName; const string appName = originalArgs[0]; IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); opts.addOpt("o", "", IceUtilInternal::Options::NeedArg); opts.addOpt("f", "", IceUtilInternal::Options::NeedArg); opts.addOpt("", "load", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("e"); opts.addOpt("", "key", IceUtilInternal::Options::NeedArg); opts.addOpt("", "value", IceUtilInternal::Options::NeedArg); opts.addOpt("", "select", IceUtilInternal::Options::NeedArg); opts.addOpt("c", "catalog"); vector<string> args; try { args = opts.parse(originalArgs); } catch(const IceUtilInternal::BadOptException& e) { cerr << appName << ": " << e.reason << endl; usage(appName); return EXIT_FAILURE; } // // Freeze creates a lock file by default to prevent multiple processes from opening // the same database environment simultaneously. In the case of a read-only program // such as dumpdb, however, we still want to be able to open the environment despite // the lock. This assumes of course that the other process has opened the environment // with DbPrivate=0. If DbPrivate=0 is also set for dumpdb, we disable the lock. // if(!args.empty()) { // // If an argument is present, we assume it is the name of the database environment. // Ice::PropertiesPtr props = communicator->getProperties(); string prefix = "Freeze.DbEnv." + args[0]; if(props->getPropertyAsIntWithDefault(prefix + ".DbPrivate", 1) <= 0) { props->setProperty(prefix + ".LockFile", "0"); } } if(opts.isSet("h")) { usage(appName); return EXIT_SUCCESS; } if(opts.isSet("version")) { cout << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } if(opts.isSet("c")) { if(args.empty()) { cerr << appName << ": no database environment specified." << endl; usage(appName); return EXIT_FAILURE; } else if(args.size() > 2) { usage(appName); return EXIT_FAILURE; } try { FreezeScript::CatalogDataMap catalog = FreezeScript::readCatalog(communicator, args[0]); if(args.size() == 1) { if(catalog.empty()) { cout << "Catalog is empty." << endl; } else { cout << "Catalog contents:" << endl; for(FreezeScript::CatalogDataMap::const_iterator p = catalog.begin(); p != catalog.end(); ++p) { cout << endl; printCatalogData(p->first, p->second); } } } else { FreezeScript::CatalogDataMap::const_iterator p = catalog.find(args[1]); if(p == catalog.end()) { cerr << appName << ": database `" << args[1] << "' not found in environment `" << args[0] << "'." << endl; return EXIT_FAILURE; } else { printCatalogData(p->first, p->second); } } return EXIT_SUCCESS; } catch(const FreezeScript::FailureException& ex) { cerr << appName << ": " << ex.reason() << endl; return EXIT_FAILURE; } } if(opts.isSet("D")) { vector<string> optargs = opts.argVec("D"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } } if(opts.isSet("U")) { vector<string> optargs = opts.argVec("U"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } } if(opts.isSet("I")) { vector<string> optargs = opts.argVec("I"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-I" + *i); } } debug = opts.isSet("debug"); // No need to set --ice option here -- it is always true. underscore = opts.isSet("underscore"); if(opts.isSet("o")) { outputFile = opts.optArg("o"); } if(opts.isSet("f")) { inputFile = opts.optArg("f"); } if(opts.isSet("load")) { vector<string> optArgs = opts.argVec("load"); for(vector<string>::const_iterator i = optArgs.begin(); i != optArgs.end(); ++i) { slice.push_back(*i); } } evictor = opts.isSet("e"); if(opts.isSet("key")) { keyTypeName = opts.optArg("key"); } if(opts.isSet("value")) { valueTypeName = opts.optArg("value"); } if(opts.isSet("select")) { selectExpr = opts.optArg("select"); } if(outputFile.empty() && args.size() != 2) { usage(appName); return EXIT_FAILURE; } if(!args.empty()) { dbEnvName = args[0]; } if(args.size() == 2) { dbName = args[1]; } else { usage(appName); return EXIT_FAILURE; } if(!inputFile.empty() && !selectExpr.empty()) { cerr << appName << ": an input file cannot be specified with --select" << endl; return EXIT_FAILURE; } Slice::UnitPtr unit = Slice::Unit::createUnit(true, true, ice, underscore); FreezeScript::Destroyer<Slice::UnitPtr> unitD(unit); if(!FreezeScript::parseSlice(appName, unit, slice, cppArgs, debug, "-D__DUMPDB__")) { return EXIT_FAILURE; } FreezeScript::createEvictorSliceTypes(unit); FreezeScript::collectCompactIds(unit, resolver); // // If no input file was provided, then we need to generate default descriptors. // string descriptors; if(inputFile.empty()) { const string evictorKeyTypeName = "::Ice::Identity"; const string oldEvictorValueTypeName = "::Freeze::ObjectRecord"; const string newEvictorValueTypeName = "Object"; if((!keyTypeName.empty() && valueTypeName.empty()) || (keyTypeName.empty() && !valueTypeName.empty() && !evictor)) { cerr << appName << ": a key type and a value type must be specified" << endl; usage(appName); return EXIT_FAILURE; } else if(valueTypeName.empty()) { try { FreezeScript::CatalogDataMap catalog = FreezeScript::readCatalog(communicator, dbEnvName); FreezeScript::CatalogDataMap::iterator p = catalog.find(dbName); if(p == catalog.end()) { cerr << appName << ": database `" << dbName << "' not found in catalog." << endl; cerr << "Current catalog databases:" << endl; for(p = catalog.begin(); p != catalog.end(); ++p) { cerr << " " << p->first << endl; } return EXIT_FAILURE; } else { if(p->second.evictor) { evictor = true; } keyTypeName = p->second.key; valueTypeName = p->second.value; if(evictor && valueTypeName.empty()) { valueTypeName = oldEvictorValueTypeName; } } } catch(const FreezeScript::FailureException& ex) { cerr << appName << ": " << ex.reason() << endl; return EXIT_FAILURE; } } if(evictor) { if(keyTypeName.empty()) { keyTypeName = evictorKeyTypeName; } if(valueTypeName.empty()) { valueTypeName = newEvictorValueTypeName; } } Slice::TypePtr keyType, valueType; Slice::TypeList l; l = unit->lookupType(keyTypeName, false); if(l.empty()) { cerr << appName << ": unknown key type `" << keyTypeName << "'" << endl; return EXIT_FAILURE; } keyType = l.front(); l = unit->lookupType(valueTypeName, false); if(l.empty()) { cerr << appName << ": unknown value type `" << valueTypeName << "'" << endl; return EXIT_FAILURE; } valueType = l.front(); ostringstream os; IceUtilInternal::XMLOutput out(os); out << se("dumpdb"); FreezeScript::SliceVisitor visitor(out, keyType, valueType, selectExpr); unit->visit(&visitor, false); out << ee; descriptors = os.str(); if(!outputFile.empty()) { IceUtilInternal::ofstream of(outputFile); if(!of.good()) { cerr << appName << ": unable to open file `" << outputFile << "'" << endl; return EXIT_FAILURE; } of << descriptors << endl; of.close(); return EXIT_SUCCESS; } } else { IceUtilInternal::ifstream in(inputFile); char buff[1024]; while(true) { in.read(buff, 1024); descriptors.append(buff, static_cast<size_t>(in.gcount())); if(in.gcount() < 1024) { break; } } in.close(); } FreezeScript::ValueFactoryPtr valueFactory = new FreezeScript::ValueFactory; communicator->getValueFactoryManager()->add(valueFactory, ""); DbEnv dbEnv(0); DbTxn* txn = 0; Freeze::ConnectionPtr connection; int status = EXIT_SUCCESS; try { #ifdef _WIN32 // // Berkeley DB may use a different C++ runtime. // dbEnv.set_alloc(::malloc, ::realloc, ::free); #endif // // Open the database environment and start a transaction. // { u_int32_t flags = DB_THREAD | DB_CREATE | DB_INIT_TXN | DB_INIT_MPOOL; dbEnv.open(dbEnvName.c_str(), flags, FREEZE_SCRIPT_DB_MODE); } // // We're creating a connection just to make sure the database environment // isn't locked. // connection = Freeze::createConnection(communicator, dbEnvName, dbEnv); dbEnv.txn_begin(0, &txn, 0); FreezeScript::ErrorReporterPtr errorReporter = new FreezeScript::ErrorReporter(cerr, false); try { FreezeScript::DataFactoryPtr factory = new FreezeScript::DataFactory(communicator, unit, errorReporter); FreezeScript::DescriptorHandler dh(factory, unit, errorReporter, valueFactory); istringstream istr(descriptors); IceXML::Parser::parse(istr, dh); FreezeScript::DumpDBDescriptorPtr descriptor = dh.descriptor(); descriptor->validate(); if(evictor) { // // The evictor database file contains multiple databases. We must first // determine the names of those databases, ignoring any whose names // begin with "$index:". Each database represents a separate facet, with // the facet name used as the database name. The database named "$default" // represents the main object. // vector<string> dbNames; { Db db(&dbEnv, 0); db.open(txn, dbName.c_str(), 0, DB_UNKNOWN, DB_RDONLY, 0); Dbt dbKey, dbValue; dbKey.set_flags(DB_DBT_MALLOC); dbValue.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL); Dbc* dbc = 0; db.cursor(txn, &dbc, 0); while(dbc->get(&dbKey, &dbValue, DB_NEXT) == 0) { string s(static_cast<char*>(dbKey.get_data()), dbKey.get_size()); if(s.find("$index:") != 0) { dbNames.push_back(s); } free(dbKey.get_data()); } dbc->close(); db.close(0); } // // Dump each database. // for(vector<string>::iterator p = dbNames.begin(); p != dbNames.end(); ++p) { string name = *p; string facet = (name == "$default" ? string("") : name); Db db(&dbEnv, 0); db.open(txn, dbName.c_str(), name.c_str(), DB_BTREE, DB_RDONLY, FREEZE_SCRIPT_DB_MODE); descriptor->dump(communicator, &db, txn, facet); db.close(0); } } else { // // Dump a map database. // Db db(&dbEnv, 0); db.open(txn, dbName.c_str(), 0, DB_BTREE, DB_RDONLY, FREEZE_SCRIPT_DB_MODE); descriptor->dump(communicator, &db, txn, ""); db.close(0); } } catch(const IceXML::ParserException& ex) { errorReporter->error(ex.reason()); } } catch(const DbException& ex) { cerr << appName << ": database error: " << ex.what() << endl; status = EXIT_FAILURE; } catch(...) { try { if(txn) { txn->abort(); } dbEnv.close(0); } catch(const DbException& ex) { cerr << appName << ": database error: " << ex.what() << endl; } if(connection) { connection->close(); connection = 0; } throw; } try { if(txn) { txn->abort(); } if(connection) { connection->close(); } dbEnv.close(0); } catch(const DbException& ex) { cerr << appName << ": database error: " << ex.what() << endl; status = EXIT_FAILURE; } return status; }
int compile(int argc, char* argv[]) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("E"); opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "depend"); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); opts.addOpt("", "all"); opts.addOpt("", "no-package"); opts.addOpt("", "checksum"); opts.addOpt("", "prefix", IceUtilInternal::Options::NeedArg); vector<string> args; try { args = opts.parse(argc, (const char**)argv); } catch(const IceUtilInternal::BadOptException& e) { getErrorStream() << argv[0] << ": error: " << e.reason << endl; usage(argv[0]); return EXIT_FAILURE; } if(opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } if(opts.isSet("version")) { getErrorStream() << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } vector<string> cppArgs; vector<string> optargs = opts.argVec("D"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } optargs = opts.argVec("U"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } vector<string> includePaths = opts.argVec("I"); for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } bool preprocess = opts.isSet("E"); string output = opts.optArg("output-dir"); bool depend = opts.isSet("depend"); bool debug = opts.isSet("debug"); bool ice = opts.isSet("ice"); bool underscore = opts.isSet("underscore"); bool all = opts.isSet("all"); bool noPackage = opts.isSet("no-package"); bool checksum = opts.isSet("checksum"); string prefix = opts.optArg("prefix"); if(args.empty()) { getErrorStream() << argv[0] << ": error: no input file" << endl; usage(argv[0]); return EXIT_FAILURE; } int status = EXIT_SUCCESS; IceUtil::CtrlCHandler ctrlCHandler; ctrlCHandler.setCallback(interruptedCallback); bool keepComments = true; for(vector<string>::const_iterator i = args.begin(); i != args.end(); ++i) { // // Ignore duplicates. // vector<string>::iterator p = find(args.begin(), args.end(), *i); if(p != i) { continue; } if(depend) { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(false, "-D__SLICE2PY__"); if(cppHandle == 0) { return EXIT_FAILURE; } UnitPtr u = Unit::createUnit(false, false, ice, underscore); int parseStatus = u->parse(*i, cppHandle, debug); u->destroy(); if(parseStatus == EXIT_FAILURE) { return EXIT_FAILURE; } if(!icecpp->printMakefileDependencies(Preprocessor::Python, includePaths, "-D__SLICE2PY__", "", prefix)) { return EXIT_FAILURE; } if(!icecpp->close()) { return EXIT_FAILURE; } } else { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(keepComments, "-D__SLICE2PY__"); if(cppHandle == 0) { return EXIT_FAILURE; } if(preprocess) { char buf[4096]; while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL) { if(fputs(buf, stdout) == EOF) { return EXIT_FAILURE; } } if(!icecpp->close()) { return EXIT_FAILURE; } } else { UnitPtr u = Unit::createUnit(false, all, ice, underscore); int parseStatus = u->parse(*i, cppHandle, debug); if(!icecpp->close()) { u->destroy(); return EXIT_FAILURE; } if(parseStatus == EXIT_FAILURE) { status = EXIT_FAILURE; } else { string base = icecpp->getBaseName(); string::size_type pos = base.find_last_of("/\\"); if(pos != string::npos) { base.erase(0, pos + 1); } // // Append the suffix "_ice" to the filename in order to avoid any conflicts // with Slice module names. For example, if the file Test.ice defines a // Slice module named "Test", then we couldn't create a Python package named // "Test" and also call the generated file "Test.py". // string file = prefix + base + "_ice.py"; if(!output.empty()) { file = output + '/' + file; } try { IceUtilInternal::Output out; out.open(file.c_str()); if(!out) { ostringstream os; os << "cannot open`" << file << "': " << strerror(errno); throw FileException(__FILE__, __LINE__, os.str()); } FileTracker::instance()->addFile(file); printHeader(out); printGeneratedHeader(out, base + ".ice", "#"); // // Generate the Python mapping. // generate(u, all, checksum, includePaths, out); out.close(); // // Create or update the Python package hierarchy. // if(!noPackage) { PackageVisitor::createModules(u, prefix + base + "_ice", output); } } catch(const Slice::FileException& ex) { // If a file could not be created, then cleanup any // created files. FileTracker::instance()->cleanup(); u->destroy(); getErrorStream() << argv[0] << ": error: " << ex.reason() << endl; return EXIT_FAILURE; } catch(const string& err) { FileTracker::instance()->cleanup(); getErrorStream() << argv[0] << ": error: " << err << endl; status = EXIT_FAILURE; } } u->destroy(); } } { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(globalMutex); if(interrupted) { FileTracker::instance()->cleanup(); return EXIT_FAILURE; } } } return status; }
int run(int argc, char* argv[], const CommunicatorPtr& communicator) { IceUtilInternal::Options opts; opts.addOpt("", "events", IceUtilInternal::Options::NeedArg); opts.addOpt("", "qos", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("", "slow"); opts.addOpt("", "erratic", IceUtilInternal::Options::NeedArg); try { opts.parse(argc, (const char**)argv); } catch(const IceUtilInternal::BadOptException& e) { cerr << argv[0] << ": " << e.reason << endl; return EXIT_FAILURE; } int events = 1000; string s = opts.optArg("events"); if(!s.empty()) { events = atoi(s.c_str()); } if(events <= 0) { cerr << argv[0] << ": events must be > 0." << endl; return EXIT_FAILURE; } IceStorm::QoS cmdLineQos; vector<string> sqos = opts.argVec("qos"); for(vector<string>::const_iterator q = sqos.begin(); q != sqos.end(); ++q) { string::size_type off = q->find(","); if(off == string::npos) { cerr << argv[0] << ": parse error: no , in QoS" << endl; return EXIT_FAILURE; } cmdLineQos[q->substr(0, off)] = q->substr(off+1); } bool slow = opts.isSet("slow"); bool erratic = false; int erraticNum = 0; s = opts.optArg("erratic"); if(!s.empty()) { erratic = true; erraticNum = atoi(s.c_str()); } if(events <= 0) { cerr << argv[0] << ": events must be > 0." << endl; return EXIT_FAILURE; } PropertiesPtr properties = communicator->getProperties(); const char* managerProxyProperty = "IceStormAdmin.TopicManager.Default"; string managerProxy = properties->getProperty(managerProxyProperty); if(managerProxy.empty()) { cerr << argv[0] << ": property `" << managerProxyProperty << "' is not set" << endl; return EXIT_FAILURE; } IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast( communicator->stringToProxy(managerProxy)); if(!manager) { cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl; return EXIT_FAILURE; } vector<Subscription> subs; if(erratic) { for(int i = 0 ; i < erraticNum; ++i) { ostringstream os; os << "SubscriberAdapter" << i; Subscription item; item.adapter = communicator->createObjectAdapterWithEndpoints(os.str(), "default"); item.servant = new ErraticEventI(communicator, events); item.qos["reliability"] = "twoway"; subs.push_back(item); } } else if(slow) { Subscription item; item.adapter = communicator->createObjectAdapterWithEndpoints("SubscriberAdapter", "default"); item.servant = new SlowEventI(communicator, events); item.qos = cmdLineQos; subs.push_back(item); } else { Subscription item; item.adapter = communicator->createObjectAdapterWithEndpoints("SubscriberAdapter", "default"); item.qos = cmdLineQos; map<string, string>::const_iterator p = item.qos.find("reliability"); if(p != item.qos.end() && p->second == "ordered") { item.servant = new OrderEventI(communicator, events); } else { item.servant = new CountEventI(communicator, events); } subs.push_back(item); } TopicPrx topic; try { topic = manager->retrieve("fed1"); } catch(const IceStorm::NoSuchTopic& e) { cerr << argv[0] << ": NoSuchTopic: " << e.name << endl; return EXIT_FAILURE; } { for(vector<Subscription>::iterator p = subs.begin(); p != subs.end(); ++p) { p->obj = p->adapter->addWithUUID(p->servant); IceStorm::QoS qos; string reliability = ""; IceStorm::QoS::const_iterator q = p->qos.find("reliability"); if(q != p->qos.end()) { reliability = q->second; } if(reliability == "twoway") { // Do nothing. } else if(reliability == "ordered") { qos["reliability"] = "ordered"; } else if(reliability == "batch") { p->obj = p->obj->ice_batchOneway(); } else //if(reliability == "oneway") { p->obj = p->obj->ice_oneway(); } topic->subscribeAndGetPublisher(qos, p->obj); } } { for(vector<Subscription>::iterator p = subs.begin(); p != subs.end(); ++p) { p->adapter->activate(); } } communicator->waitForShutdown(); { for(vector<Subscription>::const_iterator p = subs.begin(); p != subs.end(); ++p) { topic->unsubscribe(p->obj); if(p->servant->count() != events) { cerr << "expected " << events << " events but got " << p->servant->count() << " events." << endl; return EXIT_FAILURE; } } } return EXIT_SUCCESS; }
int compile(int argc, char* argv[]) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("", "header-ext", IceUtilInternal::Options::NeedArg, "h"); opts.addOpt("", "source-ext", IceUtilInternal::Options::NeedArg, "cpp"); opts.addOpt("", "add-header", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("E"); opts.addOpt("", "include-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "dll-export", IceUtilInternal::Options::NeedArg); opts.addOpt("", "impl"); opts.addOpt("", "depend"); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); opts.addOpt("", "checksum"); opts.addOpt("", "stream"); vector<string> args; try { args = opts.parse(argc, (const char**)argv); } catch(const IceUtilInternal::BadOptException& e) { getErrorStream() << argv[0] << ": " << e.reason << endl; usage(argv[0]); return EXIT_FAILURE; } if(opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } if(opts.isSet("version")) { getErrorStream() << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } string headerExtension = opts.optArg("header-ext"); string sourceExtension = opts.optArg("source-ext"); vector<string> extraHeaders = opts.argVec("add-header"); vector<string> cppArgs; vector<string> optargs = opts.argVec("D"); vector<string>::const_iterator i; for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } optargs = opts.argVec("U"); for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } vector<string> includePaths; includePaths = opts.argVec("I"); for(i = includePaths.begin(); i != includePaths.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } bool preprocess = opts.isSet("E"); string include = opts.optArg("include-dir"); string output = opts.optArg("output-dir"); string dllExport = opts.optArg("dll-export"); bool impl = opts.isSet("impl"); bool depend = opts.isSet("depend"); bool debug = opts.isSet("debug"); bool ice = opts.isSet("ice"); bool underscore = opts.isSet("underscore"); bool checksum = opts.isSet("checksum"); bool stream = opts.isSet("stream"); if(args.empty()) { getErrorStream() << argv[0] << ": error: no input file" << endl; usage(argv[0]); return EXIT_FAILURE; } int status = EXIT_SUCCESS; IceUtil::CtrlCHandler ctrlCHandler; ctrlCHandler.setCallback(interruptedCallback); for(i = args.begin(); i != args.end(); ++i) { // // Ignore duplicates. // vector<string>::iterator p = find(args.begin(), args.end(), *i); if(p != i) { continue; } if(depend) { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(false); if(cppHandle == 0) { return EXIT_FAILURE; } UnitPtr u = Unit::createUnit(false, false, ice, underscore); int parseStatus = u->parse(*i, cppHandle, debug); u->destroy(); if(parseStatus == EXIT_FAILURE) { return EXIT_FAILURE; } if(!icecpp->printMakefileDependencies(Preprocessor::CPlusPlus, includePaths, sourceExtension)) { return EXIT_FAILURE; } if(!icecpp->close()) { return EXIT_FAILURE; } } else { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(false); if(cppHandle == 0) { return EXIT_FAILURE; } if(preprocess) { char buf[4096]; while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL) { if(fputs(buf, stdout) == EOF) { return EXIT_FAILURE; } } if(!icecpp->close()) { return EXIT_FAILURE; } } else { UnitPtr u = Unit::createUnit(false, false, ice, underscore); int parseStatus = u->parse(*i, cppHandle, debug); if(!icecpp->close()) { u->destroy(); return EXIT_FAILURE; } if(parseStatus == EXIT_FAILURE) { status = EXIT_FAILURE; } else { try { Gen gen(icecpp->getBaseName(), headerExtension, sourceExtension, extraHeaders, include, includePaths, dllExport, output, impl, checksum, stream, ice); gen.generate(u); } catch(const Slice::FileException& ex) { // If a file could not be created, then // cleanup any created files. FileTracker::instance()->cleanup(); u->destroy(); getErrorStream() << argv[0] << ": error: " << ex.reason() << endl; return EXIT_FAILURE; } } u->destroy(); } } { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(mutex); if(interrupted) { FileTracker::instance()->cleanup(); return EXIT_FAILURE; } } } return status; }
int compile(const vector<string>& argv) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("", "validate"); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("E"); opts.addOpt("", "stdout"); opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "depend"); opts.addOpt("", "depend-json"); opts.addOpt("", "depend-xml"); opts.addOpt("", "depend-file", IceUtilInternal::Options::NeedArg, ""); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); bool validate = find(argv.begin(), argv.end(), "--validate") != argv.end(); vector<string> args; try { args = opts.parse(argv); } catch(const IceUtilInternal::BadOptException& e) { consoleErr << argv[0] << ": error: " << e.reason << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } if(opts.isSet("version")) { consoleErr << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } vector<string> cppArgs; vector<string> optargs = opts.argVec("D"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } optargs = opts.argVec("U"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } vector<string> includePaths = opts.argVec("I"); for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } bool preprocess = opts.isSet("E"); bool useStdout = opts.isSet("stdout"); string output = opts.optArg("output-dir"); bool depend = opts.isSet("depend"); bool dependJSON = opts.isSet("depend-json"); bool dependxml = opts.isSet("depend-xml"); string dependFile = opts.optArg("depend-file"); bool debug = opts.isSet("debug"); bool ice = opts.isSet("ice"); bool underscore = opts.isSet("underscore"); if(args.empty()) { consoleErr << argv[0] << ": error: no input file" << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(depend && dependJSON) { consoleErr << argv[0] << ": error: cannot specify both --depend and --depend-json" << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(depend && dependxml) { consoleErr << argv[0] << ": error: cannot specify both --depend and --depend-xml" << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(dependxml && dependJSON) { consoleErr << argv[0] << ": error: cannot specify both --depend-xml and --depend-json" << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(validate) { return EXIT_SUCCESS; } int status = EXIT_SUCCESS; IceUtil::CtrlCHandler ctrlCHandler; ctrlCHandler.setCallback(interruptedCallback); ostringstream os; if(dependJSON) { os << "{" << endl; } else if(dependxml) { os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<dependencies>" << endl; } // // Create a copy of args without the duplicates. // vector<string> sources; for(vector<string>::const_iterator i = args.begin(); i != args.end(); ++i) { vector<string>::iterator p = find(sources.begin(), sources.end(), *i); if(p == sources.end()) { sources.push_back(*i); } } for(vector<string>::const_iterator i = sources.begin(); i != sources.end();) { if(depend || dependJSON || dependxml) { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(false, "-D__SLICE2JS__"); if(cppHandle == 0) { return EXIT_FAILURE; } UnitPtr u = Unit::createUnit(false, false, ice, underscore); int parseStatus = u->parse(*i, cppHandle, debug); u->destroy(); if(parseStatus == EXIT_FAILURE) { return EXIT_FAILURE; } bool last = (++i == sources.end()); if(!icecpp->printMakefileDependencies(os, depend ? Preprocessor::JavaScript : (dependJSON ? Preprocessor::JavaScriptJSON : Preprocessor::SliceXML), includePaths, "-D__SLICE2JS__")) { return EXIT_FAILURE; } if(!icecpp->close()) { return EXIT_FAILURE; } if(dependJSON) { if(!last) { os << ","; } os << "\n"; } } else { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(true, "-D__SLICE2JS__"); if(cppHandle == 0) { return EXIT_FAILURE; } if(preprocess) { char buf[4096]; while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != ICE_NULLPTR) { if(fputs(buf, stdout) == EOF) { return EXIT_FAILURE; } } if(!icecpp->close()) { return EXIT_FAILURE; } } else { UnitPtr p = Unit::createUnit(false, false, ice, underscore); int parseStatus = p->parse(*i, cppHandle, debug); if(!icecpp->close()) { p->destroy(); return EXIT_FAILURE; } if(parseStatus == EXIT_FAILURE) { status = EXIT_FAILURE; } else { try { if(useStdout) { Gen gen(icecpp->getBaseName(), includePaths, output, cout); gen.generate(p); } else { Gen gen(icecpp->getBaseName(), includePaths, output); gen.generate(p); } } catch(const Slice::FileException& ex) { // // If a file could not be created, then clean up any created files. // FileTracker::instance()->cleanup(); p->destroy(); consoleErr << argv[0] << ": error: " << ex.reason() << endl; return EXIT_FAILURE; } } p->destroy(); } ++i; } { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(globalMutex); if(interrupted) { FileTracker::instance()->cleanup(); return EXIT_FAILURE; } } } if(dependJSON) { os << "}\n"; } else if(dependxml) { os << "</dependencies>\n"; } if(depend || dependJSON || dependxml) { writeDependencies(os.str(), dependFile); } return status; }
int main(int argc, char* argv[]) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("", "header-ext", IceUtilInternal::Options::NeedArg, "h"); opts.addOpt("", "source-ext", IceUtilInternal::Options::NeedArg, "cpp"); opts.addOpt("", "add-header", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("E"); opts.addOpt("", "include-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "dll-export", IceUtilInternal::Options::NeedArg); opts.addOpt("", "impl"); opts.addOpt("", "depend"); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "checksum"); opts.addOpt("", "stream"); opts.addOpt("", "case-sensitive"); // alexm: our custom options opts.addOpt("", "module", IceUtilInternal::Options::NeedArg); opts.addOpt("", "util"); opts.addOpt("", "log"); vector<string> args; try { args = opts.parse(argc, (const char**)argv); } catch(const IceUtilInternal::BadOptException& e) { cerr << argv[0] << ": " << e.reason << endl; usage(argv[0]); return EXIT_FAILURE; } if(opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } if(opts.isSet("version")) { cout << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } string headerExtension = opts.optArg("header-ext"); string sourceExtension = opts.optArg("source-ext"); vector<string> extraHeaders = opts.argVec("add-header"); vector<string> cppArgs; vector<string> optargs = opts.argVec("D"); vector<string>::const_iterator i; for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } optargs = opts.argVec("U"); for(i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } vector<string> includePaths; includePaths = opts.argVec("I"); for(i = includePaths.begin(); i != includePaths.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } // bool preprocess = opts.isSet("E"); string include = opts.optArg("include-dir"); string output = opts.optArg("output-dir"); string dllExport = opts.optArg("dll-export"); bool impl = opts.isSet("impl"); bool depend = opts.isSet("depend"); bool debug = opts.isSet("debug"); bool ice = opts.isSet("ice"); bool checksum = opts.isSet("checksum"); bool stream = opts.isSet("stream"); bool caseSensitive = opts.isSet("case-sensitive"); // alexm: custom options string module = opts.optArg("module"); bool genUtil = opts.isSet("util"); bool genLog = opts.isSet("log"); if ( !depend && !genUtil && !genLog ) { cerr << argv[0] << ": no output type specified" << endl; usage(argv[0]); return EXIT_FAILURE; } if ( genUtil && genLog ) { cerr << argv[0] << ": more than one output type specified" << endl; usage(argv[0]); return EXIT_FAILURE; } // alexm: end custom options if(args.empty()) { cerr << argv[0] << ": no input file" << endl; usage(argv[0]); return EXIT_FAILURE; } int status = EXIT_SUCCESS; for(i = args.begin(); i != args.end(); ++i) { if(depend) { Preprocessor icecpp(argv[0], *i, cppArgs); icecpp.printMakefileDependencies(Preprocessor::CPlusPlus, includePaths); } else { Preprocessor icecpp(argv[0], *i, cppArgs); FILE* cppHandle = icecpp.preprocess(false); if(cppHandle == 0) { return EXIT_FAILURE; } UnitPtr u = Unit::createUnit(false, false, ice, caseSensitive); int parseStatus = u->parse(*i, cppHandle, debug); if(!icecpp.close()) { u->destroy(); return EXIT_FAILURE; } if(parseStatus == EXIT_FAILURE) { status = EXIT_FAILURE; } else { slice2orca::Gen gen(argv[0], icecpp.getBaseName(), headerExtension, sourceExtension, extraHeaders, include, includePaths, dllExport, output, impl, checksum, stream, ice, module, genUtil, genLog ); if(!gen) { u->destroy(); return EXIT_FAILURE; } gen.generate(u); } u->destroy(); } } return status; }
int compile(int argc, char* argv[]) { IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("", "validate"); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("E"); opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg); opts.addOpt("", "tie"); opts.addOpt("", "impl"); opts.addOpt("", "impl-tie"); opts.addOpt("", "depend"); opts.addOpt("", "depend-xml"); opts.addOpt("", "depend-file", IceUtilInternal::Options::NeedArg, ""); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); opts.addOpt("", "checksum"); bool validate = false; for(int i = 0; i < argc; ++i) { if(string(argv[i]) == "--validate") { validate = true; break; } } vector<string> args; try { args = opts.parse(argc, const_cast<const char**>(argv)); } catch(const IceUtilInternal::BadOptException& e) { getErrorStream() << argv[0] << ": error: " << e.reason << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(opts.isSet("help")) { usage(argv[0]); return EXIT_SUCCESS; } if(opts.isSet("version")) { getErrorStream() << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } vector<string> cppArgs; vector<string> optargs = opts.argVec("D"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } optargs = opts.argVec("U"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } vector<string> includePaths = opts.argVec("I"); for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i) { cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i)); } bool preprocess = opts.isSet("E"); string output = opts.optArg("output-dir"); bool tie = opts.isSet("tie"); bool impl = opts.isSet("impl"); bool implTie = opts.isSet("impl-tie"); bool depend = opts.isSet("depend"); bool dependxml = opts.isSet("depend-xml"); string dependFile = opts.optArg("depend-file"); bool debug = opts.isSet("debug"); bool ice = opts.isSet("ice"); bool underscore = opts.isSet("underscore"); bool checksum = opts.isSet("checksum"); if(args.empty()) { getErrorStream() << argv[0] << ": error: no input file" << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(impl && implTie) { getErrorStream() << argv[0] << ": error: cannot specify both --impl and --impl-tie" << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(depend && dependxml) { getErrorStream() << argv[0] << ": error: cannot specify both --depend and --depend-xml" << endl; if(!validate) { usage(argv[0]); } return EXIT_FAILURE; } if(validate) { return EXIT_SUCCESS; } int status = EXIT_SUCCESS; IceUtil::CtrlCHandler ctrlCHandler; ctrlCHandler.setCallback(interruptedCallback); DependOutputUtil out(dependFile); if(dependxml) { out.os() << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<dependencies>" << endl; } for(vector<string>::const_iterator i = args.begin(); i != args.end(); ++i) { // // Ignore duplicates. // vector<string>::iterator p = find(args.begin(), args.end(), *i); if(p != i) { continue; } if(depend || dependxml) { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(false, "-D__SLICE2CS__"); if(cppHandle == 0) { out.cleanup(); return EXIT_FAILURE; } UnitPtr u = Unit::createUnit(false, false, ice, underscore); int parseStatus = u->parse(*i, cppHandle, debug); u->destroy(); if(parseStatus == EXIT_FAILURE) { out.cleanup(); return EXIT_FAILURE; } if(!icecpp->printMakefileDependencies(out.os(), depend ? Preprocessor::CSharp : Preprocessor::SliceXML, includePaths, "-D__SLICE2CS__")) { out.cleanup(); return EXIT_FAILURE; } if(!icecpp->close()) { out.cleanup(); return EXIT_FAILURE; } } else { PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs); FILE* cppHandle = icecpp->preprocess(true, "-D__SLICE2CS__"); if(cppHandle == 0) { return EXIT_FAILURE; } if(preprocess) { char buf[4096]; while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL) { if(fputs(buf, stdout) == EOF) { return EXIT_FAILURE; } } if(!icecpp->close()) { return EXIT_FAILURE; } } else { UnitPtr p = Unit::createUnit(false, false, ice, underscore); int parseStatus = p->parse(*i, cppHandle, debug); if(!icecpp->close()) { p->destroy(); return EXIT_FAILURE; } if(parseStatus == EXIT_FAILURE) { status = EXIT_FAILURE; } else { try { Gen gen(icecpp->getBaseName(), includePaths, output, impl, implTie); gen.generate(p); if(tie) { gen.generateTie(p); } if(impl) { gen.generateImpl(p); } if(implTie) { gen.generateImplTie(p); } if(checksum) { gen.generateChecksums(p); } } catch(const Slice::FileException& ex) { // If a file could not be created, then // cleanup any created files. FileTracker::instance()->cleanup(); p->destroy(); getErrorStream() << argv[0] << ": error: " << ex.reason() << endl; return EXIT_FAILURE; } } p->destroy(); } } { IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(globalMutex); if(interrupted) { out.cleanup(); FileTracker::instance()->cleanup(); return EXIT_FAILURE; } } } if(dependxml) { out.os() << "</dependencies>\n"; } return status; }