ArgumentList *unmarshalArgumentList(StorageIntf *s)
{
uint i;
uint count = unmarshalUInt(s);
if (count==NULL_LIST) return 0; // null list
ArgumentList *result = new ArgumentList;
assert(count<1000000);
//printf("unmarshalArgumentList: %d\n",count);
for (i=0;i<count;i++)
{
Argument *a = new Argument;
a->attrib = unmarshalQCString(s);
a->type = unmarshalQCString(s);
a->canType = unmarshalQCString(s);
a->name = unmarshalQCString(s);
a->array = unmarshalQCString(s);
a->defval = unmarshalQCString(s);
a->docs = unmarshalQCString(s);
result->append(a);
}
result->constSpecifier = unmarshalBool(s);
result->volatileSpecifier = unmarshalBool(s);
result->pureSpecifier = unmarshalBool(s);
return result;
}
QString makeFunction(FunctionModelItem function, const QString preFix = QString()) {
QString fullName;
fullName += function->type().toString();
fullName += " ";
fullName += preFix;
fullName += function->name();
ArgumentList arguments = function->arguments();
QStringList args;
for (int i = 0; i < arguments.count(); ++i) {
QString arg = arguments[i]->name();
if (arg.isEmpty())
arg = QString("arg%1").arg(i);
QString theargs = arguments[i]->type().toString() + " " + arg;
if (arguments[i]->defaultValue())
theargs += " = " + arguments[i]->defaultValueExpression();
args += theargs;
}
fullName += "(" + args.join(", ") + ")";
if (function->isConstant())
fullName += " const";
if (function->isStatic())
fullName = "static " + fullName;
return fullName;
}
ClassDef *GenericsSDict::find(const QCString &key)
{
int i=key.find('<');
if (i==-1)
{
GenericsCollection *collection = m_dict.find(key);
if (collection && collection->count()==1)
{
QIntDictIterator<ClassDef> it(*collection);
return it.current();
}
}
else
{
GenericsCollection *collection = m_dict.find(key.left(i));
if (collection)
{
ArgumentList argList;
stringToArgumentList(key.mid(i),&argList);
int c = argList.count();
return collection->find(c);
}
}
return 0;
}
void UDPEchoClient::onReadyRead () {
{
LockGuard guard (mMutex);
if (mState != WAIT) return; // ignoring; timeout.
// Check protocol
String from;
int fromPort;
ByteArrayPtr data = mSocket.recvFrom(&from,&fromPort);
if (!data) {
Log (LogWarning) << LOGID << "Could not read any data tough readyRead() signal" << std::endl;
return; // ?
}
String toParse (data->const_c_array(), data->size());
ArgumentList list;
sf::argSplit (toParse, &list);
// Format: TOKEN IP-Address Port
if (list.size() != 4 || list[0] != "condataReply") {
Log (LogInfo) << LOGID << "Invalid protocol in answer " << *data << ", token=" << list.size() << std::endl;
return; // invalid protocol
}
if (list[1] != mToken){
Log (LogInfo) << LOGID << "Token mismatch in answer " << *data << std::endl;
return; // invalid token
}
mState = READY;
mAddress = list[2];
mPort = atoi (list[3].c_str());
Log (LogInfo) << LOGID << "Successfully decoded echo answer: " << mAddress << ":" << mPort << " coming from " << from << ":" << fromPort << std::endl;
sf::cancelTimer(mTimeoutHandle);
}
mResultDelegate (NoError);
}
int main(int argc, const char **argv)
{
unitTests();
Settings settings;
ArgumentList args = gatherArguments(argc, argv, settings);
// TODO: Probably don't want to share them between files
Bindings bindings = bindStandardLibrary();
Interpreter interpreter(bindings, settings);
if (args.empty())
{
repl(interpreter, settings);
}
else
{
for (ArgumentList::const_iterator it = args.begin() ; it != args.end() ; ++it)
{
execute(interpreter, *it, settings);
}
}
// If you use CTRL-D, nice to output a newline...
std::cout << '\n';
}
QSharedPointer<ClassDef> GenericsSDict::find(const QString &key)
{
int i = key.indexOf('<');
if (i == -1) {
QSharedPointer<QHash<long, QSharedPointer<ClassDef>>> collection = m_dict.find(key);
if (collection && collection->count() == 1) {
return collection->begin().value();
}
} else {
QSharedPointer<QHash<long, QSharedPointer<ClassDef>>> collection = m_dict.find(key.left(i));
if (collection) {
ArgumentList argList;
stringToArgumentList(key.mid(i), &argList);
int c = argList.count();
return collection->value(c);
}
}
return QSharedPointer<ClassDef>();
}
void GenericsSDict::insert(const QString &key, QSharedPointer<ClassDef> cd)
{
int i = key.indexOf('<');
if (i == -1) {
return;
}
ArgumentList argList;
stringToArgumentList(key.mid(i), &argList);
int c = argList.count();
if (c == 0) {
return;
}
QSharedPointer<QHash<long, QSharedPointer<ClassDef>>> collection = m_dict.find(key.left(i));
if (collection == 0) {
// new hash
collection = QMakeShared<QHash<long, QSharedPointer<ClassDef>>>();
// add new hash to m_dict
m_dict.insert(key.left(i), collection);
}
if (! collection->contains(c)) {
// add the collection
collection->insert(c, cd);
}
}
Parser::ArgumentList Parser::arguments(istream* input)
{
ArgumentList list;
get_token(input);
for(;;)
{
if(curr_sym.curr_tok == Lexer::RP)
{
return list;
}
else if (curr_sym.curr_tok == Lexer::SEP)
{
get_token(input);
continue;
}
else if (curr_sym.curr_tok == Lexer::PRINT || curr_sym.curr_tok == Lexer::END)
{
throw Error::SyntaxError(") expected");
}
else
{
list.push_back(expr(input, false));
}
}
}
ArgumentList ArgumentParser::findArguments(const Option& option) const
{
ArgumentList args;
foreach (auto& arg, m_arguments)
if (&option == arg.option)
args.push_back(arg);
return args;
}
ArgumentList ArgumentParser::findUnknownArguments() const
{
ArgumentList args;
foreach (auto& arg, m_arguments)
if (!arg.isKnown())
args.push_back(arg);
return args;
}
void Action::clearOutputAgumentValues() {
ArgumentList *outArgList = getOutputArgumentList();
int nArgs = outArgList->size();
for (int n = 0; n < nArgs; n++) {
Argument *arg = outArgList->getArgument(n);
arg->setValue("");
}
}
int main(int argc, char** argv)
{
QGL::setPreferredPaintEngine(QPaintEngine::OpenGL);
// The QApplication will strip its args from argc/argv, so we want to do
// this before putting the command-line args into our ArgumentList, or we
// will try to open the Qt args as data files.
QApplication app(argc, argv);
SystemServicesImp::instance()->WriteLogInfo(QString("%1 Startup").arg(APP_NAME).toStdString());
// Register the command line options
ArgumentList* pArgumentList = ArgumentList::instance();
if (pArgumentList == NULL)
{
SystemServicesImp::instance()->WriteLogInfo(QString("%1 Shutdown").arg(APP_NAME).toStdString());
return -1;
}
pArgumentList->registerOption("input");
pArgumentList->registerOption("deployment");
pArgumentList->registerOption("debugDeployment");
pArgumentList->registerOption("exitAfterWizards");
pArgumentList->registerOption("generate");
pArgumentList->registerOption("processors");
pArgumentList->registerOption("");
pArgumentList->set(argc, argv);
// Run the application
InteractiveApplication interactiveApp(app);
int success = interactiveApp.run(argc, argv);
SystemServicesImp::instance()->WriteLogInfo(QString("%1 Shutdown").arg(APP_NAME).toStdString());
return success;
}
int FITSHeaderProcess::ProcessCommandLine( const StringList& argv ) const
{
ArgumentList arguments =
ExtractArguments( argv, ArgumentItemMode::AsViews,
ArgumentOption::AllowWildcards|ArgumentOption::NoPreviews );
FITSHeaderInstance instance( this );
bool launchInterface = false;
int count = 0;
for ( ArgumentList::const_iterator i = arguments.Begin(); i != arguments.End(); ++i )
{
const Argument& arg = *i;
if ( arg.IsNumeric() )
throw Error( "Unknown numeric argument: " + arg.Token() );
else if ( arg.IsString() )
throw Error( "Unknown string argument: " + arg.Token() );
else if ( arg.IsSwitch() )
throw Error( "Unknown switch argument: " + arg.Token() );
else if ( arg.IsLiteral() )
throw Error( "Unknown argument: " + arg.Token() );
else if ( arg.IsItemList() )
{
++count;
if ( arg.Items().IsEmpty() )
{
Console().WriteLn( "No view(s) found: " + arg.Token() );
continue;
}
for ( StringList::const_iterator j = arg.Items().Begin(); j != arg.Items().End(); ++j )
{
View v = View::ViewById( *j );
if ( v.IsNull() )
throw Error( "No such view: " + *j );
instance.LaunchOn( v );
}
}
}
if ( launchInterface )
instance.LaunchInterface();
else if ( count == 0 )
{
if ( ImageWindow::ActiveWindow().IsNull() )
throw Error( "There is no active image window." );
instance.LaunchOnCurrentWindow();
}
return 0;
}
std::string PageTemplate::get_variable(const ArgumentList& arguments, const ArrayArgument::Item* arrayItem, const std::string& var) const
{
if (arrayItem != 0)
{
ArrayArgument::Item::const_iterator i = arrayItem->find(var);
if (i != arrayItem->end())
return i->second;
}
ArgumentList::const_iterator i = arguments.find(var);
return i == arguments.end() ? std::string() : i->second->to_string();
}
void InsertMacro(CMacro* Macro, std::wstring& Args)
{
tTextData Text;
ArgumentList Arguments;
splitArguments(Arguments,Args);
if ((int)Arguments.size() != Macro->getArgumentCount())
{
Logger::printError(Logger::Error,L"%s macro arguments (%d vs %d)",
(int)Arguments.size() > Macro->getArgumentCount() ? L"Too many" : L"Not enough",
Arguments.size(),Macro->getArgumentCount());
return;
}
Global.MacroNestingLevel++;
if (Global.MacroNestingLevel == ASSEMBLER_MACRO_NESTING_LEVEL)
{
Logger::printError(Logger::Error,L"Maximum macro nesting level reached");
return;
}
int MacroCounter = Macro->getIncreaseCounter();
for (int i = 0; i < Macro->getLineCount(); i++)
{
Text.buffer = Macro->getLine(i,Arguments,MacroCounter);
Text.buffer = Global.symbolTable.insertEquations(Text.buffer,Global.FileInfo.FileNum,Global.Section);
if (CheckEquLabel(Text.buffer) == false)
{
Text.buffer = checkLabel(Text.buffer,false);
splitLine(Text.buffer,Text.name,Text.params);
if (Text.name.size() == 0) continue;
bool macro = false;
for (size_t i = 0; i < Global.Macros.size(); i++)
{
if (Text.name.compare(Global.Macros[i]->getName()) == 0)
{
InsertMacro(Global.Macros[i],Text.params);
macro = true;
}
}
if (macro == true) continue;
if (Arch->AssembleDirective(Text.name,Text.params) == false)
{
Arch->AssembleOpcode(Text.name,Text.params);
}
}
}
Global.MacroNestingLevel--;
}
Variant Invoke(Variant &obj, const ArgumentList &arguments) override
{
UAssert( arguments.size( ) == THIS_ARG_COUNT,
"Invalid method arguments.\nExpected %i args but got %i.",
THIS_ARG_COUNT,
arguments.size( )
);
invoke<void, ArgTypes...>( obj, arguments );
return { };
}
bool ParserThread::ParseArgumentList(ArgumentList &argumentList)
{
// do nothing on the argumentList, just do the loop
if(PeekToken()->type_id() != TKN_LESS)
return true;
// shoud be a (xxxx) or <xxxxx>
Token * tk = ConsumeToken();
TRACE("ParserThread::ParseArgumentList() Enter...");
int level = 1;
argumentList.clear();
argumentList.push_back(*tk); // push <while(true)
while(true)
{
tk = PeekToken();//
if(tk->type_id() == TKN_LESS)
{
ConsumeToken();
argumentList.push_back(*tk);
level++;
}
else if (tk->type_id() == TKN_GREATER)
{
level--;
ConsumeToken();
argumentList.push_back(*tk);
if(level <= 0)
break;
}
else if(tk->type_id()==TKN_SEMICOLON || tk->type_id()==TKN_R_BRACE)
{
m_Context.EndStatement();
return false;
}
else
{
//std::cout<<*tk<<std::endl;
argumentList.push_back(*tk);
ConsumeToken();
}
}
//cout<<"currentToken"<<*(CurrentToken())<<endl;
TRACE("ParserThread::ParseArgumentList() Leave...");
return true;
}
void
Protocol::_ParseCapabilities(const ArgumentList& arguments)
{
fCapabilities.MakeEmpty();
for (int32 i = 0; i < arguments.CountItems(); i++) {
if (StringArgument* argument
= dynamic_cast<StringArgument*>(arguments.ItemAt(i)))
fCapabilities.AddItem(new StringArgument(*argument));
}
TRACE("capabilities: %s\n", fCapabilities.ToString().String());
}
int main(int argc, char *argv[]) {
bool verbose = false;
/* Argomenti passati all'eseguibile */
ArgumentList args = ArgumentList(argc, argv);
if ( argc < 2 || argc > 3 ) {
cerr << "Utilizzo: " << args.getFirst() << " [-v] <file_istanza_tsp>" << endl;
cerr << "\t-v : verboso." << endl << endl;
return -1;
}
else {
cout << args.getFirst() << endl;
}
/* Istanza del problema */
TSPInstance< w_type > *problema = new TSPInstance< w_type >;
/* Loader dell'istanza */
TSPReader< w_type > *reader = new TSPReader< w_type >(problema);
/* Nome del file da cui caricare l'istanza */
string filename = "";
/* Soluzione del problema */
vector< vertice * > *soluzione;
verbose = args.getSwitch("-v");
filename = args.getFirst();
reader->setInputFile(filename);
if ( ! reader->read() ) {
cerr << "Impossibile leggere l'istanza." << endl;
delete problema;
delete reader;
return -1;
}
if ( verbose ) {
cout << "Istanza caricata, sta per essere eseguito l'algoritmo di risoluzione." << endl;
}
soluzione = new vector< vertice * >;
christofides(problema->getGrafo(), soluzione);
stampaDimensioneCircuito(*soluzione);
cout << endl;
stampaCostoCircuito(*soluzione, *(problema->getGrafo()));
delete soluzione;
delete problema;
delete reader;
return 0;
}
CDirectiveIncbin::CDirectiveIncbin(ArgumentList& args)
{
fileName = getFullPathName(args[0].text);
if (fileExists(fileName) == false)
{
Logger::printError(Logger::FatalError,L"File %s not found",fileName);
return;
}
int inputFileSize = fileSize(fileName);
if (args.size() >= 2)
{
// load start address
if (ConvertExpression(args[1].text,startAddress) == false)
{
Logger::printError(Logger::FatalError,L"Invalid start address %s",args[1].text);
return;
}
if (startAddress >= inputFileSize)
{
Logger::printError(Logger::Error,L"Start address 0x%08X after end of file",startAddress);
return;
}
if (args.size() >= 3)
{
// load size too
if (ConvertExpression(args[2].text,loadSize) == false)
{
Logger::printError(Logger::FatalError,L"Invalid size %s",args[1].text);
return;
}
if (startAddress+loadSize > inputFileSize)
{
Logger::printError(Logger::Warning,L"Loading beyond file end, truncating");
loadSize = inputFileSize-startAddress;
}
} else {
loadSize = inputFileSize-startAddress;
}
} else {
startAddress = 0;
loadSize = inputFileSize;
}
g_fileManager->advanceMemory(loadSize);
}
void PageTemplate::yield_foreach(const ArgumentList& arguments, const TokenPtr& token, std::string& result) const
{
const ForeachToken* ftoken = static_cast<const ForeachToken*>(token.get());
ArgumentList::const_iterator i = arguments.find(ftoken->data);
if (i == arguments.end() || !i->second->is_array())
return;
const ArrayArgument* array = static_cast<const ArrayArgument*>(i->second.get());
for (std::size_t i = 0, n = array->size(); i < n; i++)
{
if (i > 0)
yield_tokens(arguments, 0, ftoken->sep, result);
yield_tokens(arguments, &array->get(i), ftoken->body, result);
}
}
Argument *Action::getArgument(const std::string &name) {
ArgumentList *argList = getArgumentList();
int nArgs = argList->size();
for (int n = 0; n < nArgs; n++) {
Argument *arg = argList->getArgument(n);
const char *argName = arg->getName();
if (argName == NULL)
continue;
string argNameStr = argName;
if (argNameStr.compare(name) == 0)
return arg;
}
return NULL;
}
void PrintDeviceInfo(Device *dev, int indent)
{
string indentStr;
GetIndentString(indent, indentStr);
const char *devName = dev->getFriendlyName();
cout << indentStr << devName << endl;
int i, n, j;
ServiceList *serviceList = dev->getServiceList();
int serviceCnt = serviceList->size();
for (n=0; n<serviceCnt; n++) {
Service *service = serviceList->getService(n);
cout << indentStr << " service[" << n << "] = "<< service->getServiceType() << endl;
ActionList *actionList = service->getActionList();
int actionCnt = actionList->size();
for (i=0; i<actionCnt; i++) {
Action *action = actionList->getAction(i);
cout << indentStr << " action[" << i << "] = "<< action->getName() << endl;
ArgumentList *argList = action->getArgumentList();
int argCnt = argList->size();
for (j=0; j<argCnt; j++) {
Argument *arg = argList->getArgument(j);
cout << indentStr << " arg[" << j << "] = " << arg->getName() << "(" << arg->getDirection() << ")";
StateVariable *stateVar = arg->getRelatedStateVariable();
if (stateVar != NULL)
cout << " - " << stateVar->getName();
cout << endl;
}
}
ServiceStateTable *stateTable = service->getServiceStateTable();
int varCnt = stateTable->size();
for (i=0; i<varCnt; i++) {
StateVariable *stateVar = stateTable->getStateVariable(i);
cout << indentStr << " stateVar[" << i << "] = " << stateVar->getName() << endl;
AllowedValueList *valueList = stateVar->getAllowedValueList();
int valueListCnt = valueList->size();
if (0 < valueListCnt) {
for (j=0; j<valueListCnt; j++)
cout << indentStr << " AllowedValueList[" << j << "] = " << valueList->getAllowedValue(j) << endl;
}
AllowedValueRange *valueRange = stateVar->getAllowedValueRange();
if (valueRange != NULL) {
cout << indentStr << " AllowedRange[minimum] = " << valueRange->getMinimum() << endl;
cout << indentStr << " AllowedRange[maximum] = " << valueRange->getMaximum() << endl;
cout << indentStr << " AllowedRange[step] = " << valueRange->getStep() << endl;
}
}
}
}
bool DirectiveString(ArgumentList& List, int flags)
{
ArgumentList NewList;
if (Global.Table.isLoaded() == false)
{
Logger::printError(Logger::Error,L"No table opened");
return false;
}
for (size_t i = 0; i < List.size(); i++)
{
if (List[i].isString)
{
ByteArray data = Global.Table.encodeString(List[i].text,false);
if (data.size() == 0 && List[i].text.size() != 0)
{
Logger::printError(Logger::Error,L"Failed to encode string");
return false;
}
for (int i = 0; i < data.size(); i++)
{
wchar_t str[32];
swprintf(str,32,L"0x%02X",data[i]);
NewList.add(str,false);
}
} else {
NewList.add(List[i].text,false);
}
}
if ((flags & DIRECTIVE_STR_NOTERMINATION) == 0)
{
ByteArray data = Global.Table.encodeTermination();
for (int i = 0; i < data.size(); i++)
{
wchar_t str[32];
swprintf(str,32,L"0x%02X",data[i]);
NewList.add(str,false);
}
}
CDirectiveData* Data = new CDirectiveData(NewList,1,false);
AddAssemblerCommand(Data);
return true;
}
bool measured_response_time(
const char* name,
ArgumentList const& arguments,
EvalState &state,
Value& result)
{
result.SetErrorValue();
std::string queue_id;
int mode = 0, seconds = 0;
// we check to make sure that we are passed at least one argument
if (arguments.size() <= 1) {
return false;
} else {
Value arg[3];
if (!(arguments[0]->Evaluate(state, arg[0]) && arg[0].IsStringValue(queue_id))) {
return false;
}
if (!(arguments[1]->Evaluate(state, arg[1]) && arg[1].IsIntegerValue(mode))) {
return false;
}
if (!(arguments[2]->Evaluate(state, arg[2]) && arg[2].IsIntegerValue(seconds))) {
return false;
}
}
if (mode) {
result.SetRealValue(lb_statistics(queue_id, avg, seconds));
} else {
result.SetRealValue(lb_statistics(queue_id, std_dev, seconds));
}
return true;
}
bool DirectiveData(ArgumentList& List, int flags)
{
bool ascii = false;
if (flags & DIRECTIVE_DATA_ASCII)
{
ascii = true;
flags &= ~DIRECTIVE_DATA_ASCII;
}
bool hasNonAscii = false;
for (size_t i = 0; i < List.size(); i++)
{
if (List[i].isString)
{
for (size_t k = 0; k < List[i].text.size(); k++)
{
if (List[i].text[k] >= 0x80)
hasNonAscii = true;
}
}
}
if (hasNonAscii)
Logger::printError(Logger::Warning,L"Non-ASCII character in data directive. Use .string instead");
CDirectiveData* Data = new CDirectiveData(List,flags,ascii);
AddAssemblerCommand(Data);
return true;
}
double Calculator::call(Lexer& lexer, string name)
{
SymEntry* sym = symbols.Get(name);
if(!sym)
{
throw Error::SyntaxError("undefined function "+name);
}
ArgumentList args = arguments(lexer);
switch(sym->type)
{
case SymEntry::SYS_FUNC:
{
SymSysFunc* sFunc = static_cast<SymSysFunc*>(sym);
if(args.size() != 1)
throw Error::SyntaxError("incorrect number of arguments");
return sFunc->func(args[0]);
}
case SymEntry::USR_FUNC:
{
SymUsrFunc* uFunc = static_cast<SymUsrFunc*>(sym);
if(args.size() != uFunc->params.size())
throw Error::SyntaxError("incorrect number of arguments");
map<string,double> argMap;
for(unsigned int i = 0; i < uFunc->params.size(); i++)
{
argMap[uFunc->params[i]] = args[i];
}
for(TokenList::const_iterator i = uFunc->func.begin(); i != uFunc->func.end(); i++)
{
Token tok = *i;
if(tok.Type == Token::NAME && argMap.count(tok.StringValue) > 0)
{
Token val(Token::NUMBER, argMap[tok.StringValue]);
lexer.push(val);
}
else
lexer.push(*i);
}
return expr(lexer);
}
default:
throw Error::SyntaxError("not a function: "+name);
}
}
int PreferencesProcess::ProcessCommandLine( const StringList& argv ) const
{
ArgumentList arguments = ExtractArguments( argv, ArgumentItemMode::NoItems );
PreferencesInstance instance( this );
bool launchInterface = false;
for ( ArgumentList::const_iterator i = arguments.Begin(); i != arguments.End(); ++i )
{
const Argument& arg = *i;
if ( arg.IsNumeric() )
{
throw Error( "Unknown numeric argument: " + arg.Token() );
}
else if ( arg.IsString() )
{
throw Error( "Unknown string argument: " + arg.Token() );
}
else if ( arg.IsSwitch() )
{
throw Error( "Unknown switch argument: " + arg.Token() );
}
else if ( arg.IsLiteral() )
{
if ( arg.Id() == "-interface" )
launchInterface = true;
else if ( arg.Id() == "-help" )
{
ShowHelp();
return 0;
}
else
throw Error( "Unknown argument: " + arg.Token() );
}
else if ( arg.IsItemList() )
throw Error( "Invalid non-parametric argument: " + arg.Token() );
}
if ( launchInterface || arguments.IsEmpty() )
instance.LaunchInterface();
else
instance.LaunchGlobal();
return 0;
}
bool Application::executeStartupBatchWizards()
{
vector<string> wizardFiles;
ArgumentList* pArgumentList = ArgumentList::instance();
if (pArgumentList != NULL)
{
wizardFiles = pArgumentList->getOptions("input");
}
if (wizardFiles.empty() == true)
{
return true;
}
return WizardUtilities::runBatchFiles(wizardFiles, mpProgress);
}
void CMacro::loadArguments(ArgumentList& argumentList)
{
name = argumentList[0].text;
for (size_t i = 1; i < argumentList.size(); i++)
{
arguments.push_back(argumentList[i].text);
}
}