void convert(const Common::UString &inFile, const Common::UString &outFile,
Aurora::FileType type, bool flip) {
Common::ReadFile in(inFile);
if (type == Aurora::kFileTypeNone) {
// Detect by file contents
type = detectType(in);
if (type == Aurora::kFileTypeNone) {
// Detect by file name
type = detectType(inFile);
if (type == Aurora::kFileTypeNone)
throw Common::Exception("Failed to detect type of file \"%s\"", inFile.c_str());
}
}
Images::Decoder *image = openImage(in, type);
if (flip)
image->flipVertically();
try {
image->dumpTGA(outFile);
} catch (...) {
delete image;
throw;
}
delete image;
}
bool PluginProcess::Start()
{
// construction de la commande en fonction du type de binaire
QString command(_absExecDir);
// on ajoute le nom du binaire à la fin
command.append('/').append(_calculation->GetBin());
// en fonction du type on effectue des opérations supplémentaires
bool ok = true;
switch (detectType()) {
case BINARY:
break;
case JAR:
command.prepend("java -jar ");
break;
case SCRIPT:
if(! selectInterpreter().isNull() )
{ command.prepend(selectInterpreter()).prepend(" ");
}
else
{ ok = false;
}
break;
}
// -- démarrage du plugin
if(ok)
{ // on exécute la commande trimmée pour éviter les espaces traitres
start(command.trimmed());
}
// -- retour du statut
return ok;
}
SimpleAutomatonTokenizer::Token SimpleAutomatonTokenizer::emitToken() {
while (!eof()) {
size_t startLine = line();
size_t startColumn = column();
const char* c = curPos();
switch (*c) {
case '{':
discardUntil("}");
break;
case ',':
advance();
return Token(SimpleAutomatonToken::Comma, c, c+1, offset(c), startLine, startColumn);
case ';':
advance();
return Token(SimpleAutomatonToken::Semicolon, c, c+1, offset(c), startLine, startColumn);
case ' ':
case '\t':
case '\n':
case '\r':
discardWhile(Whitespace);
break;
default: {
const char* e = readString(Whitespace + ";,:");
if (e == NULL)
throw ParserException(startLine, startColumn, "Unexpected character: " + String(c, 1));
return Token(detectType(c, e), c, e, offset(c), startLine, startColumn);
}
}
}
return Token(SimpleAutomatonToken::Eof, NULL, NULL, length(), line(), column());
}
bool FilesPageHandler::listDirectory(Common::String path, Common::String &content, const Common::String &itemTemplate) {
if (path == "" || path == "/") {
if (ConfMan.hasKey("rootpath", "cloud"))
addItem(content, itemTemplate, IT_DIRECTORY, "/root/", _("File system root"));
addItem(content, itemTemplate, IT_DIRECTORY, "/saves/", _("Saved games"));
return true;
}
if (HandlerUtils::hasForbiddenCombinations(path))
return false;
Common::String prefixToRemove = "", prefixToAdd = "";
if (!transformPath(path, prefixToRemove, prefixToAdd))
return false;
Common::FSNode node = Common::FSNode(path);
if (path == "/")
node = node.getParent(); // absolute root
if (!HandlerUtils::permittedPath(node.getPath()))
return false;
if (!node.isDirectory())
return false;
// list directory
Common::FSList _nodeContent;
if (!node.getChildren(_nodeContent, Common::FSNode::kListAll, false)) // do not show hidden files
_nodeContent.clear();
else
Common::sort(_nodeContent.begin(), _nodeContent.end());
// add parent directory link
{
Common::String filePath = path;
if (filePath.hasPrefix(prefixToRemove))
filePath.erase(0, prefixToRemove.size());
if (filePath == "" || filePath == "/" || filePath == "\\")
filePath = "/";
else
filePath = parentPath(prefixToAdd + filePath);
addItem(content, itemTemplate, IT_PARENT_DIRECTORY, filePath, _("Parent directory"));
}
// fill the content
for (Common::FSList::iterator i = _nodeContent.begin(); i != _nodeContent.end(); ++i) {
Common::String name = i->getDisplayName();
if (i->isDirectory())
name += "/";
Common::String filePath = i->getPath();
if (filePath.hasPrefix(prefixToRemove))
filePath.erase(0, prefixToRemove.size());
filePath = prefixToAdd + filePath;
addItem(content, itemTemplate, detectType(i->isDirectory(), name), filePath, name);
}
return true;
}
void Diamond::detectAtomTypes()
{
eachAtom([this](Atom *atom) {
if (atom->type() == NO_VALUE)
{
ushort type = detectType(atom);
atom->changeType(type);
}
});
}
std::string solve_81b(const std::string str)
{
size_t sz = str.size();
std::ostringstream result;
std::string elem;
std::vector<std::string> parsed_elems;
std::vector<int> parsed_elems_types;
int type = NOT_STARTED;
for (size_t i = 0; i < sz; i++)
{
if (type == NOT_STARTED)
{
type = detectType(str[i]);
}
if (type == NUMBER)
{
if (isNumber(str[i]))
{
elem.push_back(str[i]);
continue;
} else
{
parsed_elems.push_back(elem);
parsed_elems_types.push_back(type);
type = NOT_STARTED;
elem.clear();
i--;
continue;
}
}
if (type == SPACE)
{
if (str[i] == ' ')
{
elem.push_back(str[i]);
continue;
} else
{
parsed_elems.push_back(elem);
parsed_elems_types.push_back(type);
type = NOT_STARTED;
elem.clear();
i--;
continue;
}
}
if (type == ELIPS)
{
if (str[i] == '.')
{
if (elem.size() == 3)
{
parsed_elems.push_back(elem);
parsed_elems_types.push_back(type);
elem.clear();
}
elem.push_back(str[i]);
continue;
} else
{
parsed_elems.push_back(elem);
parsed_elems_types.push_back(type);
type = NOT_STARTED;
elem.clear();
i--;
continue;
}
}
if (type == COMMA)
{
parsed_elems.push_back(",");
parsed_elems_types.push_back(type);
elem.clear();
type = NOT_STARTED;
continue;
}
}
if (type != NOT_STARTED)
{
parsed_elems.push_back(elem);
parsed_elems_types.push_back(type);
elem.clear();
}
sz = parsed_elems.size();
for (size_t i = 0; i < sz; i++)
{
if (parsed_elems_types[i] == SPACE)
{
parsed_elems_types.erase(parsed_elems_types.begin() + i);
parsed_elems.erase(parsed_elems.begin() + i);
i--; sz--;
}
}
for (size_t i = 0; i < sz; i++)
{
if (parsed_elems_types[i] == COMMA)
{
result << parsed_elems[i];
if (i < (sz - 1))
result << " ";
} else
if (parsed_elems_types[i] == ELIPS)
{
if (i > 0 && parsed_elems_types[i-1] != COMMA)
result << " ";
result << parsed_elems[i];
} else
{
result << parsed_elems[i];
if (i < (sz - 1) && parsed_elems_types[i+1] == NUMBER)
result << " ";
}
}
return result.str();
}
