int main( int argc, char *argv[]) {
solution_list_t solutions = NULL;
int numberOfSolutions = 0;
clock_t start, end;
unsigned long durationInMilliseconds;
int i;
int sizeOfBoard;
bool displayQueens = false;
if(argc == 2) {
sizeOfBoard = atoi(argv[1]);
} else if( argc == 3) {
if(strcmp(argv[1], "-d") == 0) {
sizeOfBoard = atoi(argv[2]);
displayQueens = true;
} else if(strcmp(argv[2], "-d") == 0) {
sizeOfBoard = atoi(argv[1]);
displayQueens = true;
} else {
printUsageAndExit();
}
} else {
printUsageAndExit();
}
// printf("%d\n", sizeOfBoard);
solution_t working = createSolution(sizeOfBoard);
start = clock();
solve( sizeOfBoard, &solutions, &numberOfSolutions, working, 0);
end = clock();
durationInMilliseconds = (end-start) * 1000 / CLOCKS_PER_SEC;
printf("N-Queens Found %d Solutions in %.6fs on a %dx%d board.\n", numberOfSolutions, durationInMilliseconds/1000.0, sizeOfBoard, sizeOfBoard);
if(displayQueens) {
displaySolutions(solutions, numberOfSolutions, sizeOfBoard);
}
deleteSolutions(solutions,numberOfSolutions);
deleteSolution(working);
return 0;
}
int main(int argc, char** argv) {
// Random seed
#ifdef _WIN32
srand(123456);
#else
srandom(123456);
#endif
// Client or server mode?
char* modeString = getOption(argc, argv, "-m");
CommunicatorMode mode = COMMUNICATOR_MODE_NONE;
if (!strcmp(modeString, "client"))
mode = COMMUNICATOR_MODE_CLIENT;
else if (!strcmp(modeString, "server"))
mode = COMMUNICATOR_MODE_SERVER;
else
printUsageAndExit(argv[0]);
// Declare our timeline. It will be initialized by the Communicator.
Timeline timeline;
// Declare our communicator
Communicator communicator(timeline, mode);
// If we're a client, who are we connecting to?
if (mode == COMMUNICATOR_MODE_CLIENT)
communicator.SetServer(getOption(argc, argv, "-s"));
// Otherwise, how many clients are we waiting for?
else {
int numClients = atoi(getOption(argc, argv, "-n"));
if (numClients < 0)
printUsageAndExit(argv[0]);
communicator.SetNumClientsExpected((unsigned) numClients);
}
// Start background music
sf::Music Music;
if (!Music.OpenFromFile("scenefiles/bgm.ogg"))
{
std::cout << "Error loading music file\n";
}
Music.SetLoop(true);
Music.Play();
Game growblesGame(timeline, communicator);
growblesGame.Setup();
return 0;
}
vector<StdString> Universe::handleArguments(long argc, char** argv) {
vector<StdString> vmArgs = vector<StdString>();
dumpBytecodes = 0;
gcVerbosity = 0;
for (long i = 1; i < argc; ++i) {
if (strncmp(argv[i], "-cp", 3) == 0) {
if ((argc == i + 1) || classPath.size() > 0)
printUsageAndExit(argv[0]);
setupClassPath(StdString(argv[++i]));
} else if (strncmp(argv[i], "-d", 2) == 0) {
++dumpBytecodes;
} else if (strncmp(argv[i], "-g", 2) == 0) {
++gcVerbosity;
} else if (strncmp(argv[i], "-H", 2) == 0) {
long heap_size = 0;
char unit[3];
if (sscanf(argv[i], "-H%ld%2s", &heap_size, unit) == 2) {
if (strcmp(unit, "KB") == 0)
heapSize = heap_size * 1024;
else if (strcmp(unit, "MB") == 0)
heapSize = heap_size * 1024 * 1024;
} else
printUsageAndExit(argv[0]);
} else if ((strncmp(argv[i], "-h", 2) == 0)
|| (strncmp(argv[i], "--help", 6) == 0)) {
printUsageAndExit(argv[0]);
} else {
vector<StdString> extPathTokens = vector<StdString>(2);
StdString tmpString = StdString(argv[i]);
if (getClassPathExt(extPathTokens, tmpString) == ERR_SUCCESS) {
addClassPath(extPathTokens[0]);
}
//Different from CSOM!!!:
//In CSOM there is an else, where the original filename is pushed into the vm_args.
//But unlike the class name in extPathTokens (extPathTokens[1]) that could
//still have the .som suffix though.
//So in SOM++ getClassPathExt will strip the suffix and add it to extPathTokens
//even if there is no new class path present. So we can in any case do the following:
vmArgs.push_back(extPathTokens[1]);
}
}
addClassPath(StdString("."));
return vmArgs;
}
static void processArgDetermineSortFunc(char *aProgramName,
char *aAlgorithmName,
perfContext *aContext)
{
if (strcmp(aAlgorithmName, "quick") == 0)
{
aContext->mSortFunc = qsort;
}
else if (strcmp(aAlgorithmName, "merge") == 0)
{
aContext->mSortFunc = mergesortLibc;
}
else if (strcmp(aAlgorithmName, "heap") == 0)
{
aContext->mSortFunc = heapsortLibc;
}
else if (strcmp(aAlgorithmName, "tim") == 0)
{
aContext->mSortFunc = timsort;
}
else if (strcmp(aAlgorithmName, "tim1") == 0)
{
aContext->mSortFunc = timsort1;
}
else
{
printUsageAndExit(aProgramName);
}
}
int main(int argc, char *argv[]) {
if (argc != 2)
printUsageAndExit();
const char *BinaryFilename = argv[1];
return doDumpHeapInstance(BinaryFilename);
}
void getCmdLineOptions(int argc, char *argv[]) {
int i;
char *currArg;
g_opt.targetLang = TLT_FORTRAN;
g_opt.signedChar = 0;
g_opt.asmAttachD = 0;
g_opt.prefixStructFields = -1;
g_opt.structFieldsSep = NULL;
g_opt.conflictPrefix = "WIC_";
g_opt.supressLevel = 1;
g_opt.outLineLen = 0;
g_opt.fileNameList = createSLList();
g_opt.incPathList = createSLList();
g_opt.intSize = SIZE_32;
g_opt.nearPtrSize = SIZE_32;
g_opt.ptrSize = SIZE_32;
g_opt.farPtrSize = SIZE_32;
g_opt.hugePtrSize = SIZE_48;
g_opt.debug = 0;
if (argc <= 1) {
printUsageAndExit();
} else {
for (i = 1; i < argc; i++) {
currArg = argv[i];
_scanCurrArg(currArg);
}
}
addIncPath(getenv("INCLUDE"), 1, 1);
if (isEmptySLList(g_opt.fileNameList)) {
reportError(FATAL_FILE_NOT_SPECIFIED);
}
if (g_opt.outLineLen == 0) {
switch (g_opt.targetLang) {
case TLT_FORTRAN: g_opt.outLineLen = 72; break;
case TLT_ASM: g_opt.outLineLen = 79; break;
default: assert(0);
}
}
if (g_opt.prefixStructFields == -1) {
switch (g_opt.targetLang) {
case TLT_FORTRAN: g_opt.prefixStructFields = 0; break;
case TLT_ASM: g_opt.prefixStructFields = 1; break;
default: assert(0);
}
}
if (g_opt.structFieldsSep == NULL) {
switch (g_opt.targetLang) {
case TLT_FORTRAN: g_opt.structFieldsSep = ""; break;
case TLT_ASM: g_opt.structFieldsSep = "_FS_"; break;
default: assert(0);
}
}
}
int main(int argc, char *argv[]) {
if (argc != 2)
printUsageAndExit();
const char *BinaryFilename = argv[1];
uint16_t Version = swift_reflection_getSupportedMetadataVersion();
printf("Metadata version: %u\n", Version);
return doDumpHeapInstance(BinaryFilename);
}
char* getOption(int argc, char** argv, const char* flag)
{
// Search for the flag
for (int i = 0; i < argc - 1; ++i)
if (!strcmp(argv[i], flag))
return argv[i + 1];
// If the flag wasn't found, bail out.
printUsageAndExit(argv[0]);
// Not reached
return NULL;
}
int main( int argc, char** argv )
{
// Init Physx
initializePhysx();
// Init GLUT
GLUTDisplay::init( argc, argv );
for(int i = 1; i < argc; ++i) {
std::string arg = argv[i];
if(arg == "-P" || arg == "--pbo") {
CannonBall::m_useGLBuffer = true;
} else if( arg == "-n" || arg == "--nopbo" ) {
CannonBall::m_useGLBuffer = false;
} else if( arg == "--noanimate" ) {
CannonBall::m_animate = false;
} else if( arg == "-h" || arg == "--help" ) {
printUsageAndExit(argv[0]);
} else {
std::cerr << "Unknown option '" << arg << "'\n";
printUsageAndExit(argv[0]);
}
}
if( !GLUTDisplay::isBenchmark() ) printUsageAndExit( argv[0], false );
// Start
try{
CannonBall scene;
GLUTDisplay::run( "Simple Box Physx", &scene, GLUTDisplay::CDAnimated);
} catch( optix::Exception& e ){
sutilReportError( e.getErrorString().c_str() );
exit(1);
}
return 0;
}
static void processArg(int32_t aArgc, char *aArgv[], perfContext *aContext)
{
if (aArgc == 4)
{
/*
* There is an option specified.
*/
if (strcmp(aArgv[1], "-v") == 0)
{
aContext->mDoVerify = 1;
}
else
{
printUsageAndExit(aArgv[0]);
}
processArgDetermineSortFunc(aArgv[0], aArgv[2], aContext);
aContext->mFileName = aArgv[3];
}
else if (aArgc == 3)
{
/*
* No option specified
*/
processArgDetermineSortFunc(aArgv[0], aArgv[1], aContext);
aContext->mFileName = aArgv[2];
}
else
{
/*
* Invalid number of arguments.
*/
printUsageAndExit(aArgv[0]);
}
if (aContext->mDoVerify < 0) aContext->mDoVerify = 0; /* do not verify unless -v is provided */
}
// _____________________________________________________________________________
void Grep::parseCommandLineArguments(int argc, char** argv) {
// needed if object is parsed again
_inputFile = NULL;
_outputFile = NULL;
_replace = NULL;
_pattern = NULL;
_invert = false;
_count = false;
struct option options[] = {
{ "input-file", 1, NULL, 'i' },
{ "output-file", 1, NULL, 'o' },
{ "replace-with", 1, NULL, 'r' },
{ "invert-match", 0, NULL, 'v' }, // has no argument
{ "count", 0, NULL, 'c'}, // has no argument
{ NULL, 0, NULL, 0 }
};
optind = 1; // if the loop starts again, than optind = X without reset
while (true) {
char opt = getopt_long(argc, argv, "i:o:r:vc", options, NULL);
if (opt == -1) break;
switch (opt) {
case 'i':
_inputFile = optarg;
break;
case 'o':
_outputFile = optarg;
break;
case 'r':
_replace = optarg;
break;
case 'v':
_invert = true;
break;
case 'c':
_count = true;
break;
}
}
if (optind + 1 != argc) printUsageAndExit();
_pattern = argv[optind]; // is the last non-option argument in argv
}
void parseArguments(Args * args, int argc, char **argv) {
int opt;
while ((opt = getopt(argc, argv, "d:f:e:")) != -1) {
switch (opt) {
case 'd':
args->delimiter = optarg;
break;
case 'f':
args->fileName = optarg;
break;
case 'e':
args->expression = optarg;
break;
default:
printUsageAndExit();
}
}
if (args->delimiter == NULL) {
args->delimiter = DEFAULT_DELIMITER;
}
//printArgs(args);
}
int main(int ai_ArgumentCount, char** ac_Arguments__)
{
QStringList lk_Arguments;
for (int i = 1; i < ai_ArgumentCount; ++i)
lk_Arguments << ac_Arguments__[i];
if (lk_Arguments.empty())
printUsageAndExit();
QString ls_OutputPath = "";
QString ls_RetentionTimesPath = "";
int li_BatchSize = 0;
int li_MzDecimalPlaces = -1;
int li_IntensityDecimalPlaces = -1;
QSet<QString> lk_Ids;
// consume options
while (!lk_Arguments.empty())
{
if (lk_Arguments.first() == "-o" || lk_Arguments.first() == "--output")
{
lk_Arguments.removeFirst();
ls_OutputPath = lk_Arguments.takeFirst();
}
else if (lk_Arguments.first() == "-mzdp" || lk_Arguments.first() == "--mzDecimalPlaces")
{
lk_Arguments.removeFirst();
li_MzDecimalPlaces = QVariant(lk_Arguments.takeFirst()).toInt();
}
else if (lk_Arguments.first() == "-idp" || lk_Arguments.first() == "--intensityDecimalPlaces")
{
lk_Arguments.removeFirst();
li_IntensityDecimalPlaces = QVariant(lk_Arguments.takeFirst()).toInt();
}
else if (lk_Arguments.first() == "-b" || lk_Arguments.first() == "--batch")
{
lk_Arguments.removeFirst();
li_BatchSize = QVariant(lk_Arguments.takeFirst()).toInt();
}
else if (lk_Arguments.first() == "-rt" || lk_Arguments.first() == "--retentionTimes")
{
lk_Arguments.removeFirst();
ls_RetentionTimesPath = lk_Arguments.takeFirst();
}
else if (lk_Arguments.first() == "-i" || lk_Arguments.first() == "--id")
{
lk_Arguments.removeFirst();
QString ls_Ids = lk_Arguments.takeFirst();
lk_Ids = ls_Ids.split(QRegExp("[,\\s]+")).toSet();
}
else if (lk_Arguments.first() == "--help")
{
lk_Arguments.removeFirst();
printUsageAndExit();
}
else
break;
}
k_MgfWriter lk_MgfWriter(r_ScanType::All, QList<tk_IntPair>() << tk_IntPair(2, 0x10000));
if (ls_OutputPath.isEmpty())
{
printf("Error: no output file specified.\n");
exit(1);
}
QStringList lk_SpectraFiles;
foreach (QString ls_Path, lk_Arguments)
{
if (!QFile::exists(ls_Path))
{
printf("Error: %s could not be found.\n", ls_Path.toStdString().c_str());
exit(1);
}
lk_SpectraFiles << ls_Path;
}
lk_MgfWriter.convert(lk_SpectraFiles, ls_OutputPath, li_BatchSize,
li_MzDecimalPlaces, li_IntensityDecimalPlaces,
ls_RetentionTimesPath, lk_Ids);
}
ArgData processArgs(const vector<string> &args)
{
ArgData out;
int cur = 2;
int num = args.size();
if(num < 2)
printUsageAndExit();
out.filename = args[1];
while(cur < num) {
string curStr = args[cur++];
if(curStr == string("-skel")) {
if(cur == num) {
cout << "No skeleton specified; ignoring." << endl;
continue;
}
curStr = args[cur++];
if(curStr == string("human"))
out.skeleton = HumanSkeleton();
else
out.skeleton = FileSkeleton(curStr);
out.skeletonname = curStr;
continue;
}
if(curStr == string("-rot")) {
if(cur + 3 >= num) {
cout << "Too few rotation arguments; exiting." << endl;
printUsageAndExit();
}
double x, y, z, deg;
sscanf(args[cur++].c_str(), "%lf", &x);
sscanf(args[cur++].c_str(), "%lf", &y);
sscanf(args[cur++].c_str(), "%lf", &z);
sscanf(args[cur++].c_str(), "%lf", °);
out.meshTransform = Quaternion<>(Vector3(x, y, z), deg * M_PI / 180.) * out.meshTransform;
continue;
}
if(curStr == string("-scale")) {
if(cur >= num) {
cout << "No scale provided; exiting." << endl;
printUsageAndExit();
}
sscanf(args[cur++].c_str(), "%lf", &out.skelScale);
continue;
}
if(curStr == string("-meshonly") || curStr == string("-mo")) {
out.stopAtMesh = true;
continue;
}
if(curStr == string("-circlesonly") || curStr == string("-co")) {
out.stopAfterCircles = true;
continue;
}
if(curStr == string("-nofit")) {
out.noFit = true;
continue;
}
if(curStr == string("-motion")) {
if(cur == num) {
cout << "No motion filename specified; ignoring." << endl;
continue;
}
out.motionname = args[cur++];
continue;
}
cout << "Unrecognized option: " << curStr << endl;
printUsageAndExit();
}
return out;
}
int main(int argc, char *argv[])
{
int retVal = 1;
unsigned long uTime = DEFAULT_USECOND_TIME;
int maxTime = DEFAULT_MAX_TIME;
const char *url = (const char *) 0;
try {
appConfig = AppConfig::instance();
appConfig->init(argc, argv);
appConfig->consumeArgs(&argc, argv);
appConfig->addString( "APPLOG_MINLOG", "0", false );
AppLog::instance()->reconfigure( *appConfig );
int arg;
while ((arg = ::getopt(argc, argv, "s:u:w:")) != -1) {
switch (arg) {
case 's':
uTime = ::atol(optarg);
break;
case 'u':
url = ::strdup(optarg);
break;
case 'w':
maxTime = atoi(optarg);
break;
default:
printUsageAndExit(1);
break;
}
}
// First initialize the ORB, that will remove some arguments...
SharedServiceMain::init( argc, argv, __FILE__, false );
if (url == (const char *) 0)
{
if (appConfig->findString("GS_URL"));
{
url = appConfig->getString("GS_URL");
}
}
if (url == (const char *) 0)
{
url = ::getenv("GS_URL");
}
if (url == (const char *) 0)
{
printUsageAndExit(1);
}
APPLOG_DBG("find GS_URL=%s", url);
time_t startT = ::time((time_t *) 0);
time_t nowT = startT;
bool ok = false;
while (!ok && ((nowT - startT) < maxTime))
{
try{
CORBA::Object_ptr obj = SharedServiceMain::instance()->resolve(url);
if (obj == NULL)
{
APPLOG_INFO("Couldn't resolve: %s", url);
}
else
{
Service::GenericService_ptr gs = Service::GenericService::_narrow(obj);
ok = opPing(gs);
}
} catch (CORBA::SystemException &cse) {
(void) ::fprintf(stderr, "caught CORBA::SystemException: %s\n", cse._info().rep());
cse._tao_print_system_exception(stderr);
}
if (!ok)
{
(void) ::usleep(uTime);
nowT = ::time((time_t *) 0);
}
}
if (!ok)
{
retVal = 2;
}
retVal=0;
} catch (Service::ServiceException &se) {
(void) ::fprintf(stderr, "caught serviceException %s\n", se.what_string.in());
} catch (CORBA::SystemException &se) {
(void) ::fprintf(stderr, "caught CORBA::SystemException: %s\n", se._info().rep());
se._tao_print_system_exception(stderr);
} catch (exception &e) {
(void) ::fprintf(stderr, "caught exception in main: %s\n", e.what());
} catch (...) {
(void) ::fprintf(stderr, "Caught something\n");
}
return retVal;
}
int
main (int argc, char *argv[])
{
int i, j, best;
struct memuse x[MAXFORKS];
struct memuse tmp;
int nforks = argc-1;
int prevtime;
char *memuseargs[3];
char buf[200];
progname = argv[0];
if (argc == 1 || argc >= 300) {
printUsageAndExit ();
}
for (i = 0; i < nforks; i++) {
if (sscanf (argv[i+1], "%d+%d+%d",
&(x[i].mem), &(x[i].start), &(x[i].run)) != 3) {
fprintf (stderr, "%s: specifier %d (%s) malformed - exiting!\n",
progname, i, argv[i+1]);
printUsageAndExit ();
}
if (x[i].start < 0 || x[i].start > MAXSTARTTIME ||
x[i].run < 1 || x[i].run > MAXRUNTIME) {
fprintf (stderr, "%s: program %d has a bad time (start=%d, runtime=%d)\n",
progname, i, x[i].start, x[i].run);
printUsageAndExit ();
}
for (j = 0; j < sizeof (memsizes) / sizeof (memsizes[0]); j++) {
if (x[i].mem == memsizes[j]) {
break;
}
}
if (j == sizeof (memsizes) / sizeof (memsizes[0])) {
fprintf (stderr, "%s: program %d has a bad size (%d)\n",
progname, i, x[i].mem);
printUsageAndExit ();
}
}
/* We need to sort the programs and then run them. It might seem easier
to simply run them and sleep first in the fork, but that would create
too many processes. Instead, we're going to sort the programs by
start time. Selection sort is nice and quick, so we'll use it.
*/
for (i = 0; i < nforks-1; i++) {
for (best = i, j = i+1; j < nforks; j++) {
if (x[j].start < x[best].start) {
best = j;
}
}
if (best != i) {
tmp = x[i];
x[i] = x[best];
x[best] = tmp;
}
}
prevtime = 0;
for (i = 0; i < nforks; i++) {
if (x[i].start > prevtime) {
sleep (x[i].start - prevtime);
prevtime = x[i].start;
}
printf ("Running %d MB at t=%d for %d seconds.\n", x[i].mem, x[i].start,
x[i].run);
/* Child runs the other process */
if (fork () == 0) {
memuseargs[0] = buf;
memuseargs[1] = buf+150;
sprintf (memuseargs[0], "%s%d", memuseprog, x[i].mem);
sprintf (memuseargs[1], "%d", x[i].run);
memuseargs[2] = NULL;
execv (memuseargs[0], memuseargs);
}
}
sleep (x[nforks-1].run+1);
}
void printParseErrorAndExit( const char* argv0, const std::string& flag, const char* arg )
{
std::cerr << "Could not parse argument: " << flag << " " << arg << std::endl;
printUsageAndExit( argv0 );
}
void handleConfig(int argc, char **argv, NIChannelCommand *pCommand)
{
RsslInt32 i;
RsslInt32 streamId = -2;
/* Check usage and retrieve operating parameters */
i = 1;
while(i < argc)
{
if(strcmp("-?", argv[i]) == 0)
{
printUsageAndExit(argv[0]);
}
else if(strcmp("-uname", argv[i]) == 0)
{
i += 2;
snprintf(pCommand->username.data, MAX_BUFFER_LENGTH, "%s", argv[i-1]);
pCommand->username.length = (RsslUInt32)strlen(pCommand->username.data);
}
else if(strcmp("-x", argv[i]) == 0)
{
i++;
xmlTrace = RSSL_TRUE;
snprintf(traceOutputFile, 128, "RsslNIVAProvider\0");
}
else if (strcmp("-tcp", argv[i]) == 0)
{
char *pToken, *pToken2, *pSaveToken, *pSaveToken2;
/* Syntax:
* -tcp hostname:port SERVICE_NAME mp:TRI,mp:.DJI
*/
/* Hostname */
if (++i >= argc) { printf("Error: -tcp: Missing hostname.\n"); printUsageAndExit(argv[0]); }
pToken = strtok(argv[i], ":");
if (!pToken) { printf("Error: -tcp: Missing hostname.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->hostName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->hostName.length = (RsslUInt32)strlen(pCommand->hostName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.unified.address = pCommand->hostName.data;
/* Port */
pToken = strtok(NULL, ":");
if (!pToken) { printf("Error: -tcp: Missing serviceName.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->port.data, MAX_BUFFER_LENGTH, pToken);
pCommand->port.length = (RsslUInt32)strlen(pCommand->port.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.unified.serviceName = pCommand->port.data;
/* Item Service Name */
i++;
pToken = argv[i];
if (!pToken) { printf("Error: -tcp: Missing item service name.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->serviceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->serviceName.length = (RsslUInt32)strlen(pCommand->serviceName.data);
/* Item List */
if (++i >= argc) { printf("Error: -tcp: Missing item.\n"); printUsageAndExit(argv[0]); }
pToken = strtok_r(argv[i], ",", &pSaveToken);
while(pToken)
{
RsslNIItemInfo *pItemInfo;
/* domain */
pToken2 = strtok_r(pToken, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -tcp: Missing item.\n"); printUsageAndExit(argv[0]); }
if (0 == strcmp(pToken2, "mp"))
{
if (pCommand->marketPriceItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketPriceItemInfo[pCommand->marketPriceItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_PRICE;
++pCommand->marketPriceItemCount;
}
else
{
printf("Number of items for Market Price domain exceeded CHAN_CMD_MAX_ITEMS (%d)\n", CHAN_CMD_MAX_ITEMS);
printUsageAndExit(argv[0]);
}
}
else if (0 == strcmp(pToken2, "mbo"))
{
if (pCommand->marketByOrderItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketByOrderItemInfo[pCommand->marketByOrderItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_BY_ORDER;
++pCommand->marketByOrderItemCount;
}
else
{
printf("Number of items for Market By Order domain exceeded CHAN_CMD_MAX_ITEMS (%d)\n", CHAN_CMD_MAX_ITEMS);
printUsageAndExit(argv[0]);
}
}
else
{
printf("Unknown item domain: %s\n", pToken2);
printUsageAndExit(argv[0]);
}
/* name */
pToken2 = strtok_r(NULL, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -tcp: Missing item name.\n"); printUsageAndExit(argv[0]); }
snprintf(pItemInfo->Itemname, 128, "%s", pToken2);
pItemInfo->isActive = RSSL_TRUE;
pItemInfo->streamId = streamId--;
pToken = strtok_r(NULL, ",", &pSaveToken);
}
i++;
}
else if (strcmp("-segmentedMulticast", argv[i]) == 0)
{
char *pToken, *pToken2, *pSaveToken, *pSaveToken2;
/* Syntax:
* -segmentedmulticast hostname:port SERVICE_NAME mp:TRI,mp:.DJI
*/
pCommand->cOpts.rsslConnectOptions.connectionType = RSSL_CONN_TYPE_RELIABLE_MCAST;
/* Hostname */
i++;
pToken = strtok(argv[i], ":");
if (!pToken) { printf("Error: -segmentedMulticast: Missing sendAddress.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->hostName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->hostName.length = (RsslUInt32)strlen(pCommand->hostName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.sendAddress = pCommand->hostName.data;
/* Port */
pToken = strtok(NULL, ":");
if (!pToken) { printf("Error: -segmentedMulticast: Missing sendPort.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->port.data, MAX_BUFFER_LENGTH, pToken);
pCommand->port.length = (RsslUInt32)strlen(pCommand->port.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.sendServiceName = pCommand->port.data;
/* Interface name */
pToken = strtok(NULL, ":");
if (!pToken)
{
pCommand->interfaceName.length = 0;
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.interfaceName = NULL;
}
else
{
snprintf(pCommand->interfaceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->interfaceName.length = (RsslUInt32)strlen(pCommand->interfaceName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.interfaceName = pCommand->interfaceName.data;
}
/* Recv Hostname */
i++;
pToken = strtok(argv[i], ":");
if (!pToken) { printf("Error: -segmentedMulticast: Missing recvAddress.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->recvHostName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->recvHostName.length = (RsslUInt32)strlen(pCommand->recvHostName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.recvAddress = pCommand->recvHostName.data;
/* Recv Port */
pToken = strtok(NULL, ":");
if (!pToken) { printf("Error: -segmentedMulticast: Missing recvPort.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->recvPort.data, MAX_BUFFER_LENGTH, pToken);
pCommand->recvPort.length = (RsslUInt32)strlen(pCommand->recvPort.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.recvServiceName = pCommand->recvPort.data;
i++;
pToken = argv[i];
if (!pToken) { printf("Error: -segmentedMulticast: Missing unicast Port.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->unicastServiceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->unicastServiceName.length = (RsslUInt32)strlen(pCommand->unicastServiceName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.unicastServiceName = pCommand->unicastServiceName.data;
/* Item Service Name */
i++;
pToken = argv[i];
if (!pToken) { printf("Error: -segmentedMulticast: Missing Service Name.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->serviceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->serviceName.length = (RsslUInt32)strlen(pCommand->serviceName.data);
/* Item List */
i++;
pToken = strtok_r(argv[i], ",", &pSaveToken);
if (!pToken) { printf("Error: -segmentedMulticast: Missing Items.\n"); printUsageAndExit(argv[0]); }
while(pToken)
{
RsslNIItemInfo *pItemInfo;
/* domain */
pToken2 = strtok_r(pToken, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -segmentedMulticast: Missing Items.\n"); printUsageAndExit(argv[0]); }
if (0 == strcmp(pToken2, "mp") && pCommand->marketPriceItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketPriceItemInfo[pCommand->marketPriceItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_PRICE;
++pCommand->marketPriceItemCount;
}
else if (0 == strcmp(pToken2, "mbo") && pCommand->marketByOrderItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketByOrderItemInfo[pCommand->marketByOrderItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_BY_ORDER;
++pCommand->marketByOrderItemCount;
}
else
{
printf("Unknown item domain: %s\n", pToken2);
printUsageAndExit(argv[0]);
}
/* name */
pToken2 = strtok_r(NULL, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -segmentedMulticast: Missing Item name.\n"); printUsageAndExit(argv[0]); }
snprintf(pItemInfo->Itemname, 128, "%s", pToken2);
pItemInfo->isActive = RSSL_TRUE;
pItemInfo->streamId = streamId--;
pToken = strtok_r(NULL, ",", &pSaveToken);
}
i++;
printf("sendAddress: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.sendAddress);
printf("SendPort: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.sendServiceName);
printf("RecvAddress: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.recvAddress);
printf("RecvPort: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.recvServiceName);
printf("UnicastPort: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.unicastServiceName);
printf("InterfaceName: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.interfaceName);
}
else if(strcmp("-runtime", argv[i]) == 0)
{
i += 2;
timeToRun = atoi(argv[i-1]);
}
else if (strcmp("-cache", argv[i]) == 0)
{
i += 1;
cacheCommandlineOption = RSSL_TRUE;
}
else
{
printf("Error: Unrecognized option: %s\n\n", argv[i]);
printUsageAndExit(argv[0]);
}
}
}
/*
* configures options based on command line arguments.
*/
void parseCommandLine(int argc, char **argv)
{
RsslInt32 i;
/* Check usage and retrieve operating parameters */
{
ChannelStorage *pCommand = NULL;
RsslBool hasQueueServiceName = RSSL_FALSE;
RsslBool hasConnection = RSSL_FALSE;
i = 1;
if (argc == 1)
printUsageAndExit(argv[0]);
while(i < argc)
{
if ((strcmp("-c", argv[i]) == 0))
{
char *pToken;
/* Syntax:
* -tcp hostname:port
*/
i += 1;
if (i >= argc) printUsageAndExit(argv[0]);
pCommand = &chanCommand;
/* Hostname */
pToken = strtok(argv[i], ":");
if (!pToken) { printf("Error: Missing hostname.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->hostName, MAX_BUFFER_LENGTH, pToken);
pCommand->cInfo.rsslConnectOptions.connectionInfo.unified.address = pCommand->hostName;
/* Port */
pToken = strtok(NULL, ":");
if (!pToken) { printf("Error: Missing port.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->port, MAX_BUFFER_LENGTH, pToken);
pCommand->cInfo.rsslConnectOptions.connectionInfo.unified.serviceName = pCommand->port;
pToken = strtok(NULL, ":");
if (pToken) { printf("Error: extra input after <hostname>:<port>.\n"); printUsageAndExit(argv[0]); }
i += 1;
hasConnection = RSSL_TRUE;
}
else if (strcmp("-runtime", argv[i]) == 0)
{
i += 2; if (i > argc) printUsageAndExit(argv[0]);
timeToRun = atoi(argv[i-1]);
if (timeToRun == 0)
timeToRun = 5;
}
else if (strcmp("-tsDomain", argv[i]) == 0)
{
if (pCommand == NULL)
{
printf("-tsDomain specified before a connection.\n");
printUsageAndExit(argv[0]);
}
i += 2; if (i > argc) printUsageAndExit(argv[0]);
pCommand->tunnelStreamDomain = atoi(argv[i-1]);
}
else if (strcmp("-tsAuth", argv[i]) == 0)
{
if (pCommand == NULL)
{
printf("-tsAuth specified before a connection.\n");
printUsageAndExit(argv[0]);
}
i += 1;
pCommand->useAuthentication = RSSL_TRUE;
}
else if (strcmp("-qServiceName", argv[i]) == 0)
{
if (pCommand == NULL)
{
printf("-qServiceName specified before a connection.\n");
printUsageAndExit(argv[0]);
}
i += 2; if (i > argc) printUsageAndExit(argv[0]);
hasQueueServiceName = RSSL_TRUE;
snprintf(pCommand->queueServiceName, sizeof(pCommand->queueServiceName), argv[i-1]);
snprintf(pCommand->serviceName, sizeof(pCommand->serviceName), pCommand->queueServiceName);
}
else if (strcmp("-qSourceName", argv[i]) == 0)
{
if (pCommand == NULL)
{
printf("-qSourceName specified before a connection.\n");
printUsageAndExit(argv[0]);
}
i += 2; if (i > argc) printUsageAndExit(argv[0]);
pCommand->sourceName.data = argv[i-1];
pCommand->sourceName.length = (RsslUInt32)strlen(pCommand->sourceName.data);
}
else if (strcmp("-qDestName", argv[i]) == 0)
{
if (pCommand == NULL)
{
printf("-qDestName specified before a connection.\n");
printUsageAndExit(argv[0]);
}
i += 2; if (i > argc) printUsageAndExit(argv[0]);
if (pCommand->destNameCount == MAX_DEST_NAMES)
{
printf("Error: Example only supports %d queue destination names.\n", MAX_DEST_NAMES);
printUsageAndExit(argv[0]);
}
pCommand->destNames[pCommand->destNameCount].data = argv[i-1];
pCommand->destNames[pCommand->destNameCount].length = (RsslUInt32)strlen(pCommand->destNames[pCommand->destNameCount].data);
++pCommand->destNameCount;
}
else if(strcmp("-uname", argv[i]) == 0)
{
i += 2; if (i > argc) printUsageAndExit(argv[0]);
userName.length = snprintf(userNameBlock, sizeof(userNameBlock), "%s", argv[i-1]);
userName.data = userNameBlock;
}
else if (strcmp("-?", argv[i]) == 0)
{
printUsageAndExit(argv[0]);
}
else if (strcmp("-x", argv[i]) == 0)
{
i += 1;
xmlTrace = RSSL_TRUE;
snprintf(traceOutputFile, 128, "RsslVAQueueConsumer\0");
}
else
{
printf("Unknown option: %s\n", argv[i]);
printUsageAndExit(argv[0]);
}
/* Check channel-specific options. */
if (pCommand != NULL && (i >= argc || strcmp("-c", argv[i]) == 0))
{
/* Ensure queue source is specified if queue destinations are specified. */
if (pCommand->sourceName.length == 0)
{
printf("Error: No source queue specified.\n");
printUsageAndExit(argv[0]);
}
/* If service not specified for queue messaging, use the service given for other items instead. */
if (hasQueueServiceName == RSSL_FALSE)
{
printf("Error: Missing Queue Service name.\n");
printUsageAndExit(argv[0]);
}
}
}
if (!hasConnection || !hasQueueServiceName || pCommand->sourceName.length == 0)
{
printf("Error: Missing Queue Service, Queue Source Name, or conneciton information.\n");
printUsageAndExit(argv[0]);
}
}
}
static void _scanCurrArg(char *currArg) {
char *saveCurrArg = currArg;
switch (currArg[0]) {
case '-':
case '/':
currArg++;
switch (currArg++[0]) {
case 'F': g_opt.structFieldsSep = currArg; break;
case 'f': g_opt.targetLang = TLT_FORTRAN; break;
case '?':
case 'h':
printUsageAndExit();
break;
case 'i': addIncPath(currArg, 0, 1); break;
case 'I': _scanSize(currArg, &(g_opt.intSize)); break;
case 'j': g_opt.signedChar = 1; break;
case 'l':
if (currArg[0] == '=') {
currArg++;
}
sscanf(currArg, "%u", &(g_opt.outLineLen));
if (!WITHIN_RANGE(g_opt.outLineLen, 30, MAX_OUT_LINE_LEN)) {
reportError(ERR_LINE_LEN_OUT_OF_RANGE, g_opt.outLineLen);
g_opt.outLineLen = 0;
}
break;
case 'a':
switch (currArg++[0]) {
case 'd': g_opt.asmAttachD = 1; break;
case 0: g_opt.targetLang = TLT_ASM; break;
default:
reportError(ERR_INV_CMD_LINE_OPTION, saveCurrArg);
break;
}
break;
case 's':
switch (currArg++[0]) {
case '-':
g_opt.prefixStructFields = 0;
_scanCurrArg("-F");
break;
case '+': g_opt.prefixStructFields = 1; break;
case '0': g_opt.supressLevel = 0; break;
case '1': g_opt.supressLevel = 1; break;
case '2': g_opt.supressLevel = 2; break;
case '3': g_opt.supressLevel = 3; break;
default: g_opt.supressLevel = 0; break;
}
break;
case '1':
if (currArg[0] == '6') {
_scanCurrArg("-P16");
_scanCurrArg("-I16");
}
break;
case '3':
if (currArg[0] == '2') {
_scanCurrArg("-P32");
_scanCurrArg("-I32");
}
break;
case 'p': g_opt.conflictPrefix = currArg; break;
case 'P':
if (currArg[0] == 'n') {
_scanSize(currArg+1, &(g_opt.nearPtrSize));
} else if (currArg[0] == 'p' || currArg[0] == 'd') {
_scanSize(currArg+1, &(g_opt.ptrSize));
} else if (currArg[0] == 'f') {
_scanSize(currArg+1, &(g_opt.farPtrSize));
} else if (currArg[0] == 'h') {
_scanSize(currArg+1, &(g_opt.hugePtrSize));
} else {
SizeType temp = SIZE_MAX;
_scanSize(currArg, &temp);
if (temp == SIZE_16) {
_scanCurrArg("-Pn16");
_scanCurrArg("-Pd16");
_scanCurrArg("-Pf32");
_scanCurrArg("-Ph32");
} else if (temp == SIZE_32) {
_scanCurrArg("-Pn32");
_scanCurrArg("-Pd32");
_scanCurrArg("-Pf32");
_scanCurrArg("-Ph48");
}
}
break;
#ifndef NDEBUG
case 'd':
g_opt.debug = 1;
break;
#endif
default:
reportError(ERR_INV_CMD_LINE_OPTION, saveCurrArg);
}
break;
case '?':
printUsageAndExit();
break;
default:
{
char driveDir[_MAX_DRIVE+_MAX_DIR+10];
char drive[_MAX_DRIVE];
char dir[_MAX_DIR];
char name[_MAX_FNAME];
char ext[_MAX_EXT];
int len;
_splitpath(currArg, drive, dir, name, ext);
_makepath(driveDir, drive, dir, "", "");
len = strlen(driveDir);
if (len > 0) if (driveDir[len-1] == '\\') {
driveDir[len-1] = 0;
}
addSLListElem(g_opt.fileNameList, wicStrdup(currArg));
addIncPath(driveDir, 0, 0); // Add at the beginning
}
}
}
static const struct ProxySettings* processArgs(
int argc,
char** argv)
{
int retVal;
bool foundLocalAddress = false;
bool foundRemoteAddress = false;
struct ProxySettings* proxySettings =
checkedCalloc(1, sizeof(struct ProxySettings));
proxySettings->bufferSize = DEFAULT_BUFFER_SIZE;
proxySettings->noDelay = DEFAULT_NO_DELAY_SETTING;
proxySettings->numIOThreads = DEFAULT_NUM_IO_THREADS;
initializeLinkedList(&(proxySettings->serverAddrInfoList));
do
{
retVal = getopt(argc, argv, "b:l:nr:t:");
switch (retVal)
{
case 'b':
proxySettings->bufferSize = parseBufferSize(optarg);
break;
case 'l':
addToLinkedList(&(proxySettings->serverAddrInfoList),
parseAddrPort(optarg));
foundLocalAddress = true;
break;
case 'n':
proxySettings->noDelay = true;
break;
case 'r':
if (foundRemoteAddress)
{
printUsageAndExit();
}
proxySettings->remoteAddrInfo =
parseRemoteAddrPort(
optarg,
&(proxySettings->remoteAddrPortStrings));
foundRemoteAddress = true;
break;
case 't':
proxySettings->numIOThreads = parseNumIOThreads(optarg);
break;
case '?':
printUsageAndExit();
break;
}
}
while (retVal != -1);
if ((!foundLocalAddress) || (!foundRemoteAddress))
{
printUsageAndExit();
}
return proxySettings;
}
int main(int argc, char *argv[])
{
canStatus stat;
canHandle hnd;
int channelRx;
int channelTx;
if (argc != 3) {
printUsageAndExit(argv[0]);
}
{
char *endPtr = NULL;
errno = 0;
channelRx = strtol(argv[1], &endPtr, 10);
if ( (errno != 0) || ((channelRx == 0) && (endPtr == argv[1])) ) {
printUsageAndExit(argv[0]);
}
channelTx = strtol(argv[2], &endPtr, 10);
if ( (errno != 0) || ((channelTx == 0) && (endPtr == argv[2])) ) {
printUsageAndExit(argv[0]);
}
}
canInitializeLibrary();
hnd = canOpenChannel(channelRx, canOPEN_REQUIRE_EXTENDED);
if (hnd < 0) {
printf("canOpenChannel %d", channelRx);
check("", hnd);
return -1;
}
stat = canBusOff(hnd);
check("canBusOff", stat);
if (stat != canOK) {
goto ErrorExit;
}
stat = canSetNotify(hnd, callback, canNOTIFY_ERROR | canNOTIFY_STATUS, NULL);
check("canSetNotify", stat);
if (stat != canOK) {
goto ErrorExit;
}
stat = canSetBusParams(hnd, bitrate, 0, 0, 0, 0, 0);
check("canSetBusParams", stat);
if (stat != canOK) {
goto ErrorExit;
}
stat = canBusOn(hnd);
check("canBusOn", stat);
if (stat != canOK) {
goto ErrorExit;
}
incBusLoad(channelTx, canOPEN_REQUIRE_EXTENDED, 0);
testBusLoad(hnd);
incBusLoad(channelTx, canOPEN_REQUIRE_EXTENDED, 100);
testBusLoad(hnd);
testBusLoad(hnd);
incBusLoad(channelTx, canOPEN_REQUIRE_EXTENDED, 300);
testBusLoad(hnd);
testBusLoad(hnd);
ErrorExit:
stat = canBusOff(hnd);
check("canBusOff", stat);
stat = canClose(hnd);
check("canClose", stat);
stat = canUnloadLibrary();
check("canUnloadLibrary", stat);
return 0;
}
int main(int argc, char* argv[])
{
/* Primary OptiX objects */
RTcontext context;
RTprogram ray_gen_program;
RTprogram exception_program;
RTprogram miss_program;
RTbuffer buffer;
RTselector dummy_selector;
RTgeometrygroup dummy_group;
RTvariable dummy_object;
RTacceleration dummy_acceleration;
RTprogram selector_program;
RTmaterial material;
RTprogram closest_hit_program;
RTprogram any_hit_program;
RTgeometryinstance instance;
RTgeometry geometry;
RTprogram intersection_program;
RTprogram bounding_box_program;
/* Parameters */
RTvariable result_buffer;
char path_to_ptx[512];
char outfile[512];
unsigned int width = 512u;
unsigned int height = 384u;
int i;
outfile[0] = '\0';
/* Process command line args */
RT_CHECK_ERROR_NO_CONTEXT( sutilInitGlut( &argc, argv ) );
for( i = 1; i < argc; ++i ) {
if( strcmp( argv[i], "--help" ) == 0 || strcmp( argv[i], "-h" ) == 0 ) {
printUsageAndExit( argv[0] );
} else {
fprintf( stderr, "Unknown option '%s'\n", argv[i] );
printUsageAndExit( argv[0] );
}
}
/* Create our objects and set state */
RT_CHECK_ERROR( rtContextCreate( &context ) );
RT_CHECK_ERROR( rtContextSetRayTypeCount( context, 1 ) );
RT_CHECK_ERROR( rtContextSetEntryPointCount( context, 1 ) );
RT_CHECK_ERROR( rtBufferCreate( context, RT_BUFFER_OUTPUT, &buffer ) );
RT_CHECK_ERROR( rtBufferSetFormat( buffer, RT_FORMAT_FLOAT4 ) );
RT_CHECK_ERROR( rtBufferSetSize2D( buffer, width, height ) );
RT_CHECK_ERROR( rtContextDeclareVariable( context, "result_buffer", &result_buffer ) );
RT_CHECK_ERROR( rtVariableSetObject( result_buffer, buffer ) );
sprintf( path_to_ptx, "%s/%s", sutilSamplesPtxDir(), "exceptions_generated_exceptions_programs.cu.ptx" );
RT_CHECK_ERROR( rtProgramCreateFromPTXFile( context, path_to_ptx, "buggy_draw_solid_color", &ray_gen_program ) );
RT_CHECK_ERROR( rtContextSetRayGenerationProgram( context, 0, ray_gen_program ) );
RT_CHECK_ERROR( rtProgramCreateFromPTXFile( context, path_to_ptx, "exception", &exception_program ) );
RT_CHECK_ERROR( rtContextSetExceptionProgram( context, 0, exception_program ) );
RT_CHECK_ERROR( rtProgramCreateFromPTXFile( context, path_to_ptx, "non_terminating_miss_program", &miss_program ) );
RT_CHECK_ERROR( rtContextSetMissProgram( context, 0, miss_program ) );
RT_CHECK_ERROR( rtSelectorCreate( context, &dummy_selector ) );
RT_CHECK_ERROR( rtGeometryGroupCreate( context, &dummy_group ) );
RT_CHECK_ERROR( rtSelectorSetChildCount( dummy_selector, 1 ) );
RT_CHECK_ERROR( rtSelectorSetChild( dummy_selector, 0, dummy_group ) );
RT_CHECK_ERROR( rtProgramCreateFromPTXFile( context, path_to_ptx, "visit", &selector_program ) );
RT_CHECK_ERROR( rtSelectorSetVisitProgram( dummy_selector, selector_program ) );
RT_CHECK_ERROR( rtContextDeclareVariable( context, "dummy_object", &dummy_object ) );
RT_CHECK_ERROR( rtVariableSetObject( dummy_object, dummy_selector ) );
RT_CHECK_ERROR( rtAccelerationCreate( context, &dummy_acceleration ) );
RT_CHECK_ERROR( rtAccelerationSetBuilder( dummy_acceleration,"NoAccel") );
RT_CHECK_ERROR( rtAccelerationSetTraverser( dummy_acceleration,"NoAccel") );
RT_CHECK_ERROR( rtGeometryGroupSetAcceleration( dummy_group, dummy_acceleration) );
RT_CHECK_ERROR( rtProgramCreateFromPTXFile( context, path_to_ptx, "closest_hit", &closest_hit_program ) );
RT_CHECK_ERROR( rtProgramCreateFromPTXFile( context, path_to_ptx, "any_hit", &any_hit_program ) );
RT_CHECK_ERROR( rtMaterialCreate( context, &material ) );
RT_CHECK_ERROR( rtMaterialSetClosestHitProgram( material, 0, closest_hit_program ) );
RT_CHECK_ERROR( rtMaterialSetAnyHitProgram( material, 0, any_hit_program ) );
RT_CHECK_ERROR( rtGeometryInstanceCreate( context, &instance ) );
RT_CHECK_ERROR( rtGeometryInstanceSetMaterialCount( instance, 1 ) );
RT_CHECK_ERROR( rtGeometryInstanceSetMaterial( instance, 0, material ) );
RT_CHECK_ERROR( rtGeometryCreate( context, &geometry ) );
RT_CHECK_ERROR( rtGeometryInstanceSetGeometry( instance, geometry ) );
RT_CHECK_ERROR( rtGeometryGroupSetChildCount( dummy_group, 1 ) );
RT_CHECK_ERROR( rtGeometryGroupSetChild( dummy_group, 0, instance ) );
RT_CHECK_ERROR( rtGeometrySetPrimitiveCount( geometry, 1 ) );
RT_CHECK_ERROR( rtProgramCreateFromPTXFile( context, path_to_ptx, "bounds", &bounding_box_program ) );
RT_CHECK_ERROR( rtGeometrySetBoundingBoxProgram( geometry, bounding_box_program ) );
RT_CHECK_ERROR( rtProgramCreateFromPTXFile( context, path_to_ptx, "intersect", &intersection_program ) );
RT_CHECK_ERROR( rtGeometrySetIntersectionProgram( geometry, intersection_program ) );
/* Enable checking for all exceptions */
RT_CHECK_ERROR( rtContextSetExceptionEnabled( context, RT_EXCEPTION_ALL, 1 ) );
/* Enable printing so rtPrintExceptionDetails has an effect */
RT_CHECK_ERROR( rtContextSetPrintEnabled( context, 1 ) );
/* Run */
RT_CHECK_ERROR( rtContextValidate( context ) );
RT_CHECK_ERROR( rtContextCompile( context ) );
RT_CHECK_ERROR( rtContextLaunch2D( context, 0 /* entry point */, width, height ) );
/* Display image */
if( strlen( outfile ) == 0 ) {
RT_CHECK_ERROR( sutilDisplayBufferInGlutWindow( argv[0], buffer ) );
} else {
RT_CHECK_ERROR( sutilDisplayFilePPM( outfile, buffer ) );
}
/* Clean up */
RT_CHECK_ERROR( rtBufferDestroy( buffer ) );
RT_CHECK_ERROR( rtProgramDestroy( ray_gen_program ) );
RT_CHECK_ERROR( rtContextDestroy( context ) );
return( 0 );
}
Config( int argc, const char ** argv ) {
// set defaults
num_instances_per_mesh = 1;
num_samples = 0; // default means determine from mesh
min_samples_per_face = SAMPLES_PER_FACE;
num_rays = NUM_RAYS;
ground_upaxis = 1;
ground_scale_factor = GROUND_SCALE;
ground_offset_factor = GROUND_OFFSET;
scene_offset_scale = SCENE_OFFSET_SCALE;
scene_maxdistance_scale = SCENE_MAXDISTANCE_SCALE;
scene_offset = 0; // must default to 0
scene_maxdistance = 0;
use_cpu = false;
conserve_memory = false;
#ifdef EIGEN3_ENABLED
filter_mode = bake::VERTEX_FILTER_LEAST_SQUARES;
#else
filter_mode = bake::VERTEX_FILTER_AREA_BASED;
#endif
regularization_weight = REGULARIZATION_WEIGHT;
use_ground_plane_blocker = true;
use_viewer = true;
// parse arguments
for ( int i = 1; i < argc; ++i )
{
std::string arg( argv[i] );
if ( arg.empty() ) continue;
if( arg == "-h" || arg == "--help" )
{
printUsageAndExit( argv[0] );
}
else if( (arg == "-f" || arg == "--file") && i+1 < argc )
{
assert( scene_filename.empty() && "multiple -f (--file) flags found when parsing command line");
scene_filename = argv[++i];
}
else if ((arg == "-o" || arg == "--outfile") && i + 1 < argc)
{
assert(output_filename.empty() && "multiple -o (--outfile) flags found when parsing command line");
output_filename = argv[++i];
}
else if ( (arg == "-i" || arg == "--instances") && i+1 < argc )
{
int n = -1;
if( (sscanf( argv[++i], "%d", &n ) != 1) || n < 1 ) {
printParseErrorAndExit( argv[0], arg, argv[i] );
}
num_instances_per_mesh = static_cast<size_t>(n);
}
else if ( (arg == "-s" || arg == "--samples") && i+1 < argc )
{
if( sscanf( argv[++i], "%d", &num_samples ) != 1 ) {
printParseErrorAndExit( argv[0], arg, argv[i] );
}
}
else if ( (arg == "-t" || arg == "--samples_per_face") && i+1 < argc )
{
if (sscanf( argv[++i], "%d", &min_samples_per_face ) != 1 ) {
printParseErrorAndExit( argv[0], arg, argv[i] );
}
}
else if ((arg == "-d" || arg == "--ray_distance_scale") && i + 1 < argc)
{
if (sscanf(argv[++i], "%f", &scene_offset_scale) != 1) {
printParseErrorAndExit(argv[0], arg, argv[i]);
}
}
else if ((arg == "-m" || arg == "--hit_distance_scale") && i + 1 < argc)
{
if (sscanf(argv[++i], "%f", &scene_maxdistance_scale) != 1) {
printParseErrorAndExit(argv[0], arg, argv[i]);
}
}
else if ((arg == "--ray_distance") && i + 1 < argc)
{
if (sscanf(argv[++i], "%f", &scene_offset) != 1) {
printParseErrorAndExit(argv[0], arg, argv[i]);
}
}
else if ((arg == "--hit_distance") && i + 1 < argc)
{
if (sscanf(argv[++i], "%f", &scene_maxdistance) != 1) {
printParseErrorAndExit(argv[0], arg, argv[i]);
}
}
else if ( (arg == "-r" || arg == "--rays") && i+1 < argc )
{
if( sscanf( argv[++i], "%d", &num_rays ) != 1 ) {
printParseErrorAndExit( argv[0], arg, argv[i] );
}
}
else if ((arg == "-g" || arg == "--ground_setup") && i + 3 < argc)
{
if (sscanf(argv[++i], "%d", &ground_upaxis) != 1 || (ground_upaxis < 0 || ground_upaxis > 5)) {
printParseErrorAndExit(argv[0], arg, argv[i]);
}
if (sscanf(argv[++i], "%f", &ground_scale_factor) != 1) {
printParseErrorAndExit(argv[0], arg, argv[i]);
}
if (sscanf(argv[++i], "%f", &ground_offset_factor) != 1) {
printParseErrorAndExit(argv[0], arg, argv[i]);
}
}
else if ( (arg == "--no_ground_plane" ) ) {
use_ground_plane_blocker = false;
}
else if ((arg == "--no_viewer")) {
use_viewer = false;
}
else if ((arg == "--no_gpu")) {
use_cpu = true;
}
else if ((arg == "--conserve_memory")) {
conserve_memory = true;
}
else if ( (arg == "--no_least_squares" ) ) {
filter_mode = bake::VERTEX_FILTER_AREA_BASED;
}
else if ( (arg == "-w" || arg == "--regularization_weight" ) && i+1 < argc ) {
if( sscanf( argv[++i], "%f", ®ularization_weight ) != 1 ) {
printParseErrorAndExit( argv[0], arg, argv[i] );
}
regularization_weight = std::max( regularization_weight, 0.0f );
}
else
{
std::cerr << "Bad option: '" << arg << "'" << std::endl;
printUsageAndExit( argv[0] );
}
}
if (scene_filename.empty()) {
// Make default filename
const std::string asset_path(ASSET_PATH);
#ifndef NOGZLIB
// Try more interesting gzipped file first
std::string bk3d_path = asset_path + std::string(DEFAULT_BK3DGZ_FILE);
struct stat buf;
if (stat(bk3d_path.c_str(), &buf) == 0) {
scene_filename = bk3d_path;
}
#endif
if (scene_filename.empty()) {
// Fall back to simpler file
std::string obj_path = asset_path + std::string(DEFAULT_BK3D_FILE);
struct stat buf;
if (stat(obj_path.c_str(), &buf) == 0) {
scene_filename = obj_path;
} else {
std::cerr << "Could not find default scene file (" << obj_path << "). Use options to specify one." << std::endl;
printUsageAndExit( argv[0] );
}
}
}
}
void handleConfig(int argc, char **argv, NIChannelCommand *pCommand)
{
RsslInt32 i;
RsslInt32 streamId = -2;
/* Check usage and retrieve operating parameters */
i = 1;
snprintf(proxyHost, sizeof(proxyHost), "");
snprintf(proxyPort, sizeof(proxyPort), "");
snprintf(proxyUserName, sizeof(proxyUserName), "");
snprintf(proxyPasswd, sizeof(proxyPasswd), "");
snprintf(proxyDomain, sizeof(proxyDomain), "");
snprintf(libcryptoName, sizeof(libcryptoName), "");
snprintf(libsslName, sizeof(libsslName), "");
snprintf(libcurlName, sizeof(libcurlName), "");
snprintf(sslCAStore, sizeof(sslCAStore), "");
while(i < argc)
{
if (strcmp("-?", argv[i]) == 0)
{
printUsageAndExit(argv[0]);
}
if (strcmp("-libsslName", argv[i]) == 0)
{
i += 2;
snprintf(libsslName, 255, "%s", argv[i - 1]);
}
else if (strcmp("-libcryptoName", argv[i]) == 0)
{
i += 2;
snprintf(libcryptoName, 255, "%s", argv[i - 1]);
}
else if (strcmp("-libcurlName", argv[i]) == 0)
{
i += 2;
snprintf(libcurlName, 255, "%s", argv[i - 1]);
}
else if (strcmp("-castore", argv[i]) == 0)
{
i += 2;
snprintf(sslCAStore, 255, "%s", argv[i - 1]);
pCommand->cOpts.rsslConnectOptions.encryptionOpts.openSSLCAStore = sslCAStore;
}
else if(strcmp("-uname", argv[i]) == 0)
{
i += 2;
snprintf(pCommand->username.data, MAX_BUFFER_LENGTH, "%s", argv[i-1]);
pCommand->username.length = (RsslUInt32)strlen(pCommand->username.data);
}
else if(strcmp("-at", argv[i]) == 0)
{
i += 2;
snprintf(pCommand->authenticationToken.data, MAX_AUTHN_LENGTH, "%s", argv[i-1]);
pCommand->authenticationToken.length = (RsslUInt32)strlen(pCommand->authenticationToken.data);
}
else if(strcmp("-ax", argv[i]) == 0)
{
i += 2;
snprintf(pCommand->authenticationExtended.data, MAX_AUTHN_LENGTH, "%s", argv[i-1]);
pCommand->authenticationExtended.length = (RsslUInt32)strlen(pCommand->authenticationExtended.data);
}
else if(strcmp("-aid", argv[i]) == 0)
{
i += 2;
snprintf(pCommand->applicationId.data, MAX_BUFFER_LENGTH, "%s", argv[i-1]);
pCommand->applicationId.length = (RsslUInt32)strlen(pCommand->applicationId.data);
}
else if (strcmp("-ph", argv[i]) == 0)
{
i += 2;
snprintf(proxyHost, sizeof(proxyHost), "%s", argv[i - 1]);
pCommand->cOpts.rsslConnectOptions.proxyOpts.proxyHostName = proxyHost;
}
else if (strcmp("-pp", argv[i]) == 0)
{
i += 2;
snprintf(proxyPort, sizeof(proxyPort), "%s", argv[i - 1]);
pCommand->cOpts.rsslConnectOptions.proxyOpts.proxyPort = proxyPort;
}
else if (strcmp("-plogin", argv[i]) == 0)
{
i += 2;
snprintf(proxyUserName, sizeof(proxyUserName), "%s", argv[i - 1]);
pCommand->cOpts.rsslConnectOptions.proxyOpts.proxyUserName = proxyUserName;
}
else if (strcmp("-ppasswd", argv[i]) == 0)
{
i += 2;
snprintf(proxyPasswd, sizeof(proxyPasswd), "%s", argv[i - 1]);
pCommand->cOpts.rsslConnectOptions.proxyOpts.proxyPasswd = proxyPasswd;
}
else if (strcmp("-pdomain", argv[i]) == 0)
{
i += 2;
snprintf(proxyDomain, sizeof(proxyDomain), "%s", argv[i - 1]);
pCommand->cOpts.rsslConnectOptions.proxyOpts.proxyDomain = proxyDomain;
}
else if(strcmp("-x", argv[i]) == 0)
{
i++;
xmlTrace = RSSL_TRUE;
snprintf(traceOutputFile, 128, "RsslNIVAProvider\0");
}
else if (strcmp("-tcp", argv[i]) == 0)
{
char *pToken, *pToken2, *pSaveToken, *pSaveToken2;
/* Syntax:
* -tcp hostname:port SERVICE_NAME mp:TRI,mp:.DJI
*/
/* Hostname */
if (++i >= argc) { printf("Error: -tcp: Missing hostname.\n"); printUsageAndExit(argv[0]); }
pToken = strtok(argv[i], ":");
if (!pToken) { printf("Error: -tcp: Missing hostname.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->hostName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->hostName.length = (RsslUInt32)strlen(pCommand->hostName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.unified.address = pCommand->hostName.data;
/* Port */
pToken = strtok(NULL, ":");
if (!pToken) { printf("Error: -tcp: Missing serviceName.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->port.data, MAX_BUFFER_LENGTH, pToken);
pCommand->port.length = (RsslUInt32)strlen(pCommand->port.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.unified.serviceName = pCommand->port.data;
/* Item Service Name */
i++;
pToken = argv[i];
if (!pToken) { printf("Error: -tcp: Missing item service name.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->serviceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->serviceName.length = (RsslUInt32)strlen(pCommand->serviceName.data);
/* Item List */
if (++i >= argc) { printf("Error: -tcp: Missing item.\n"); printUsageAndExit(argv[0]); }
pToken = strtok_r(argv[i], ",", &pSaveToken);
while(pToken)
{
RsslNIItemInfo *pItemInfo;
/* domain */
pToken2 = strtok_r(pToken, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -tcp: Missing item.\n"); printUsageAndExit(argv[0]); }
if (0 == strcmp(pToken2, "mp"))
{
if (pCommand->marketPriceItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketPriceItemInfo[pCommand->marketPriceItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_PRICE;
++pCommand->marketPriceItemCount;
}
else
{
printf("Number of items for Market Price domain exceeded CHAN_CMD_MAX_ITEMS (%d)\n", CHAN_CMD_MAX_ITEMS);
printUsageAndExit(argv[0]);
}
}
else if (0 == strcmp(pToken2, "mbo"))
{
if (pCommand->marketByOrderItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketByOrderItemInfo[pCommand->marketByOrderItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_BY_ORDER;
++pCommand->marketByOrderItemCount;
}
else
{
printf("Number of items for Market By Order domain exceeded CHAN_CMD_MAX_ITEMS (%d)\n", CHAN_CMD_MAX_ITEMS);
printUsageAndExit(argv[0]);
}
}
else
{
printf("Unknown item domain: %s\n", pToken2);
printUsageAndExit(argv[0]);
}
/* name */
pToken2 = strtok_r(NULL, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -tcp: Missing item name.\n"); printUsageAndExit(argv[0]); }
snprintf(pItemInfo->Itemname, 128, "%s", pToken2);
pItemInfo->isActive = RSSL_TRUE;
pItemInfo->streamId = streamId--;
pToken = strtok_r(NULL, ",", &pSaveToken);
}
i++;
}
else if (strcmp("-encryptedSocket", argv[i]) == 0)
{
char *pToken, *pToken2, *pSaveToken, *pSaveToken2;
/* Syntax:
* -encryptedSocket hostname:port SERVICE_NAME mp:TRI,mp:.DJI
*/
pCommand->cOpts.rsslConnectOptions.connectionType = RSSL_CONN_TYPE_ENCRYPTED;
pCommand->cOpts.rsslConnectOptions.encryptionOpts.encryptedProtocol = RSSL_CONN_TYPE_SOCKET;
/* Hostname */
if (++i >= argc) { printf("Error: -encryptedSocket: Missing hostname.\n"); printUsageAndExit(argv[0]); }
pToken = strtok(argv[i], ":");
if (!pToken) { printf("Error: -encryptedSocket: Missing hostname.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->hostName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->hostName.length = (RsslUInt32)strlen(pCommand->hostName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.unified.address = pCommand->hostName.data;
/* Port */
pToken = strtok(NULL, ":");
if (!pToken) { printf("Error: -encryptedSocket: Missing serviceName.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->port.data, MAX_BUFFER_LENGTH, pToken);
pCommand->port.length = (RsslUInt32)strlen(pCommand->port.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.unified.serviceName = pCommand->port.data;
/* Item Service Name */
i++;
pToken = argv[i];
if (!pToken) { printf("Error: -encryptedSocket: Missing item service name.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->serviceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->serviceName.length = (RsslUInt32)strlen(pCommand->serviceName.data);
/* Item List */
if (++i >= argc) { printf("Error: -encryptedSocket: Missing item.\n"); printUsageAndExit(argv[0]); }
pToken = strtok_r(argv[i], ",", &pSaveToken);
while (pToken)
{
RsslNIItemInfo *pItemInfo;
/* domain */
pToken2 = strtok_r(pToken, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -encryptedSocket: Missing item.\n"); printUsageAndExit(argv[0]); }
if (0 == strcmp(pToken2, "mp"))
{
if (pCommand->marketPriceItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketPriceItemInfo[pCommand->marketPriceItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_PRICE;
++pCommand->marketPriceItemCount;
}
else
{
printf("Number of items for Market Price domain exceeded CHAN_CMD_MAX_ITEMS (%d)\n", CHAN_CMD_MAX_ITEMS);
printUsageAndExit(argv[0]);
}
}
else if (0 == strcmp(pToken2, "mbo"))
{
if (pCommand->marketByOrderItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketByOrderItemInfo[pCommand->marketByOrderItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_BY_ORDER;
++pCommand->marketByOrderItemCount;
}
else
{
printf("Number of items for Market By Order domain exceeded CHAN_CMD_MAX_ITEMS (%d)\n", CHAN_CMD_MAX_ITEMS);
printUsageAndExit(argv[0]);
}
}
else
{
printf("Unknown item domain: %s\n", pToken2);
printUsageAndExit(argv[0]);
}
/* name */
pToken2 = strtok_r(NULL, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -encryptedSocket: Missing item name.\n"); printUsageAndExit(argv[0]); }
snprintf(pItemInfo->Itemname, 128, "%s", pToken2);
pItemInfo->isActive = RSSL_TRUE;
pItemInfo->streamId = streamId--;
pToken = strtok_r(NULL, ",", &pSaveToken);
}
i++;
}
else if (strcmp("-encryptedHttp", argv[i]) == 0)
{
char *pToken, *pToken2, *pSaveToken, *pSaveToken2;
#ifdef LINUX
printf("Error: -encryptedHttp: WinInet HTTP connection not supported on Linux.\n");
printUsageAndExit(argv[0]);
#endif
/* Syntax:
* -encryptedSocket hostname:port SERVICE_NAME mp:TRI,mp:.DJI
*/
pCommand->cOpts.rsslConnectOptions.connectionType = RSSL_CONN_TYPE_ENCRYPTED;
pCommand->cOpts.rsslConnectOptions.encryptionOpts.encryptedProtocol = RSSL_CONN_TYPE_HTTP;
/* Hostname */
if (++i >= argc) { printf("Error: -encryptedSocket: Missing hostname.\n"); printUsageAndExit(argv[0]); }
pToken = strtok(argv[i], ":");
if (!pToken) { printf("Error: -encryptedSocket: Missing hostname.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->hostName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->hostName.length = (RsslUInt32)strlen(pCommand->hostName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.unified.address = pCommand->hostName.data;
/* Port */
pToken = strtok(NULL, ":");
if (!pToken) { printf("Error: -encryptedSocket: Missing serviceName.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->port.data, MAX_BUFFER_LENGTH, pToken);
pCommand->port.length = (RsslUInt32)strlen(pCommand->port.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.unified.serviceName = pCommand->port.data;
/* Item Service Name */
i++;
pToken = argv[i];
if (!pToken) { printf("Error: -encryptedSocket: Missing item service name.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->serviceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->serviceName.length = (RsslUInt32)strlen(pCommand->serviceName.data);
/* Item List */
if (++i >= argc) { printf("Error: -encryptedSocket: Missing item.\n"); printUsageAndExit(argv[0]); }
pToken = strtok_r(argv[i], ",", &pSaveToken);
while (pToken)
{
RsslNIItemInfo *pItemInfo;
/* domain */
pToken2 = strtok_r(pToken, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -encryptedSocket: Missing item.\n"); printUsageAndExit(argv[0]); }
if (0 == strcmp(pToken2, "mp"))
{
if (pCommand->marketPriceItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketPriceItemInfo[pCommand->marketPriceItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_PRICE;
++pCommand->marketPriceItemCount;
}
else
{
printf("Number of items for Market Price domain exceeded CHAN_CMD_MAX_ITEMS (%d)\n", CHAN_CMD_MAX_ITEMS);
printUsageAndExit(argv[0]);
}
}
else if (0 == strcmp(pToken2, "mbo"))
{
if (pCommand->marketByOrderItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketByOrderItemInfo[pCommand->marketByOrderItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_BY_ORDER;
++pCommand->marketByOrderItemCount;
}
else
{
printf("Number of items for Market By Order domain exceeded CHAN_CMD_MAX_ITEMS (%d)\n", CHAN_CMD_MAX_ITEMS);
printUsageAndExit(argv[0]);
}
}
else
{
printf("Unknown item domain: %s\n", pToken2);
printUsageAndExit(argv[0]);
}
/* name */
pToken2 = strtok_r(NULL, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -encryptedSocket: Missing item name.\n"); printUsageAndExit(argv[0]); }
snprintf(pItemInfo->Itemname, 128, "%s", pToken2);
pItemInfo->isActive = RSSL_TRUE;
pItemInfo->streamId = streamId--;
pToken = strtok_r(NULL, ",", &pSaveToken);
}
i++;
}
else if (strcmp("-segmentedMulticast", argv[i]) == 0)
{
char *pToken, *pToken2, *pSaveToken, *pSaveToken2;
/* Syntax:
* -segmentedmulticast hostname:port SERVICE_NAME mp:TRI,mp:.DJI
*/
pCommand->cOpts.rsslConnectOptions.connectionType = RSSL_CONN_TYPE_RELIABLE_MCAST;
/* Hostname */
i++;
pToken = strtok(argv[i], ":");
if (!pToken) { printf("Error: -segmentedMulticast: Missing sendAddress.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->hostName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->hostName.length = (RsslUInt32)strlen(pCommand->hostName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.sendAddress = pCommand->hostName.data;
/* Port */
pToken = strtok(NULL, ":");
if (!pToken) { printf("Error: -segmentedMulticast: Missing sendPort.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->port.data, MAX_BUFFER_LENGTH, pToken);
pCommand->port.length = (RsslUInt32)strlen(pCommand->port.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.sendServiceName = pCommand->port.data;
/* Interface name */
pToken = strtok(NULL, ":");
if (!pToken)
{
pCommand->interfaceName.length = 0;
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.interfaceName = NULL;
}
else
{
snprintf(pCommand->interfaceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->interfaceName.length = (RsslUInt32)strlen(pCommand->interfaceName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.interfaceName = pCommand->interfaceName.data;
}
/* Recv Hostname */
i++;
pToken = strtok(argv[i], ":");
if (!pToken) { printf("Error: -segmentedMulticast: Missing recvAddress.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->recvHostName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->recvHostName.length = (RsslUInt32)strlen(pCommand->recvHostName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.recvAddress = pCommand->recvHostName.data;
/* Recv Port */
pToken = strtok(NULL, ":");
if (!pToken) { printf("Error: -segmentedMulticast: Missing recvPort.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->recvPort.data, MAX_BUFFER_LENGTH, pToken);
pCommand->recvPort.length = (RsslUInt32)strlen(pCommand->recvPort.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.recvServiceName = pCommand->recvPort.data;
i++;
pToken = argv[i];
if (!pToken) { printf("Error: -segmentedMulticast: Missing unicast Port.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->unicastServiceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->unicastServiceName.length = (RsslUInt32)strlen(pCommand->unicastServiceName.data);
pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.unicastServiceName = pCommand->unicastServiceName.data;
/* Item Service Name */
i++;
pToken = argv[i];
if (!pToken) { printf("Error: -segmentedMulticast: Missing Service Name.\n"); printUsageAndExit(argv[0]); }
snprintf(pCommand->serviceName.data, MAX_BUFFER_LENGTH, pToken);
pCommand->serviceName.length = (RsslUInt32)strlen(pCommand->serviceName.data);
/* Item List */
i++;
pToken = strtok_r(argv[i], ",", &pSaveToken);
if (!pToken) { printf("Error: -segmentedMulticast: Missing Items.\n"); printUsageAndExit(argv[0]); }
while(pToken)
{
RsslNIItemInfo *pItemInfo;
/* domain */
pToken2 = strtok_r(pToken, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -segmentedMulticast: Missing Items.\n"); printUsageAndExit(argv[0]); }
if (0 == strcmp(pToken2, "mp") && pCommand->marketPriceItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketPriceItemInfo[pCommand->marketPriceItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_PRICE;
++pCommand->marketPriceItemCount;
}
else if (0 == strcmp(pToken2, "mbo") && pCommand->marketByOrderItemCount < CHAN_CMD_MAX_ITEMS)
{
pItemInfo = &pCommand->marketByOrderItemInfo[pCommand->marketByOrderItemCount];
pItemInfo->domainType = RSSL_DMT_MARKET_BY_ORDER;
++pCommand->marketByOrderItemCount;
}
else
{
printf("Unknown item domain: %s\n", pToken2);
printUsageAndExit(argv[0]);
}
/* name */
pToken2 = strtok_r(NULL, ":", &pSaveToken2);
if (!pToken2) { printf("Error: -segmentedMulticast: Missing Item name.\n"); printUsageAndExit(argv[0]); }
snprintf(pItemInfo->Itemname, 128, "%s", pToken2);
pItemInfo->isActive = RSSL_TRUE;
pItemInfo->streamId = streamId--;
pToken = strtok_r(NULL, ",", &pSaveToken);
}
i++;
printf("sendAddress: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.sendAddress);
printf("SendPort: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.sendServiceName);
printf("RecvAddress: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.recvAddress);
printf("RecvPort: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.recvServiceName);
printf("UnicastPort: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.unicastServiceName);
printf("InterfaceName: %s\n", pCommand->cOpts.rsslConnectOptions.connectionInfo.segmented.interfaceName);
}
else if(strcmp("-runtime", argv[i]) == 0)
{
i += 2;
timeToRun = atoi(argv[i-1]);
}
else if (strcmp("-cache", argv[i]) == 0)
{
i += 1;
cacheCommandlineOption = RSSL_TRUE;
}
else
{
printf("Error: Unrecognized option: %s\n\n", argv[i]);
printUsageAndExit(argv[0]);
}
}
}
