/*
* Upon reaching the yield operator, the factory is
* suspended until the next request arrives.
* The information in the target list should be delivered
* to the caller stack frame.
*/
int
yieldResult(MalBlkPtr mb, InstrPtr p, int pc)
{
Plant pl, plim = plants + lastPlant;
ValPtr lhs, rhs;
int i;
(void) p;
(void) pc;
for (pl = plants; pl < plim; pl++)
if (pl->factory == mb ) {
if( pl->env == NULL)
return(int) (pl-plants);
for (i = 0; i < p->retc; i++) {
#ifdef DEBUG_MAL_FACTORY
printf("lhs %d rhs %d\n", getArg(pl->pci, i), getArg(p, i));
#endif
rhs = &pl->stk->stk[getArg(p, i)];
lhs = &pl->env->stk[getArg(pl->pci, i)];
VALcopy(lhs, rhs);
}
return (int) (pl-plants);
}
return -1;
}
string const Parser::ertEnvironment(string const & name)
{
if (!good())
return string();
ostringstream os;
for (Token t = get_token(); good(); t = get_token()) {
if (t.cat() == catBegin) {
putback();
os << '{' << verbatim_item() << '}';
} else if (t.asInput() == "\\begin") {
string const env = getArg('{', '}');
os << "\\begin{" << env << '}'
<< ertEnvironment(env)
<< "\\end{" << env << '}';
} else if (t.asInput() == "\\end") {
string const end = getArg('{', '}');
if (end != name)
cerr << "\\end{" << end
<< "} does not match \\begin{" << name
<< "}." << endl;
return os.str();
} else
os << t.asInput();
}
cerr << "unexpected end of input" << endl;
return os.str();
}
AREXPORT bool ArArgumentBuilder::isArgDouble(size_t whichArg) const
{
const char *str;
double ret;
char *endPtr;
if (whichArg > myArgc || getArg(whichArg) == NULL)
return false;
str = getArg(whichArg);
if (strcmp(str, "-INF") == 0)
{
return true;
}
else if (strcmp(str, "INF") == 0)
{
return true;
}
else
{
ret = strtod(str, &endPtr);
if (endPtr[0] == '\0' && endPtr != str)
return true;
else
return false;
}
}
/**
* Check whether a special "help" flag was given in the arguments, and also
* print a warning (Using ArLog at Normal log level) if any unparsed arguments were found.
* The following are the help flags: -help, -h, --help, /?, /h.
* @return false if a help flag was found or unparsed arguments
* were found, true otherwise.
* @param numArgsOkay If you plan on checking for additional
* arguments later in the program, you can specify the number of arguments
* expected here, which prevents this method from warning about them being unparsed
* yet.
*/
AREXPORT bool ArArgumentParser::checkHelpAndWarnUnparsed(
unsigned int numArgsOkay)
{
if (myHelp || checkArgument("-help") || checkArgument("-h") ||
checkArgument("/?") || checkArgument("/h"))
{
myHelp = true;
return false;
}
if (getArgc() <= 1 + numArgsOkay)
return true;
size_t i;
char buf[2048];
sprintf(buf, "Unhandled arguments to program:");
for (i = 1 + (int)numArgsOkay; i < getArgc(); i++)
sprintf(buf, "%s %s", buf, getArg(i));
ArLog::log(ArLog::Normal, buf);
ArLog::log(ArLog::Normal,
"Program will continue but to see the help listing type '%s -help'",
getArg(0));
return true;
}
void EvtSVVNONCPEIGEN::init(){
// check that there are 27 arguments
checkNArg(27,15);
checkNDaug(2);
checkSpinDaughter(0,EvtSpinType::VECTOR);
checkSpinDaughter(1,EvtSpinType::VECTOR);
// The ordering of A_f is :
// A_f[0-2] = A_f
// A_f[3-5] = Abar_f
// A_f[6-8] = A_fbar
// A_f[9-11] = Abar_fbar
//
// Each of the 4 amplitudes include the 3 different helicity states in
// the order +, 0, -. See more about helicity amplitude ordering in ::decay
int i=0;
int j=(getNArg()-3)/2;
for(i=0; i<j; ++i){
_A_f[i] = getArg((2*i)+3) * EvtComplex( cos(getArg((2*i)+4)),sin(getArg((2*i)+4)) );
}
// If only 6 amplitudes are specified, calculate the last 6 from the first 6:
if(6 == j){
for(i = 0; i < 3; ++i){
_A_f[6+i] = _A_f[3+i];
_A_f[9+i] = _A_f[i];
}
}
}
static InstrPtr
ReplaceWithNil(MalBlkPtr mb, InstrPtr p, int pos, int tpe)
{
p = pushNil(mb, p, tpe); /* push at end */
getArg(p, pos) = getArg(p, p->argc-1);
p->argc--;
return p;
}
void EvtSSSCP::initProbMax(){
//This is probably not quite right, but it should do as a start...
//Anders
setProbMax(2*(getArg(3)*getArg(3)+getArg(5)*getArg(5)));
}
void EvtHypNonLepton::init() {
if(getNArg()<2 || getNArg()>3) { // alpha phi gamma delta
EvtGenReport(EVTGEN_ERROR,"EvtGen") << " ERROR: EvtHypNonLepton generator expected 2 or 3 arguments but found: " << getNArg() << std::endl;
EvtGenReport(EVTGEN_INFO ,"EvtGen") << " 1. Decay asymmetry parameter - alpha" << std::endl;
EvtGenReport(EVTGEN_INFO ,"EvtGen") << " 2. Parameter phi - in degrees (not radians)" << std::endl;
EvtGenReport(EVTGEN_INFO ,"EvtGen") << " 3. Note on every x-th decay" << std::endl;
::abort();
}
if(getNDaug()!=2) { // Check that there are 2 daughters only
EvtGenReport(EVTGEN_ERROR,"EvtGen") << " ERROR: EvtHypNonLepton generator expected 2 daughters but found: " << getNDaug() << std::endl;
::abort();
}
// Check particles spins
if(EvtSpinType::getSpin2(EvtPDL::getSpinType(getParentId()))!=1) {
EvtGenReport(EVTGEN_ERROR,"EvtGen") << " ERROR: EvtHypNonLepton generator expected dirac parent particle, but found " << EvtSpinType::getSpin2(EvtPDL::getSpinType(getParentId())) << " spin degrees of freedom" << std::endl;
::abort();
}
if(EvtSpinType::getSpin2(EvtPDL::getSpinType(getDaug(0)))!=1) {
EvtGenReport(EVTGEN_ERROR,"EvtGen") << " ERROR: EvtHypNonLepton generator expected the first child to be dirac particle, but found " << EvtSpinType::getSpin2(EvtPDL::getSpinType(getDaug(0))) << " spin degrees of freedom" << std::endl;
::abort();
}
if(EvtSpinType::getSpin2(EvtPDL::getSpinType(getDaug(1)))!=0) {
EvtGenReport(EVTGEN_ERROR,"EvtGen") << " ERROR: EvtHypNonLepton generator expected the second child to be scalar particle, but found " << EvtSpinType::getSpin2(EvtPDL::getSpinType(getDaug(1))) << " spin degrees of freedom" << std::endl;
::abort();
}
// Read all parameters
m_alpha = getArg(0);
m_phi = getArg(1)*EvtConst::pi/180;
if(getNArg()==3) m_noTries = static_cast<long>(getArg(2));
else m_noTries = 0;
// calculate additional parameters
double p,M,m1,m2;
double p_to_s,beta,delta,gamma;
M = EvtPDL::getMass(getParentId());
m1 = EvtPDL::getMass(getDaug(0));
m2 = EvtPDL::getMass(getDaug(1));
if(m1+m2>=M) {
EvtGenReport(EVTGEN_ERROR,"EvtGen") << " ERROR: EvtHypNonLepton found impossible decay: " << M << " --> " << m1 << " + " << m2 << " GeV\n" << std::endl;
::abort();
}
p = sqrt(M*M-(m1+m2)*(m1+m2))*sqrt(M*M-(m1-m2)*(m1-m2))/2./M;
beta = sqrt(1.-m_alpha*m_alpha)*sin(m_phi);
delta = -atan2(beta,m_alpha);
gamma = sqrt(1.-m_alpha*m_alpha-beta*beta);
p_to_s = sqrt((1.-gamma)/(1.+gamma));
m_B_to_A = p_to_s*(m1+sqrt(p*p+m1*m1))/p*EvtComplex(cos(delta),sin(delta));
}
//
// Called to create the network connection.
//
static VMIOS_INTERCEPT_FN(netInit)
{
object->domain = vmirtGetProcessorDataDomain(processor);
Uns32 prefixStringAddr;
Uns32 localNetAddr;
getArg(processor, object, 0, &object->diagLevel);
getArg(processor, object, 1, &object->packets);
getArg(processor, object, 2, &prefixStringAddr);
getArg(processor, object, 3, &localNetAddr);
object->pollCount = 0;
const char *tftp_path = NULL;
if(prefixStringAddr) {
tftp_path = vmirtGetString(object->domain, prefixStringAddr);
if(DIAG_LOW) {
vmiMessage("I", PREFIX,
"local tftp server is active. Root directory is '%s'",
object->tftpPath
);
}
}
const char *localNet = localNetAddr
? vmirtGetString(object->domain, localNetAddr)
: "10.0.2.0";
char vhostname[256];
vhostname[0] = 0;
//gethostname(vhostname, sizeof(vhostname));
const char *bootfile = NULL;
const char *vnetmask = NULL;
const char *vdhcp_start = NULL;
const char *vnameserver = NULL;
const char *vhost = NULL;
Bool restricted = False;
object->slirp = net_slirp_init(
restricted,
localNet,
vnetmask,
vhost,
vhostname,
tftp_path,
bootfile,
vdhcp_start,
vnameserver,
object
);
if (!object->slirp) {
vmiMessage("F", PREFIX, "Unable to start networking");
}
}
/*
* Enable incremental packing. The SQL front-end requires
* fixed oid sequences.
*/
str
MATpackIncrement(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
bat *ret = getArgReference_bat(stk,p,0);
int pieces;
BAT *b, *bb, *bn;
size_t newsize;
(void) cntxt;
b = BATdescriptor( stk->stk[getArg(p,1)].val.ival);
if ( b == NULL)
throw(MAL, "mat.pack", RUNTIME_OBJECT_MISSING);
if ( getArgType(mb,p,2) == TYPE_int){
/* first step, estimate with some slack */
pieces = stk->stk[getArg(p,2)].val.ival;
bn = BATnew(TYPE_void, b->ttype?b->ttype:TYPE_oid, (BUN)(1.2 * BATcount(b) * pieces), TRANSIENT);
if (bn == NULL)
throw(MAL, "mat.pack", MAL_MALLOC_FAIL);
/* allocate enough space for the vheap, but not for strings,
* since BATappend does clever things for strings */
if ( b->T->vheap && bn->T->vheap && ATOMstorage(b->ttype) != TYPE_str){
newsize = b->T->vheap->size * pieces;
if (HEAPextend(bn->T->vheap, newsize, TRUE) != GDK_SUCCEED)
throw(MAL, "mat.pack", MAL_MALLOC_FAIL);
}
BATseqbase(bn, b->H->seq);
BATseqbase(BATmirror(bn), b->T->seq);
BATappend(bn,b,FALSE);
assert(!bn->H->nil || !bn->H->nonil);
assert(!bn->T->nil || !bn->T->nonil);
bn->H->align = (pieces-1);
BBPkeepref(*ret = bn->batCacheid);
BBPunfix(b->batCacheid);
} else {
/* remaining steps */
bb = BATdescriptor(stk->stk[getArg(p,2)].val.ival);
if ( bb ){
if (BATcount(b) == 0)
BATseqbase(b, bb->H->seq);
if (BATcount(b) == 0)
BATseqbase(BATmirror(b), bb->T->seq);
BATappend(b,bb,FALSE);
}
b->H->align--;
if(b->H->align == 0)
BATsetaccess(b, BAT_READ);
assert(!b->H->nil || !b->H->nonil);
assert(!b->T->nil || !b->T->nonil);
BBPkeepref(*ret = b->batCacheid);
if( bb)
BBPunfix(bb->batCacheid);
}
return MAL_SUCCEED;
}
AREXPORT bool ArArgumentBuilder::getArgBool(size_t whichArg) const
{
if (whichArg > myArgc || getArg(whichArg) == NULL)
return false;
if (strcasecmp(getArg(whichArg), "true") == 0 ||
strcasecmp(getArg(whichArg), "1") == 0)
return true;
else
return false;
}
static InstrPtr
PushArgument(MalBlkPtr mb, InstrPtr p, int arg, int pos)
{
int i;
p = pushArgument(mb, p, arg); /* push at end */
for (i = p->argc-1; i > pos; i--)
getArg(p, i) = getArg(p, i-1);
getArg(p, pos) = arg;
return p;
}
str OPTsql_append(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p){
str modnme;
str fcnnme;
str msg= MAL_SUCCEED;
Symbol s= NULL;
lng t,clk= GDKusec();
int actions = 0;
if( p )
removeInstruction(mb, p);
OPTDEBUGsql_append mnstr_printf(cntxt->fdout,"=APPLY OPTIMIZER sql_append\n");
if( p && p->argc > 1 ){
if( getArgType(mb,p,1) != TYPE_str ||
getArgType(mb,p,2) != TYPE_str ||
!isVarConstant(mb,getArg(p,1)) ||
!isVarConstant(mb,getArg(p,2))
) {
throw(MAL, "optimizer.sql_append", ILLARG_CONSTANTS);
}
if( stk != 0){
modnme= *getArgReference_str(stk,p,1);
fcnnme= *getArgReference_str(stk,p,2);
} else {
modnme= getArgDefault(mb,p,1);
fcnnme= getArgDefault(mb,p,2);
}
s= findSymbol(cntxt->nspace, putName(modnme,strlen(modnme)),putName(fcnnme,strlen(fcnnme)));
if( s == NULL) {
char buf[1024];
snprintf(buf,1024, "%s.%s",modnme,fcnnme);
throw(MAL, "optimizer.sql_append", RUNTIME_OBJECT_UNDEFINED ":%s", buf);
}
mb = s->def;
stk= 0;
}
if( mb->errors ){
/* when we have errors, we still want to see them */
addtoMalBlkHistory(mb,"sql_append");
return MAL_SUCCEED;
}
actions= OPTsql_appendImplementation(cntxt, mb,stk,p);
msg= optimizerCheck(cntxt, mb, "optimizer.sql_append", actions, t=(GDKusec() - clk));
OPTDEBUGsql_append {
mnstr_printf(cntxt->fdout,"=FINISHED sql_append %d\n",actions);
printFunction(cntxt->fdout,mb,0,LIST_MAL_ALL );
}
DEBUGoptimizers
mnstr_printf(cntxt->fdout,"#opt_reduce: " LLFMT " ms\n",t);
QOTupdateStatistics("sql_append",actions,t);
addtoMalBlkHistory(mb,"sql_append");
return msg;
}
static InstrPtr
PushNil(MalBlkPtr mb, InstrPtr p, int pos, int tpe)
{
int i, arg;
p = pushNil(mb, p, tpe); /* push at end */
arg = getArg(p, p->argc-1);
for (i = p->argc-1; i > pos; i--)
getArg(p, i) = getArg(p, i-1);
getArg(p, pos) = arg;
return p;
}
/*
* The pack is an ordinary multi BAT insert. Oid synchronistion
* between pieces should be ensured by the code generators.
* The pack operation could be quite expensive, because it
* may create a really large BAT.
* The slice over a mat helps to avoid constructing intermediates
* that are subsequently reduced.
* Contrary to most operations, NIL arguments are skipped and
* do not produce RUNTIME_OBJECT_MISSING.
*/
static str
MATpackInternal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
int i, *ret = (int*) getArgReference(stk,p,0);
BAT *b, *bn;
BUN cap = 0;
int tt = TYPE_any;
(void) cntxt;
(void) mb;
for (i = 1; i < p->argc; i++) {
int bid = stk->stk[getArg(p,i)].val.ival;
b = BBPquickdesc(abs(bid),FALSE);
if (b && bid < 0)
b = BATmirror(b);
if( b ){
assert(BAThdense(b));
if (tt == TYPE_any){
tt = b->ttype;
}
if (!tt && tt != b->ttype)
tt = b->ttype;
cap += BATcount(b);
}
}
if (tt == TYPE_any){
*ret = 0;
return MAL_SUCCEED;
}
bn = BATnew(TYPE_void, tt, cap, TRANSIENT);
if (bn == NULL)
throw(MAL, "mat.pack", MAL_MALLOC_FAIL);
for (i = 1; i < p->argc; i++) {
b = BATdescriptor(stk->stk[getArg(p,i)].val.ival);
if( b ){
if (BATcount(bn) == 0)
BATseqbase(bn, b->H->seq);
if (BATcount(bn) == 0)
BATseqbase(BATmirror(bn), b->T->seq);
BATappend(bn,b,FALSE);
BBPunfix(b->batCacheid);
}
}
assert(!bn->H->nil || !bn->H->nonil);
assert(!bn->T->nil || !bn->T->nonil);
BATsettrivprop(bn);
BATderiveProps(bn,FALSE);
BBPkeepref(*ret = bn->batCacheid);
return MAL_SUCCEED;
}
int main ( int argc, char * argv [] )
{
int status = 1;
try
{
const char *outfile = "./db/";
const char *schema_path = "./test-general-writer.vschema";
int num_columns = 0;
for ( int i = 1; i < argc; ++ i )
{
const char * arg = argv [ i ];
if ( arg [ 0 ] != '-' )
{
// have an input column
argv [ num_columns ++ ] = ( char* ) arg;
}
else do switch ( ( ++ arg ) [ 0 ] )
{
case 'o':
outfile = getArg ( arg, i, argc, argv );
break;
case 's':
schema_path = getArg ( arg, i, argc, argv );
default:
throw "Invalid argument";
}
while ( arg [ 1 ] != 0 );
}
if ( num_columns == 0 )
{
const char * columns [ 2 ] = { "input/column01", "input/column02" };
ncbi :: runTest ( 2, columns, outfile, schema_path );
}
else
{
ncbi :: runTest ( num_columns, ( const char ** ) argv, outfile, schema_path );
}
status = 0;
}
catch ( const char x [] )
{
std :: cerr << x << std :: endl;
}
return status;
}
int main(int argc, const char* argv[]) {
if(argc < 2) {
printHelp();
}
const string func = getArg(argc, argv, 1);
if(func.compare("help") == 0) {
printHelp();
} else if(func.compare("activemqSend") == 0) {
const string brokerURI = getArg(argc, argv, 2);
const bool destType = getDestType(getArg(argc, argv, 3));
const string dest = getArg(argc, argv, 4);
const string message = getArg(argc, argv, 5);
mql4j::activemqSend(brokerURI, destType, dest , message);
} else if(func.compare("activemqRecv") == 0) {
const string brokerURI = getArg(argc, argv, 2);
const bool destType = getDestType(getArg(argc, argv, 3));
const string dest = getArg(argc, argv, 4);
mql4j::activemqRecv(brokerURI, destType, dest);
} else if(func.compare("jvmStart") == 0) {
mql4j::jvmStart();
} else {
printHelp();
}
return 0;
}
void EvtbsToLLLL::decay( EvtParticle *p ){
double mu = getArg(0); // the scale parameter
int Nf = (int) getArg(1); // number of "effective" flavors
int res_swch = (int) getArg(2); // resonant switching parametr
int ias = (int) getArg(3); // switching parametr for \alpha_s(M_Z)
double CKM_A = getArg(4);
double CKM_lambda = getArg(5);
double CKM_barrho = getArg(6);
double CKM_bareta = getArg(7);
p->initializePhaseSpace(getNDaug(),getDaugs());
_calcamp->CalcAmp(p,_amp2, _mntffmodel, _wilscoeff, mu, Nf, res_swch, ias,
CKM_A,CKM_lambda,CKM_barrho,CKM_bareta);
// EvtGenReport(NOTICE,"EvtGen") << "\n The function EvtbTosllMSExt::decay(...) passed with arguments:"
// << "\n mu = " << mu << " Nf =" << Nf
// << " res_swch = " << res_swch
// << " ias = " << ias
// << " CKM_A = " << CKM_A
// << " CKM_lambda = " << CKM_lambda
// << " CKM_barrho = " << CKM_barrho
// << " CKM_bareta = " << CKM_bareta
// << " ReA7 = " << ReA7
// << " ImA7 = " << ImA7
// << " ReA10 = " << ReA10
// << " ImA10 = " << ImA10 << std::endl;
}
static lng
SQLgetSpace(mvc *m, MalBlkPtr mb)
{
sql_trans *tr = m->session->tr;
lng space = 0, i;
for (i = 0; i < mb->stop; i++) {
InstrPtr p = mb->stmt[i];
char *f = getFunctionId(p);
if (getModuleId(p) == sqlRef && (f == bindRef || f == bindidxRef)) {
int upd = (p->argc == 7 || p->argc == 9), mode = 0;
char *sname = getVarConstant(mb, getArg(p, 2 + upd)).val.sval;
char *tname = getVarConstant(mb, getArg(p, 3 + upd)).val.sval;
char *cname = NULL;
sql_schema *s = mvc_bind_schema(m, sname);
if (!s || strcmp(s->base.name, dt_schema) == 0)
continue;
cname = getVarConstant(mb, getArg(p, 4 + upd)).val.sval;
mode = getVarConstant(mb, getArg(p, 5 + upd)).val.ival;
if (mode != 0 || !cname || !s)
continue;
if (f == bindidxRef) {
sql_idx *i = mvc_bind_idx(m, s, cname);
if (i && (!isRemote(i->t) && !isMergeTable(i->t))) {
BAT *b = store_funcs.bind_idx(tr, i, RDONLY);
if (b) {
space += getBatSpace(b);
BBPunfix(b->batCacheid);
}
}
} else if (f == bindRef) {
sql_table *t = mvc_bind_table(m, s, tname);
sql_column *c = mvc_bind_column(m, t, cname);
if (c && (!isRemote(c->t) && !isMergeTable(c->t))) {
BAT *b = store_funcs.bind_col(tr, c, RDONLY);
if (b) {
space += getBatSpace(b);
BBPunfix(b->batCacheid);
}
}
}
}
}
return space;
}
/*
* Matching a block calls for building two variable lists used.
* The isomorphism can be determined after-wards using a single scan.
* The candidate block is matched with mb starting at a given pc.
* The candidate block is expected to defined as a function, including
* a signature and end-statement. They are ignored in the comparison
*
* Beware, the variables in the block being removed, could be
* used furtheron in the program. [tricky to detect, todo]
*/
static int
malFcnMatch(MalBlkPtr mc, MalBlkPtr mb, int pc)
{
int i, j, k, lim;
int *cvar, *mvar;
int ctop = 0, mtop = 0;
InstrPtr p, q;
if (mb->stop - pc < mc->stop - 2)
return 0;
cvar = (int *) GDKmalloc(mc->vtop * mc->maxarg * sizeof(*cvar));
if (cvar == NULL)
return 0;
mvar = (int *) GDKmalloc(mb->vtop * mc->maxarg * sizeof(*mvar));
if (mvar == NULL){
GDKfree(cvar);
return 0;
}
/* also trim the return statement */
lim = pc + mc->stop - 3;
k = 1;
for (i = pc; i < lim; i++, k++) {
p = getInstrPtr(mb, i);
q = getInstrPtr(mc, k);
if (malMatch(p, q) == 0){
GDKfree(cvar);
GDKfree(mvar);
return 0;
}
for (j = 0; j < p->argc; j++)
cvar[ctop++] = getArg(p, j);
for (j = 0; j < q->argc; j++)
mvar[mtop++] = getArg(q, j);
}
assert(mtop == ctop); /*shouldn't happen */
for (i = 0; i < ctop; i++)
for (j = i + 1; j < ctop; j++)
if ((cvar[i] == cvar[j]) != (mvar[i] == mvar[j])) {
GDKfree(cvar);
GDKfree(mvar);
return 0;
}
GDKfree(cvar);
GDKfree(mvar);
return 1;
}
AREXPORT int ArArgumentBuilder::getArgInt(size_t whichArg) const
{
const char *str;
int ret;
char *endPtr;
if (whichArg > myArgc || getArg(whichArg) == NULL)
return 0;
str = getArg(whichArg);
ret = strtol(str, &endPtr, 10);
if (endPtr[0] == '\0' && endPtr != str)
return ret;
else
return 0;
}
static VMIOS_INTERCEPT_FN(netTxPacket)
{
Uns32 addr, bytes;
getArg(processor, object, 0, &addr);
getArg(processor, object, 1, &bytes);
// copy data from PSE to host memory space.
Uns8 packet[bytes];
vmirtReadNByteDomain(object->domain, addr, packet, bytes, NULL, False);
if(DIAG_HIGH) vmiMessage("I", PREFIX, "netTxPacket bytes:%d", bytes);
// send to slirp
slirp_input(object->slirp, packet, bytes);
}
int
OPTinlineImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
int i;
InstrPtr q,sig;
int actions = 0;
(void) p;
(void)stk;
for (i = 1; i < mb->stop; i++) {
q = getInstrPtr(mb, i);
if( q->blk ) {
sig = getInstrPtr(q->blk,0);
/*
* Time for inlining functions that are used in multiplex operations.
* They are produced by SQL compiler.
*/
if( getFunctionId(q)== multiplexRef &&
getModuleId(q) == malRef &&
OPTinlineMultiplex(cntxt,mb,q)) {
OPTDEBUGinline {
mnstr_printf(cntxt->fdout,"#multiplex inline function\n");
printInstruction(cntxt->fdout,mb,0,q,LIST_MAL_ALL);
}
varSetProp(mb, getArg(q,0), inlineProp, op_eq, NULL);
} else
/*
* Check if the function definition is tagged as being inlined.
*/
if (sig->token == FUNCTIONsymbol &&
void fuzz(struct syscall_t *curSyscall){
//printf("%s\n", curSyscall->name);
UINT64 ret = 0xDEADBEEFDEADBEEF;
UINT64 args[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
try{
for (int i = 0; i < curSyscall->argn; i++){
args[i] = getArg(curSyscall, i);
}
ret = _syscall(curSyscall->syscallnumber,
args[0],
args[1],
args[2],
args[3],
args[4],
args[5],
args[6],
args[7]);
}
catch (...){
printf("...\n");
return ;
}
//printf("ret %p\n", ret);
}
AREXPORT bool ArArgumentBuilder::getArgBool(size_t whichArg,
bool *ok) const
{
bool isSuccess = false;
bool ret = false;
const char *str = getArg(whichArg);
// If the arg was successfully obtained...
if (str != NULL) {
if (strcasecmp(str, "true") == 0 ||
strcasecmp(str, "1") == 0) {
isSuccess = true;
ret = true;
}
else if (strcasecmp(str, "false") == 0 ||
strcasecmp(str, "0") == 0) {
isSuccess = true;
ret = false;
}
} // end if valid arg
if (ok != NULL) {
*ok = isSuccess;
}
if (isSuccess) {
return ret;
}
else {
return 0;
}
} // end method getArgBool
static VMIOS_INTERCEPT_FN(netPoll)
{
u_int timeMS;
getArg(processor, object, 0, &timeMS);
if(DIAG_HIGH) {
vmiMessage("I", PREFIX, "netPoll #" FMT_64d " at %d ***********", object->pollCount, timeMS);
}
object->pollCount++;
int nfds = -1;
Slirp *slirp = object->slirp;
FD_ZERO(&slirp->rfds);
FD_ZERO(&slirp->wfds);
FD_ZERO(&slirp->xfds);
slirp_select_fill(slirp, &nfds, &slirp->rfds, &slirp->wfds, &slirp->xfds);
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
int r = recSelectSocket(nfds + 1, &slirp->rfds, &slirp->wfds, &slirp->xfds, &tv);
slirp_select_poll(slirp, &slirp->rfds, &slirp->wfds, &slirp->xfds, timeMS, r >= 0);
}
str
MATpackValues(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
int i, type, first = 1;
bat *ret;
BAT *bn;
(void) cntxt;
type = getArgType(mb,p,first);
bn = BATnew(TYPE_void, type, p->argc, TRANSIENT);
if( bn == NULL)
throw(MAL, "mat.pack", MAL_MALLOC_FAIL);
if (ATOMextern(type)) {
for(i = first; i < p->argc; i++)
BUNappend(bn, stk->stk[getArg(p,i)].val.pval, TRUE);
} else {
for(i = first; i < p->argc; i++)
BUNappend(bn, getArgReference(stk, p, i), TRUE);
}
BATseqbase(bn, 0);
ret= getArgReference_bat(stk,p,0);
BBPkeepref(*ret = bn->batCacheid);
return MAL_SUCCEED;
}
AREXPORT bool ArArgumentBuilder::isArgInt(size_t whichArg) const
{
const char *str;
//int ret;
char *endPtr;
if (whichArg > myArgc || getArg(whichArg) == NULL)
return false;
str = getArg(whichArg);
int ret = strtol(str, &endPtr, 10);
(void)(ret); // Avoid unused var warning
if (endPtr[0] == '\0' && endPtr != str)
return true;
else
return false;
}
str
MATpackValues(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
int i,*ret, type, first = 1;
BAT *bn;
(void) cntxt;
type = getArgType(mb,p,first);
bn = BATnew(TYPE_void, type, p->argc, TRANSIENT);
if( bn == NULL)
throw(MAL, "mat.pack", MAL_MALLOC_FAIL);
if (ATOMvarsized(type)) {
for(i = first; i < p->argc; i++)
BUNappend(bn, stk->stk[getArg(p,i)].val.sval, TRUE);
} else {
for(i = first; i < p->argc; i++)
BUNappend(bn, getArgReference(stk, p, i), TRUE);
}
BATsettrivprop(bn);
BATderiveProps(bn,FALSE);
ret= (int*) getArgReference(stk,p,0);
BBPkeepref(*ret = bn->batCacheid);
return MAL_SUCCEED;
}
static int
OPTallConstant(Client cntxt, MalBlkPtr mb, InstrPtr p)
{
int i;
(void)cntxt;
if ( !(p->token == ASSIGNsymbol ||
getModuleId(p) == calcRef ||
getModuleId(p) == strRef ||
getModuleId(p) == mtimeRef ||
getModuleId(p) == mmathRef))
return FALSE;
if (getModuleId(p) == mmathRef && strcmp(getFunctionId(p), "rand") == 0)
return FALSE;
for (i = p->retc; i < p->argc; i++)
if (isVarConstant(mb, getArg(p, i)) == FALSE)
return FALSE;
for (i = 0; i < p->retc; i++) {
if (isaBatType(getArgType(mb, p, i)))
return FALSE;
if ( mb->unsafeProp )
return FALSE;
}
return TRUE;
}
