//-------------------------------------------------------------------------------------
PyObject* MethodDescription::call(PyObject* func, PyObject* args)
{
PyObject* pyResult = NULL;
if (!PyCallable_Check(func))
{
PyErr_Format(PyExc_TypeError, "MethodDescription::call: method[%s] call attempted on a error object!",
getName());
}
else
{
if(args == NULL)
{
pyResult = PyObject_CallObject(func, NULL);
}
else
{
if(checkArgs(args))
pyResult = PyObject_CallObject(func, args);
}
}
if (PyErr_Occurred())
{
if (isExposed() && PyErr_ExceptionMatches(PyExc_TypeError))
{
WARNING_MSG(fmt::format("MethodDescription::call: {} is exposed of method, if there is a missing arguments error, "
"try adding callerEntityID, For example: \ndef func(msg): => def func(callerEntityID, msg):\n",
this->getName()));
}
PyErr_PrintEx(0);
}
return pyResult;
}
int main ( int argc, char **argv ) {
double time_spent;
struct timeval tv1, tv2;
#ifdef DEBUG
printf("IN MAIN\n");
#endif
/*Displays Help Command*/
if(argc!=MIN_REQUIRED) { help("WRONG NUMBER OF ARGUMENTS");}
if(!strcmp(argv[1], "-h")){ help("HELP: ");}
if(argc == 2){ checkArgs(argv[1]);}
gettimeofday(&tv1, NULL);
readFile(argv[1]);
populateMemory();
readMemory();
gettimeofday(&tv2, NULL);
/*printf("%x", 0x3f%0x10);*/
time_spent= (double)(tv2.tv_usec - tv1.tv_usec)/1000000 + (double)(tv2.tv_sec - tv1.tv_sec);
printf("\n=========\n TIME REQUIRED: %.0f microseconds\n=========\n", time_spent* 1000000);
#ifdef DEBUG
printf("OUT OF MAIN\n");
#endif
return 0;
}
int _tmain(int argc, char* argv[])
{
char *inFile = NULL;
outFormat format = NOTSET;
int rowStart = -1;
int rowEnd = -1;
packets parsedList;
#ifdef _DEBUG
testparseQueryString();
testParseFile();
#endif
printf("Content-Type: text/xml\n\n");
if (!checkArgs(argc, argv, &inFile, format, rowStart, rowEnd))
{
printUsage();
return -1;
}
parseFile(inFile, rowStart, rowEnd, parsedList);
outputInfo(parsedList, format);
return 0;
}
int main(int argc, char** argv) {
checkArgs(argc, argv);
copyFile(argv[1], argv[2]);
return 0;
}
void GlobalArgsTabu::retrieve(int argc, char *argv[]) {
int opt;
while ((opt = getopt(argc, argv, "m:o:t:r:f:")) != -1) {
switch(opt) {
case 'm':
ttIterationsWoModification = std::stoul(optarg);
break;
case 'o':
maxOccurencesFrequentlyEncountered = std::stoul(optarg);
break;
case 't':
maxCandidateTriggerEscape = std::stoul(optarg);
break;
case 'r':
randomStepsEscape = std::stoul(optarg);
break;
case 'f':
filePath = optarg;
break;
default:
break;
}
}
checkArgs();
}
/*
Main method.
*/
int main(int argc, char *argv[])
{
/* Hexadecimal, Octal, Character, Hexadecimal and ASCII, Length, Offset */
int optionFlags[] = {ON, OFF, OFF, OFF, OFF, OFF};
/* Length bytes of input to interpret, Offset bytes from beginning */
int optionValues[] = {0, 0};
int *flags = optionFlags;
int *values = optionValues;
int i = 1;
int checkArgsValidation = 0;
if(argv[1] == NULL)
{
printf("No arguments specified. Qutting program...\n");
return 1;
}
for(i = 1; i < argc; i++)
{
checkArgsValidation = checkArgs(i, argv, flags, values);
if(checkArgsValidation == 0)
{
break;
}
}
return 0;
}
int main ( int argc, char **argv ) {
double time_spent;
struct timeval tv1, tv2;
#ifdef DEBUG
printf("IN MAIN\n");
#endif
/*Check Arguments*/
if(argc!=MIN_REQUIRED) help("WRONG NUMBER OF ARGUMENTS");
if(!strcmp(argv[1], "-h")) help("HELP: ");
if(argc == 2) checkArgs(argv[1]);
/*Tracks time*/
gettimeofday(&tv1, NULL);
/*Reads File and Populates Data*/
readFile( argv[1]);
/*Populates Memory*/
populateMemory();
/*Runs through fetch decode execute loop*/
readMemory();
/*Tracks time*/
gettimeofday(&tv2, NULL);
time_spent= (double)(tv2.tv_usec - tv1.tv_usec)/1000000 + (double)(tv2.tv_sec - tv1.tv_sec);
printf("\n=========\n TIME REQUIRED: %.0f microseconds\n=========\n", time_spent* 1000000);
#ifdef DEBUG
printf("OUT OF MAIN\n");
#endif
return 0;
}
CMPIBoolean __eft_evaluateUsingAccessor (
CONST CMPISelectExp* se,
CMPIAccessor *accessor,
void *parm, CMPIStatus* rc)
{
CMPIContext *ctx;
CMPIBroker *broker;
if (!checkArgs(se, rc) || !checkArgs(accessor, rc))
{
return 0;
}
broker = tool_mm_get_broker ( (void**)&ctx);
return( ( (NativeCMPIBrokerFT*)broker->bft) )->
selExp_evaluateUsingAccessor (se, accessor ,parm, rc);
}
CMPIBoolean __eft_evaluate (
CONST CMPISelectExp * exp,
CONST CMPIInstance * inst,
CMPIStatus * rc )
{
CMPIContext *ctx;
CMPIBroker *broker;
if (!checkArgs(exp, rc) || !checkArgs(inst, rc))
{
return 0;
}
broker = tool_mm_get_broker ( (void**)&ctx);
return(((NativeCMPIBrokerFT*)broker->bft))->selExp_evaluate (exp, inst ,rc);
}
Value testingGradient_AST(argList *a) {
checkArgs(a, 0);
long long numFrames = (long long)OPTNUM("frames", 1000);
long long width = (long long)OPTNUM("width", 200);
long long height = (long long)OPTNUM("height", 200);
////////////////////
// Error Checking //
////////////////////
if(numFrames < 0 || width < 0 || height < 0)
MkvsynthError("width, height, and frames must be numbers greater than 0");
MkvsynthOutput *output = createOutputBuffer();
///////////////
// Meta Data //
///////////////
output->metaData->colorspace = MKVS_RGB48;
output->metaData->width = width;
output->metaData->height = height;
output->metaData->fpsNumerator = 60;
output->metaData->fpsDenominator = 1;
////////////////////////
// Pthread Parameters //
////////////////////////
struct TestingGradientParams *params = malloc(sizeof(struct TestingGradientParams));
params->frames = numFrames;
params->output = output;
mkvsynthQueue((void *)params, testingGradient);
RETURNCLIP(output);
}
// H=gradHist(M,O,[...]) - see gradientHist.m
void mGradHist( int nl, mxArray *pl[], int nr, const mxArray *pr[] ) {
int h, w, d, hb, wb, nChns, binSize, nOrients, softBin, useHog;
bool full; float *M, *O, *H, clipHog;
checkArgs(nl,pl,nr,pr,1,3,2,8,&h,&w,&d,mxSINGLE_CLASS,(void**)&M);
O = (float*) mxGetPr(pr[1]);
if( mxGetM(pr[1])!=h || mxGetN(pr[1])!=w || d!=1 ||
mxGetClassID(pr[1])!=mxSINGLE_CLASS ) mexErrMsgTxt("M or O is bad.");
binSize = (nr>=3) ? (int) mxGetScalar(pr[2]) : 8;
nOrients = (nr>=4) ? (int) mxGetScalar(pr[3]) : 9;
softBin = (nr>=5) ? (int) mxGetScalar(pr[4]) : 1;
useHog = (nr>=6) ? (int) mxGetScalar(pr[5]) : 0;
clipHog = (nr>=7) ? (float) mxGetScalar(pr[6]) : 0.2f;
full = (nr>=8) ? (bool) (mxGetScalar(pr[7])>0) : false;
hb = h/binSize; wb = w/binSize;
nChns = useHog== 0 ? nOrients : (useHog==1 ? nOrients*4 : nOrients*3+5);
pl[0] = mxCreateMatrix3(hb,wb,nChns,mxSINGLE_CLASS,1,(void**)&H);
if( nOrients==0 ) return;
if( useHog==0 ) {
gradHist( M, O, H, h, w, binSize, nOrients, softBin, full );
} else if(useHog==1) {
hog( M, O, H, h, w, binSize, nOrients, softBin, full, clipHog );
} else {
fhog( M, O, H, h, w, binSize, nOrients, softBin, clipHog );
}
}
/** Searches for a config file in the command-line arguments,
* environment, and finally in a default location. WARNING:
* if no valid config file is found, the value of the result
* parameter is unspecified! Always make sure to check the return
* value!
* @param argc Argument count
* @param argv Argument list
* @param result std::string reference to store the path, if any
* @return true if a config file is found, false otherwise.
*/
bool findConfigFile(int argc, char** argv, string& result)
{
if ( checkArgs(argc, argv, result) ) return true;
else if ( checkEnv(result) ) return true;
else if ( checkDefault(result) ) return true;
else return false;
}
int main(int args, char *argv[]){
int option = checkArgs(args, argv);
int returnVal = 0;
switch (option){
case 1:{ //-review
XmElem *top = openXmElemTree( stdin );
if (top == NULL){
return EXIT_FAILURE;
}
returnVal = review(top, stdout);
mxCleanElem (top);
break;
}
case 2:{ //-cat
returnVal = combineFiles(args, argv, stdout);
break;
}
case 3:{ //-keep
XmElem *top = openXmElemTree( stdin );
if (top == NULL){
return EXIT_FAILURE;
}
returnVal = selects(top, KEEP, argv[2], stdout);
mxCleanElem(top);
break;
}
case 4:{ //-discard
XmElem *top = openXmElemTree( stdin );
if (top == NULL){
return EXIT_FAILURE;
}
returnVal = selects(top, DISCARD, argv[2], stdout);
mxCleanElem(top);
break;
}
case 5:{ //-lib
XmElem *top = openXmElemTree( stdin );
if (top == NULL){
return EXIT_FAILURE;
}
returnVal = libFormat(top, stdout);
mxCleanElem(top);
break;
}
case 6:{ //-bib
XmElem *top = openXmElemTree( stdin );
if (top == NULL){
return EXIT_FAILURE;
}
returnVal = bibFormat(top, stdout);
mxCleanElem(top);
break;
}
default://invalid command
return EXIT_FAILURE;
}
return returnVal;
}
TEST_F( Factory_TEST
, StoreAndGetObjectWithAGroupWith2Params__ObjectToStoreAndGetAreEqual )
{
typedef Factory< Models::IModel
, int
, int > ModelFactory2;
EXPECT_CALL( *model__
, checkArgs( 3
, 2 ) );
std::shared_ptr< int > int_ptr_1( new int( 3 ) );
std::shared_ptr< int > int_ptr_2( new int( 2 ) );
ModelFactory2::store( "tt2"
, "testArgs2"
, Models::MockModel::createMockModelWithArg );
std::shared_ptr< Models::IModel > returned_object =
ModelFactory2::get( "tt2"
, "testArgs2"
, int_ptr_1
, int_ptr_2 );
EXPECT_EQ( static_cast< Models::IModel* >( model__ )
, returned_object.get() );
}
int main(int argc, char* argv[]){
//Check Command line arguments
if(checkArgs(argc, argv)){
return -1;
}
//Create new inetSock from portNumber argument
inetSock servSock(argv[1]);
//Sets listening socket to non-blocking
// fcntl(servSock.getFileDescriptor(), F_SETFL, O_NONBLOCK);
std::string servHandle = getHandle();
//Listen on file descriptor
listen(servSock.getFileDescriptor(), QUEUE_LENGTH); //QUEUE_LENGTH macro defined
//Client/connection information
std::vector< std::pair<std::string, inetSock> > clients;
int tempFD;
struct sockaddr_in tempAddr;
socklen_t tempLen = sizeof(struct sockaddr_in);
while(1){
std::cout << "Waiting on peer connection..." << std::endl;
tempFD = accept(servSock.getFileDescriptor(), (struct sockaddr*)&tempAddr, &tempLen);
if(errno != EWOULDBLOCK && errno != EAGAIN){
fcntl(tempFD, F_SETFL, fcntl(tempFD, F_GETFL) & (~O_NONBLOCK));
chatProcess(tempFD, servHandle);
}
}
return 0;
}
int
main(int argc, char *argv[]) {
checkArgs(argc, argv);
GetTime();
inputProfile();
if (makeRP)
MakeRegionProfile();
if (makeSP)
MakeStackProfile();
if (makeObjP)
MakeObjectProfile(regionNo);
if (printProfile)
PrintProfile();
if (printRegion)
PrintRegion(regionNo2);
if (printSomeStat)
PrintSomeStat();
if (findPrgPoint)
FindProgramPoint(prgPoint);
if (interact)
interactive();
return EXIT_SUCCESS;
}
int main (int argc, char* argv [])
{
int sockConnection, port;
char str[128];
count = 0;
checkArgs(argc, argv);
sscanf(argv[2],"%d", &port);
signal(SIGINT,sigHandler);
if(initServerSocket(&serverSock, argv[1], port)!=0)
{
sprintf(str,"I can't use %s:%d\n",argv[1],port);
perror(str);
return -1;
}
if (count < 50) {
while(waitConexion(serverSock,&sockConnection)!=-1)
{
pthread_create(&threadArray[count], NULL, attendClientThread, (void *) sockConnection);
count++;
}
} else {
printf("Server busy, aborting...\n");
return -1;
}
return 0;
}
int main (int argc, char* argv [])
{
char str01[32], str02[32];
unsigned int n1, n2 , result01, result02;
int sock, port;
checkArgs(argc, argv);
sscanf(argv[2],"%d", &port);
if(connectToServer(&sock, argv[1], port)!=0)
{
sprintf(str01,"I couldn't connect to %s:%d\n",argv[1],port);
perror(str01);
return -1;
}
printf ("give me a natural number: ");
fgets (str01,32,stdin);
sscanf(str01,"%u",&n1);
printf ("give me a natural number: ");
fgets(str02,32,stdin);
sscanf(str02,"%u",&n2);
remoteGCD(sock, n1, n2, &result01);
printf("gcd(%u,%u)=%u\n", n1, n2, result01);
remoteLCM(sock,n1, n2, &result02);
printf("lcm(%u,%u)=%u\n", n1, n2, result02);
close(sock);
return 0;
}
int main(int argc, char* argv[])
{
/* create VirtualMachine */
VM SVM;
SVM.errorCode = 0;
SVM.mode = 0;
/* check arguments */
if (checkArgs(argc, argv, &SVM.mode)) return 1;
/* check configuration file */
checkConfig(&SVM.config, &SVM.errorCode);
if (SVM.errorCode != 0) return 1;
/* initialization memory */
SVM.memory.space = createMemory(SVM.config.memorySize);
if(SVM.memory.space == NULL) return 1;
SVM.memory.currentAddress = SVM.config.memorySize - 1;
/* initialization stack */
SVM.stack = initStack();
/* start */
if (!runVM(&SVM, argv[1])) return 1;
return 0;
}
static CMPIEnumeration * __eft_clone (
CONST CMPIEnumeration * enumeration,
CMPIStatus * rc )
{
CMPIStatus tmp;
struct native_enum * e = (struct native_enum *) enumeration;
CMPIArray * data;
if (!checkArgs(enumeration, rc))
{
return 0;
}
data = CMClone ( e->data, &tmp );
if (tmp.rc != CMPI_RC_OK)
{
CMSetStatus ( rc, CMPI_RC_ERR_FAILED );
return NULL;
}
return
(CMPIEnumeration *) __new_enumeration (
TOOL_MM_NO_ADD,
data,
rc );
}
// [Gx,Gy] = grad2(I) - see gradient2.m
void mGrad2( int nl, mxArray *pl[], int nr, const mxArray *pr[] ) {
int h, w, d; float *I, *Gx, *Gy;
checkArgs(nl,pl,nr,pr,1,2,1,1,&h,&w,&d,mxSINGLE_CLASS,(void**)&I);
if(h<2 || w<2) mexErrMsgTxt("I must be at least 2x2.");
pl[0]= mxCreateMatrix3( h, w, d, mxSINGLE_CLASS, 0, (void**) &Gx );
pl[1]= mxCreateMatrix3( h, w, d, mxSINGLE_CLASS, 0, (void**) &Gy );
grad2( I, Gx, Gy, h, w, d );
}
// gradMagNorm( M, S, norm ) - operates on M - see gradientMag.m
void mGradMagNorm( int nl, mxArray *pl[], int nr, const mxArray *pr[] ) {
int h, w, d; float *M, *S, norm;
checkArgs(nl,pl,nr,pr,0,0,3,3,&h,&w,&d,mxSINGLE_CLASS,(void**)&M);
if( mxGetM(pr[1])!=h || mxGetN(pr[1])!=w || d!=1 ||
mxGetClassID(pr[1])!=mxSINGLE_CLASS ) mexErrMsgTxt("M or S is bad.");
S = (float*) mxGetPr(pr[1]); norm = (float) mxGetScalar(pr[2]);
gradMagNorm(M,S,h,w,norm);
}
//Unified core function
static bool run(KernelArgs* args) {
if(!checkArgs(args)) {
printf("Arguments are invalid\n");
return false;
}
mandelbrot_scalar(args);
return true;
}
static CMPIContext * __cft_clone ( CONST CMPIContext * ctx, CMPIStatus * rc )
{
if (!checkArgs(ctx, rc))
{
return 0;
}
CMSetStatus ( rc, CMPI_RC_ERR_NOT_SUPPORTED );
return NULL;
}
Console_Error Console_putCursor(short x, short y) {
Console_Error error = checkArgs(x, y, 0, 0);
if(error != CONSOLE_OK) return error;
COORD coord = {x, y};
SetConsoleCursorPosition(hConsole, coord);
return CONSOLE_OK;
}
int main(int argc, char **argv)
{
int sctpInstance;
SCTP_ulpCallbacks terminalUlp;
SCTP_InstanceParameters instanceParameters;
sctp_initLibrary();
/* trapping Ctrl-C */
signal(SIGINT, finish);
/* trapping Ctrl-backslash */
signal (SIGQUIT, finish);
/* initialize the terminal_ulp variable */
terminalUlp.dataArriveNotif = &dataArriveNotif;
terminalUlp.sendFailureNotif = &sendFailureNotif;
terminalUlp.networkStatusChangeNotif = &networkStatusChangeNotif;
terminalUlp.communicationUpNotif = &communicationUpNotif;
terminalUlp.communicationLostNotif = &communicationLostNotif;
terminalUlp.communicationErrorNotif = &communicationErrorNotif;
terminalUlp.restartNotif = &restartNotif;
terminalUlp.shutdownCompleteNotif = &shutdownCompleteNotif;
terminalUlp.peerShutdownReceivedNotif = NULL;
/* handle all command line options */
getArgs(argc, argv);
checkArgs();
if (client) {
sctpInstance = sctp_registerInstance(localPort,
MAXIMUM_NUMBER_OF_IN_STREAMS,
MAXIMUM_NUMBER_OF_OUT_STREAMS,
noOfLocalAddresses, localAddressList,
terminalUlp);
/* set the TOS byte */
sctp_getAssocDefaults(sctpInstance, &instanceParameters);
instanceParameters.ipTos=tosByte;
sctp_setAssocDefaults(sctpInstance, &instanceParameters);
associationID = sctp_associate(sctpInstance, MAXIMUM_NUMBER_OF_OUT_STREAMS,
destinationAddress, remotePort, NULL);
}
sctp_registerUserCallback(fileno(stdin),&stdinCallback, NULL, POLLIN|POLLPRI);
/* run the event handler forever */
while (sctp_eventLoop() >= 0);
/* this will never be reached */
return 0;
}
Console_Error Console_setSize(short width, short height) {
Console_Error error = checkArgs(0, 0, width, height);
if(error != CONSOLE_OK) return error;
char cmd[32];
sprintf(cmd, "mode con: lines=%d cols=%d", height, width);
system(cmd);
return CONSOLE_OK;
}
// [M,O] = gradMag( I, channel, full ) - see gradientMag.m
void mGradMag( int nl, mxArray *pl[], int nr, const mxArray *pr[] ) {
int h, w, d, c, full; float *I, *M, *O=0;
checkArgs(nl,pl,nr,pr,1,2,3,3,&h,&w,&d,mxSINGLE_CLASS,(void**)&I);
if(h<2 || w<2) mexErrMsgTxt("I must be at least 2x2.");
c = (int) mxGetScalar(pr[1]); full = (int) mxGetScalar(pr[2]);
if( c>0 && c<=d ) { I += h*w*(c-1); d=1; }
pl[0] = mxCreateMatrix3(h,w,1,mxSINGLE_CLASS,0,(void**)&M);
if(nl>=2) pl[1] = mxCreateMatrix3(h,w,1,mxSINGLE_CLASS,0,(void**)&O);
gradMag(I, M, O, h, w, d, full>0 );
}
int main(int argc, char **argv)
{
SCTP_ulpCallbacks terminalUlp;
SCTP_InstanceParameters instanceParameters;
SCTP_LibraryParameters params;
char buffer[2000];
/* initialize the terminal_ulp variable */
terminalUlp.dataArriveNotif = &dataArriveNotif;
terminalUlp.sendFailureNotif = &sendFailureNotif;
terminalUlp.networkStatusChangeNotif = &networkStatusChangeNotif;
terminalUlp.communicationUpNotif = &communicationUpNotif;
terminalUlp.communicationLostNotif = &communicationLostNotif;
terminalUlp.communicationErrorNotif = &communicationErrorNotif;
terminalUlp.restartNotif = &restartNotif;
terminalUlp.shutdownCompleteNotif = &shutdownCompleteNotif;
terminalUlp.peerShutdownReceivedNotif = &shutdownReceivedNotif;
/* handle all command line options */
getArgs(argc, argv);
checkArgs();
SCTP_initLibrary();
SCTP_getLibraryParameters(¶ms);
params.sendOotbAborts = sendOOTBAborts;
params.supportPRSCTP = 1;
params.checksumAlgorithm = SCTP_CHECKSUM_ALGORITHM_CRC32C;
SCTP_setLibraryParameters(¶ms);
sctpInstance=SCTP_registerInstance(localPort,
MAXIMUM_NUMBER_OF_IN_STREAMS, MAXIMUM_NUMBER_OF_OUT_STREAMS,
noOfLocalAddresses, localAddressList,
terminalUlp);
/* set the TOS byte */
SCTP_getAssocDefaults((unsigned short)sctpInstance, &instanceParameters);
instanceParameters.ipTos = tosByte;
instanceParameters.rtoMin = rto_min;
instanceParameters.rtoMax = rto_max;
instanceParameters.rtoInitial = rto_min;
if (myRwndSpecified)
instanceParameters.myRwnd = myRwnd;
SCTP_setAssocDefaults((unsigned short)sctpInstance, &instanceParameters);
SCTP_registerStdinCallback(&stdinCallback, buffer, sizeof(buffer));
associationID=SCTP_associate((unsigned short)sctpInstance, MAXIMUM_NUMBER_OF_OUT_STREAMS, destinationAddress, remotePort, NULL);
/* run the event handler forever */
while (1){
SCTP_eventLoop();
}
/* this will never be reached */
exit(0);
}
static CMPIArray * __eft_toArray (
CONST CMPIEnumeration * enumeration,
CMPIStatus * rc )
{
struct native_enum * e = (struct native_enum *) enumeration;
if (!checkArgs(enumeration, rc))
{
return 0;
}
return e->data;
}
