void recall::apply_temp_modifier(unit_map& unit_map)
{
assert(valid());
temp_unit_->set_location(recall_hex_);
DBG_WB << "Inserting future recall " << temp_unit_->name() << " [" << temp_unit_->id()
<< "] at position " << temp_unit_->get_location() << ".\n";
//temporarily remove unit from recall list
UnitPtr it = resources::teams->at(team_index()).recall_list().extract_if_matches_id(temp_unit_->id());
assert(it);
//Add cost to money spent on recruits.
int cost = resources::teams->at(team_index()).recall_cost();
if (it->recall_cost() > -1) {
cost = it->recall_cost();
}
// Temporarily insert unit into unit_map
//unit map takes ownership of temp_unit
unit_map.insert(temp_unit_);
resources::teams->at(team_index()).get_side_actions()->change_gold_spent_by(cost);
// Update gold in top bar
resources::screen->invalidate_game_status();
}
void dlgUnitEditor::on_buttonBox_accepted()
{
UnitPtr unit = qSharedPointerDynamicCast<Unit>(_entity);
unit->setName(ui->txtNombre->text());
unit->setDescripcion(ui->txtDescripcion->text());
close();
}
dlgUnitEditor::dlgUnitEditor(UnitsModel *model, int selectedEntity, QWidget *parent) :
QDialog(parent),
ui(new Ui::dlgUnitEditor)
{
_model = model;
ui->setupUi(this);
_entity = model->getItemByRowid(selectedEntity);
UnitPtr unit = qSharedPointerDynamicCast<Unit>(_entity);
ui->txtNombre->setText(unit->name());
ui->txtDescripcion->setText(unit->description());
}
UnitPtr Restorer::ExtractUnitFromLine(string & str) {
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep("\t");
tokenizer tokens(str, sep);
int size = 0;
for (tokenizer::iterator tit = tokens.begin(); tit != tokens.end(); ++tit) {
++size;
}
if (size < 6) {//至少有六段
MCE_INFO("Restorer::ExtractUnitFromLine. wrong size:" << size << " str:" << str);
return NULL;
}
tokenizer::iterator itr = tokens.begin();
++itr;
Ice::Long id = lexical_cast<Ice::Long> (*itr++);
set<Ice::Long>::iterator it = outtag_ids_.find(id);
if (it != outtag_ids_.end()) {
MCE_INFO("Restorer::ExtractUnitFromLine. matched. id:" << id);
return NULL;
}
// if (it != outtag_ids_.end()) {
// --(it->second);
// if (it->second == 0) {
// outtag_ids_.erase(it);
// }
// MCE_INFO("Restorer::ExtractUnitFromLine. matched. id:" << id);
// return NULL;
// }
int retry = lexical_cast<int> (*itr++);
string instance = lexical_cast<string> (*itr++);
int wrflag = lexical_cast<int> (*itr++);
string pattern = lexical_cast<string> (*itr++);
string statement;
for (; itr != tokens.end(); ++itr) {
statement += lexical_cast<string> (*itr);
statement += "\t";
}
UnitPtr unit = new Unit(id, retry + 1, instance, wrflag, pattern, statement);
if (retry > MAX_RETRY) {
MCE_INFO("Restorer::ExtractUnitFromLine. retry exceed max_retry. " << unit->DumpToString());
return NULL;
}
return unit;
}
bool Section::IsOutOfBoundary(const UnitPtr& unit, OUT Direction& dir)
{
auto x = unit->GetPos().GetX();
auto y = unit->GetPos().GetY();
if (x < m_Boundary.left)
{
dir = Direction::LEFT;
return true;
}
if (y < m_Boundary.top)
{
dir = Direction::TOP;
return true;
}
if (x > m_Boundary.right)
{
dir = Direction::RIGHT;
return true;
}
if (y > m_Boundary.bottom)
{
dir = Direction::BOTTOM;
return true;
}
return false;
}
void
FreezeScript::collectCompactIds(const UnitPtr& u, const FreezeScript::CompactIdResolverIPtr& r)
{
class Visitor : public ParserVisitor
{
public:
Visitor(const FreezeScript::CompactIdResolverIPtr& resolver) : _r(resolver)
{
}
virtual bool visitClassDefStart(const ClassDefPtr& p)
{
if(p->compactId() != -1)
{
_r->add(p->compactId(), p->scoped());
}
return true;
}
FreezeScript::CompactIdResolverIPtr _r;
};
Visitor v(r);
u->visit(&v, false);
}
void
PackageVisitor::createModules(const UnitPtr& unit, const string& module, const string& dir)
{
StringList modules;
PackageVisitor v(modules);
unit->visit(&v, false);
for(StringList::iterator p = modules.begin(); p != modules.end(); ++p)
{
vector<string> v;
if(!IceUtilInternal::splitString(*p, ".", v))
{
assert(false);
}
string currentModule;
string path = dir.empty() ? "." : dir;
for(vector<string>::iterator q = v.begin(); q != v.end(); ++q)
{
if(q != v.begin())
{
addSubmodule(path, currentModule, *q);
currentModule += ".";
}
currentModule += *q;
path += "/" + *q;
createDirectory(path);
addModule(path, currentModule, module);
}
}
}
void
Slice::Ruby::generate(const UnitPtr& un, bool all, bool checksum, const vector<string>& includePaths, Output& out)
{
out << nl << "require 'Ice'";
if(!all)
{
vector<string> paths = includePaths;
for(vector<string>::iterator p = paths.begin(); p != paths.end(); ++p)
{
*p = fullPath(*p);
}
StringList includes = un->includeFiles();
for(StringList::const_iterator q = includes.begin(); q != includes.end(); ++q)
{
string file = changeInclude(*q, paths);
out << nl << "require '" << file << ".rb'";
}
}
CodeVisitor codeVisitor(out);
un->visit(&codeVisitor, false);
if(checksum)
{
ChecksumMap checksums = createChecksums(un);
if(!checksums.empty())
{
out << sp;
for(ChecksumMap::const_iterator p = checksums.begin(); p != checksums.end(); ++p)
{
out << nl << "::Ice::SliceChecksums[\"" << p->first << "\"] = \"";
ostringstream str;
str.flags(ios_base::hex);
str.fill('0');
for(vector<unsigned char>::const_iterator q = p->second.begin(); q != p->second.end(); ++q)
{
str << (int)(*q);
}
out << str.str() << "\"";
}
}
}
out << nl; // Trailing newline.
}
bool
Slice::ObjCGenerator::MetaDataVisitor::visitUnitStart(const UnitPtr& p)
{
//
// Validate global metadata in the top-level file and all included files.
//
StringList files = p->allFiles();
for(StringList::iterator q = files.begin(); q != files.end(); ++q)
{
string file = *q;
DefinitionContextPtr dc = p->findDefinitionContext(file);
assert(dc);
StringList globalMetaData = dc->getMetaData();
int headerDir = 0;
for(StringList::const_iterator r = globalMetaData.begin(); r != globalMetaData.end(); ++r)
{
string s = *r;
if(_history.count(s) == 0)
{
if(s.find(_objcPrefix) == 0)
{
static const string objcHeaderDirPrefix = "objc:header-dir:";
if(s.find(objcHeaderDirPrefix) == 0 && s.size() > objcHeaderDirPrefix.size())
{
headerDir++;
if(headerDir > 1)
{
ostringstream ostr;
ostr << "ignoring invalid global metadata `" << s
<< "': directive can appear only once per file";
emitWarning(file, -1, ostr.str());
_history.insert(s);
}
continue;
}
ostringstream ostr;
ostr << "ignoring invalid global metadata `" << s << "'";
emitWarning(file, -1, ostr.str());
}
_history.insert(s);
}
}
}
return true;
}
void Section::UnRegisterUnit(const UnitPtr& unit)
{
unit->SetSection(nullptr);
m_UnitList.remove_if([&unit](auto& target)
{
return target.lock() == unit;
});
}
Slice::ChecksumMap Slice::createChecksums(const UnitPtr& u)
{
ChecksumMap result;
ChecksumVisitor visitor(result);
u->visit(&visitor, false);
return result;
}
void SqlQueue::Push(const UnitPtr& unit) {
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
q_.push(unit);
notify();
}
MCE_INFO(unit->MakeInLog());
manager_->Update(1);
return;
}
void SqlQueue::Execute(const UnitPtr& unit) {
// return;//TODO del
Statement st;
st << unit->statement_;
try {
MCE_INFO(unit->MakeOutLog());
// QueryRunner(unit->info_->instance, unit->info_->wrflag,
// unit->info_->pattern).store(st);
usleep(7000);//db平均为7毫秒
// sleep(10000);
} catch (Ice::Exception& e) {
MCE_WARN("SqlQueue::Execute --> error:" << e);
} catch (std::exception& e) {
MCE_WARN("SqlQueue::Execute --> error:" << e.what());
}
}
bool Section::RegisterUnit(const UnitPtr& unit)
{
if (unit == nullptr)
return false;
Direction dir;
if (IsOutOfBoundary(unit, dir))
{
// 유닛이 바운더리 바깥이면 해당 방향의 섹션에 등록을 시도한다.
return RegisterUnit(unit, dir);
}
// 유닛 리스트에 등록하고, 유닛에게 등록된 섹션을 알려준다.
// 섹션끼리는 weak_ptr만 들고있기 때문에, 여기서 유닛에게 보관시키는
// shared_ptr이 유효 카운트이다.
// 즉, 이 섹션에 포함된 유닛이 0이 될때, 자동으로 이 섹션도 파괴된다.
m_UnitList.push_back(unit);
unit->SetSection(shared_from_this());
return true;
}
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
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;
}
void
Slice::ObjCGenerator::validateMetaData(const UnitPtr& u)
{
MetaDataVisitor visitor;
u->visit(&visitor, true);
}
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
main(int argc, char* argv[])
{
string cppArgs;
vector<string> includePaths;
string output;
bool debug = false;
bool ice = false;
bool caseSensitive = false;
int idx = 1;
while(idx < argc)
{
if(strncmp(argv[idx], "-I", 2) == 0)
{
cppArgs += ' ';
cppArgs += argv[idx];
string path = argv[idx] + 2;
if (path.length())
includePaths.push_back(path);
for(int i = idx ; i + 1 < argc ; ++i)
{
argv[i] = argv[i + 1];
}
--argc;
}
else if(strncmp(argv[idx], "-D", 2) == 0 || strncmp(argv[idx], "-U", 2) == 0)
{
cppArgs += ' ';
cppArgs += argv[idx];
for(int i = idx ; i + 1 < argc ; ++i)
{
argv[i] = argv[i + 1];
}
--argc;
}
else if(strcmp(argv[idx], "-h") == 0 || strcmp(argv[idx], "--help") == 0)
{
usage(argv[0]);
return EXIT_SUCCESS;
}
else if(strcmp(argv[idx], "-v") == 0 || strcmp(argv[idx], "--version") == 0)
{
cout << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
else if(strcmp(argv[idx], "-d") == 0 || strcmp(argv[idx], "--debug") == 0)
{
debug = true;
for(int i = idx ; i + 1 < argc ; ++i)
{
argv[i] = argv[i + 1];
}
--argc;
}
else if(strcmp(argv[idx], "--ice") == 0)
{
ice = true;
for(int i = idx ; i + 1 < argc ; ++i)
{
argv[i] = argv[i + 1];
}
--argc;
}
else if(strcmp(argv[idx], "--case-sensitive") == 0)
{
caseSensitive = true;
for(int i = idx ; i + 1 < argc ; ++i)
{
argv[i] = argv[i + 1];
}
--argc;
}
else if(strcmp(argv[idx], "--output-dir") == 0)
{
if(idx + 1 >= argc)
{
cerr << argv[0] << ": argument expected for`" << argv[idx] << "'" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
output = argv[idx + 1];
for(int i = idx ; i + 2 < argc ; ++i)
{
argv[i] = argv[i + 2];
}
argc -= 2;
}
else if(argv[idx][0] == '-')
{
cerr << argv[0] << ": unknown option `" << argv[idx] << "'" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
else
{
++idx;
}
}
if(argc < 2)
{
cerr << argv[0] << ": no input file" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
UnitPtr p = Unit::createUnit(true, false, ice, caseSensitive);
int status = EXIT_SUCCESS;
for(idx = 1 ; idx < argc ; ++idx)
{
Preprocessor icecpp(argv[0], argv[idx], cppArgs);
FILE* cppHandle = icecpp.preprocess(false);
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
UnitPtr u = Unit::createUnit(false, false, ice, caseSensitive);
int parseStatus = u->parse(cppHandle, debug);
if(!icecpp.close())
{
u->destroy();
return EXIT_FAILURE;
}
if(parseStatus == EXIT_FAILURE)
{
status = EXIT_FAILURE;
}
else
{
Gen gen(argv[0], icecpp.getBaseName(), output);
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("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;
}
bool find_if_matches_helper(const UnitPtr & ptr, const std::string & unit_id)
{
return ptr->matches_id(unit_id);
}
bool find_if_matches_uid_helper(const UnitPtr & ptr, size_t uid)
{
return ptr->underlying_id() == uid;
}
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
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;
}
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
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
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(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;
}
