bool X86RTLGenerator::parseInsn(x86_insn_t &aInsn, RTLOp &aRTLOp)
{
size_t uOpCount = x86_operand_count(&aInsn, op_explicit);
unsigned uExpectedOpCount = 0xFFFFFFFF;
switch(aInsn.type)
{
case insn_add:
aRTLOp.setType(RTLOp::OP_ADD);
uExpectedOpCount = 2;
break;
case insn_call:
aRTLOp.setType(RTLOp::OP_CALL);
break;
case insn_jcc:
aRTLOp.setType(RTLOp::OP_JUMP);
break;
case insn_jmp:
aRTLOp.setType(RTLOp::OP_JUMP);
break;
case insn_mov:
aRTLOp.setType(RTLOp::OP_ASSIGN);
break;
case insn_return:
aRTLOp.setType(RTLOp::OP_RETURN);
break;
case insn_sub:
aRTLOp.setType(RTLOp::OP_SUBTRACT);
break;
case insn_test:
aRTLOp.setType(RTLOp::OP_COMPARE);
break;
case insn_push:
case insn_pop:
aRTLOp.setType(RTLOp::OP_NOP);
break;
default:
return false;
}
if((uOpCount >= 1) && (!parseArgument(x86_operand_1st(&aInsn), aRTLOp.getArg1())))
{
return false;
}
if((uOpCount >= 2) && (!parseArgument(x86_operand_2nd(&aInsn), aRTLOp.getArg2())))
{
return false;
}
if((uOpCount >= 3) && (!parseArgument(x86_operand_3rd(&aInsn), aRTLOp.getArg3())))
{
return false;
}
return true;
}
ff::Signature ff::SignatureParser::parse2(const std::string &str, std::string::size_type pos)
{
Signature sign;
string::size_type rpos, lpos;
if ((rpos = str.rfind(')', pos)) == string::npos) {
return sign;
}
if ((lpos = str.find('(')) == string::npos) {
return sign;
}
sign.arg_list = parseArgument(str, lpos, rpos);
{// return type
string rt = cc::trim(str.substr(pos + 2));
sign.return_type = rt.empty() ? ReturnType(ff::T_Any) : ReturnType(rt);
}
{// function name
string fn = cc::trim(str.substr(0, lpos));
sign.func_name = fn.empty() ? FuncName(ff::T_Any) : FuncName(fn);
}
return sign;
}
std::map<std::string, std::string> ArgParser::parse(int argc, const char ** argv, std::list<std::string> & rest)
{
std::map<std::string, std::string> paramsInString;
for(int i = 1; i < argc; i++)
{
int i_increase = 0;
std::string restArg = parseArgument(¶msInString, argc, argv, i, &i_increase);
if("" != restArg)
{
rest.push_back(restArg);
}
if(0 != i_increase)
{
i += i_increase;
}
}
addDefaultValues(¶msInString, _options_list);
addDefaultValues(¶msInString, _flags_list);
return paramsInString;
}
void
ChoiceFormat::parse(const UnicodeString& text,
Formattable& result,
ParsePosition& pos) const
{
result.setDouble(parseArgument(msgPattern, 0, text, pos));
}
int main(int argc, char *argv[])
{
int num[SIZE_INT];
int value = 0;
if(parseArgument(argc, argv, &value))
{
printf("Not a formatted number.\n"); /* Return error */
exit(-1);
}
printf("Value: %d\n", value); /* Printing value */
printf("Binary: ");
intToBinary(value, num);
printNumber(num);
printf("Comp1: ");
intToComp1(value, num);
printNumber(num);
printf("Comp2: ");
intToComp2(value, num);
printNumber(num);
return 0; /* Return success */
}
int main(int argc, char** argv)
{
aLog::init("c:\\file.log",aLog::MT_DEBUG);
printf("dwd1\n");
if(argc <=1)
{
showError("", invalid_usage);
return 1;
}
printf("dwd\n");
QStringList args;
fillArgsFromArgv(&args, argv, argc);
QString command = parseCommand(&args);
if(!isValidCommand(command))
{
showError(command, invalid_command);
return 1;
}
QString argument = parseArgument(&args);
if(!isValidArgument(argument))
{
showError(argument, invalid_argument);
return 2;
}
QStringList options;
parseOptions(&args, &options);
removeInvalidOptions(&options);
int res = doAction(command, argument, &options);
aLog::close();
return res;
}
void CommandInterpreter::printArguments(CommandInterpreter::Command *cmd, bool summary)
{
if (cmd->argumentCount() == 0) return;
Argument arg;
unsigned int count = cmd->argumentCount() - 1;
for (unsigned int i = 0; i <= count; ++i)
{
arg.name = cmd->argument(i);
arg.value.s = nullptr;
parseArgument(arg);
if (summary)
{
if (!arg.optional) printf("%s ", arg.name);
else printf("<%s> ", arg.name);
}
else
{
printf("%10s: %s", arg.name, arg.optional ? "optional " : "");
switch (arg.type)
{
case Argument::Type::String: printf("string\n"); break;
case Argument::Type::Int: printf("int\n"); break;
case Argument::Type::UnsignedInt: printf("unsigned int\n"); break;
case Argument::Type::Bool: printf("bool\n"); break;
case Argument::Type::Unknown: printf("unknown\n"); break;
}
}
}
}
//------------------------------------------------------------------------------
int LArguments::parseInternalArgument(LString argument) {
int ret;
ret = parseArgument(argument);
if(ret < 0) {
llog.log(LLog::error, LString("Unknown argument ") + argument);
}
return ret;
}
void CommandInterpreter::complete()
{
if (mFirstSpace == 0)
{
Possibilities possible;
findCommand(mLine, mLineLen, possible);
const char* useName = possible.string();
if (possible.count() == 1)
{
int useLen = strlen(useName);
strncpy(mLine + mLineLen, useName + mLineLen, useLen - mLineLen);
mLineLen = useLen;
mFirstSpace = mLineLen - 1;
printLine();
}
else if (possible.count() > 1)
{
std::printf("\n%s\n", useName);
printLine();
}
}
else
{
Possibilities possible;
Command* cmd = findCommand(mLine, mFirstSpace, possible);
if (cmd != nullptr)
{
unsigned int argc = findArguments(false);
if (argc >= 2)
{
Argument arg;
arg.name = cmd->argument(argc - 2);
arg.value.s = nullptr;
parseArgument(arg);
if (arg.enhancedType == Argument::EnhancedType::Address)
{
unsigned int i = mLineLen - 1;
bool hex = false;
while (i > 0 && mLine[i] != ' ')
{
if (mLine[i] == 'x' || mLine[i] == 'X')
{
hex = true;
break;
}
--i;
}
if (hex)
{
for (unsigned int j = mLineLen - i; j < 9; ++j) mLine[mLineLen++] = '0';
mLine[mLineLen++] = ' ';
printLine();
}
}
}
}
}
}
int main(int argc, char **argv) {
initializeDebug();
int i = 1;
while (i < argc) {
if (parseArgument(argv[i++]) == -1) exit(0);
}
initializeRegisters();
run(isTimerEnabled());
}
void CommandInterpreter::execute()
{
mLine[mLineLen] = 0;
addToHistory(mLine);
// first we split our line into seperate strings (by replacing whitespace with binary 0)
unsigned int argc = findArguments(true);
if (mArguments[0].value.s[0] == 0) return;
Possibilities possible;
Command* cmd = findCommand(mArguments[0].value.s, strlen(mArguments[0].value.s), possible);
if (cmd == nullptr)
{
printf("Unknown command: %s", mArguments[0].value.s);
// const char* p = mArguments[0].value.s;
// while (*p != 0)
// {
// printf(" %02x", *p++);
// }
printf(", try help.\n");
return;
}
unsigned int maxArgc = std::min(static_cast<unsigned int>(MAX_ARG_LEN), cmd->argumentCount() + 1);
unsigned int minArgc = 1;
bool failed = false;
// If everything is fine so far we parse our arguments and check if they are valid.
for (unsigned int i = 1; i < argc; ++i)
{
mArguments[i].name = cmd->argument(i - 1);
//printf("Parsing %s/%s: ", argv[i].name, argv[i].value.s);
if (!parseArgument(mArguments[i]))
{
failed = true;
break;
}
//printf("%u\n", argv[i].value.u);
if (!mArguments[i].optional) ++minArgc;
}
// If we fond a problem print a usage message.
if (failed || argc < minArgc || argc > maxArgc)
{
if (argc > maxArgc || argc < minArgc) printf("Wrong argument count (%i != [%i, %i]).\n", argc - 1, minArgc - 1, maxArgc - 1);
printUsage(cmd);
return;
}
// Everything is fine, execute it.
if (cmd != nullptr)
{
uint64_t start = System::instance()->ns();
cmd->execute(*this, argc, mArguments);
if (mCommandTime)
{
uint64_t delta = System::instance()->ns() - start;
printf("Command took %u.%06us\n", static_cast<unsigned int>(delta / 1000000000), static_cast<unsigned int>((delta / 1000) % 1000000));
}
}
}
bool Parser::Impl::parseArgumentList() {
// our ABNF:
// argument-list := *argument
while ( !atEnd() ) {
if ( !obtainToken() )
return false;
if ( !isArgumentToken() )
return true;
if ( !parseArgument() )
return !error();
}
return true;
}
/*===========================================================================*/
int CalibrationWithOpenShortParameter::parse( int argc, char** argv )
{
printf( "parsing command parameter\n" );
for( int i = 1; i < argc; i++ )
{
printf( "%d: [%s] ", i, argv[i] );
if(!parseArgument(argv[i]))
{
printf( "unknown parameter: %s\n", argv[i] );
return 0;
}
}
return check();
}
std::map<std::string, std::string> ArgParser::parse(int argc, const char ** argv)
{
std::map<std::string, std::string> paramsInString;
for(int i = 1; i < argc; i++)
{
int i_increase = 0;
parseArgument(¶msInString, argc, argv, i, &i_increase);
if(0 != i_increase)
{
i += i_increase;
}
}
addDefaultValues(¶msInString, _options_list);
addDefaultValues(¶msInString, _flags_list);
return paramsInString;
}
ff::Signature ff::SignatureParser::parse1(const std::string &str)
{
Signature sign;
string::size_type rpos, lpos;
if ((rpos = str.rfind(')')) == string::npos) {
return sign;
}
if ((lpos = str.find('(')) == string::npos) {
return sign;
}
sign.arg_list = parseArgument(str, lpos, rpos);
{// parse return and name
string rn = str.substr(0, lpos);
string::size_type space_pos = 0;
if ((space_pos = rn.rfind(' ')) == string::npos) {
sign.func_name = rn.empty() ? FuncName(ff::T_Any) : FuncName(rn);
} else {
string rnt = cc::trim(rn.substr(0, space_pos));
sign.return_type = rnt.empty() ? ReturnType(ff::T_Any) : ReturnType(rnt);
string fn = cc::trim(rn.substr(space_pos));
sign.func_name = fn.empty() ? FuncName(ff::T_Any) : FuncName(fn);
}
if (sign.return_type.name == string("void")) {
sign.return_type.type = ff::T_Void;
}
}
return sign;
}
/*===========================================================================*/
int UpdateFWParameter::parse( int argc, char** argv )
{
if ( argc <= 1 )
{
return 0;
}
printf( "parsing command parameter\n" );
for( int i = 1; i < argc; i++ )
{
printf( "%d: [%s] \n", i, argv[i] );
if(!parseArgument(argv[i]))
{
printf( "unknown parameter: %s\n", argv[i] );
return 0;
}
}
return check();
}
static void parseArguments(int argc, char **argv)
{
# define skipArg() (--argc, argv++)
# define saveArg() (vmArgVec[vmArgCnt++]= *skipArg())
saveArg(); /* vm name */
while ((argc > 0) && (**argv == '-')) /* more options to parse */
{
int n= 0;
if (!strcmp(*argv, "--"))
break; /* escape from option processing */
else
n= parseArgument(argc, argv);
if (n == 0) /* option not recognised */ {
fprintf(stderr, "unknown option: %s\n", argv[0]);
usage();
}
while (n--)
saveArg();
}
if (!argc)
return;
if (!strcmp(*argv, "--"))
skipArg();
else /* image name default to normal mac expectations */
resolveWhatTheImageNameIs(saveArg());
/* save remaining arguments as Squeak arguments */
while (argc > 0)
squeakArgVec[squeakArgCnt++]= *skipArg();
# undef saveArg
# undef skipArg
}
CodaClientApplication::ParseArgsResult CodaClientApplication::parseArguments(QString *errorMessage)
{
int argNumber = 1;
const QStringList args = QCoreApplication::arguments();
const QStringList::const_iterator cend = args.constEnd();
QStringList::const_iterator it = args.constBegin();
bool optionsEnd = false;
for (++it; it != cend; ++it) {
if (!optionsEnd && *it == QLatin1String("--")) {
optionsEnd = true;
continue;
}
if (!optionsEnd && it->startsWith(QLatin1Char('-')) && it->size() == 2) {
switch (it->at(1).toAscii()) {
case 'v':
m_verbose++;
break;
case 'd':
m_launchDebug = true;
break;
case 's':
m_installSilently = true;
break;
case 'c':
if (++it == cend) {
*errorMessage = QString::fromLatin1("Parameter missing for -c");
return ParseArgsError;
}
m_putChunkSize = it->toULongLong() * 1024;
if (!m_putChunkSize) {
*errorMessage = QString::fromLatin1("Invalid chunk size.");
return ParseArgsError;
}
break;
default:
*errorMessage = QString::fromLatin1("Invalid option %1").arg(*it);
return ParseArgsError;
}
} else {
if (!parseArgument(*it, argNumber++, errorMessage))
return ParseArgsError;
}
} //for loop
// Basic Check & init
switch (m_mode) {
case Invalid:
return ParseArgsError;
case Launch:
if (m_address.isEmpty() || !m_launchUID || m_launchBinary.isEmpty()) {
*errorMessage = QString::fromLatin1("Not enough parameters for launch.");
return ParseInitError;
}
break;
case Ping:
if (m_address.isEmpty()) {
*errorMessage = QString::fromLatin1("Not enough parameters for ping.");
return ParseInitError;
}
if (!isSerialPort(m_address)) {
*errorMessage = QString::fromLatin1("'ping' not supported for TCP/IP.");
return ParseInitError;
}
break;
case Install:
if (m_address.isEmpty() || m_installSisFile.isEmpty()) {
*errorMessage = QString::fromLatin1("Not enough parameters for install.");
return ParseInitError;
}
break;
case Uninstall:
if (!m_uninstallPackage) {
*errorMessage = QString::fromLatin1("Not enough parameters for uninstall.");
return ParseInitError;
}
break;
case Put: {
if (m_address.isEmpty() || m_putLocalFile.isEmpty() || m_putRemoteFile.isEmpty()) {
*errorMessage = QString::fromLatin1("Not enough parameters for put.");
return ParseInitError;
}
const QFileInfo fi(m_putLocalFile);
if (!fi.isFile() || !fi.isReadable()) {
*errorMessage = QString::fromLatin1("Local file '%1' not readable.").arg(m_putLocalFile);
return ParseInitError;
}
}
break;
default:
break;
}
return ParseArgsOk;
}
Call::Call(std::string code){
std::size_t p = code.find('(');
function_ = code.substr(0, p);
code = code.substr(p + 1, code.length() - p - 2);
std::stringstream currentArgument;
bool isString = false;
bool isChar = false;
bool isEscaped = false;
std::stack<char> keller;
for (size_t i = 0; i < code.length(); i++) {
char c = code[i];
if (!isString && !isChar){
switch (c) {
case '(':
case '{':
keller.push(c);
currentArgument << c;
break;
case ')':
if (keller.empty() || pop(keller) != '(')
throw;
currentArgument << c;
break;
case '}':
if (keller.empty() || pop(keller) != '{')
throw;
currentArgument << c;
break;
case ';':
if (!keller.empty()) {
currentArgument << c;
}
break;
case '"':
isString = true;
currentArgument << c;
break;
case '\'':
isChar = true;
currentArgument << c;
break;
case ' ':
break;
case ',':
if (keller.size() > 0){ //if it isn't a comma that separates parameters of this call
currentArgument << c;
}
break;
default:
currentArgument << c;
break;
}
}
else {
if (!isEscaped){
if (c == '"') {
isString = false;
}
else if (c == '\'') {
isChar = false;
}
else if (c == '\\') {
isEscaped = true;
}
}
else {
isEscaped = false;
}
currentArgument << c;
}
if (keller.empty() && !isString && !isChar && (i == code.length() - 1 || code[i + 1] == ',')) {
arguments_.emplace_back(parseArgument(currentArgument.str()));
//this clears the stringstream
currentArgument.str(std::string());
currentArgument.clear();
}
}
if (!keller.empty()) {
throw;
}
}
int main(int argc, char** argv){
if(!parseArgument(argc, argv)){
argumentUsage(argv[0]);
}
return 0;
}
