EXPORT_C TInt RMemSpySession::ThreadSystemPermanentOrCritical( TThreadId aId, TBool aValue )
{
TPckgBuf<TThreadId> arg1( aId );
TPckgBuf<TBool> arg2( aValue );
TIpcArgs args( &arg1, &arg2 );
TInt error = SendReceive( EMemSpyClientServerOpThreadSystemPermanentOrCritical, args );
aValue = arg2();
return error;
}
bool xpathplugin_xbn_select::operator() (xbn_state &state, xbn_xpath *pxpath )
{
// Hole linke Seite
xbn_state arg1(state);
if( !pxpath->process( arg1, *(state.pCurrent_token) ) )
{
return true;
}
// Und verknuepfe diese mit allen ergebnissen der rechten seite
uint_xbn pos=0, col_size = arg1.ResultNodeList.size();
for( xbnode_list::iterator pc=arg1.ResultNodeList.begin(),pe=arg1.ResultNodeList.end(); pc!=pe;++pc,++pos )
{
xbn_state arg2(state);
uint_xbn current_token = *(state.pCurrent_token);
arg2.pCurrent_token = ¤t_token;
arg2.pCurrentNode = *pc;
arg2.current_node_position = pos;
arg2.last_node_position = col_size-1;
if( pxpath->process( arg2, *(arg2.pCurrent_token) ) )
{
// Ergebnis auflisten
state.addNodeList( arg2.ResultNodeList );
//if( state.ResultNodeList.size()>state.MaxResultSize ) break;
}
}
return true;
}
// ----------------------------------------------------------------------
double f_3g(double *x, double *par) {
// par[0] -> const
// par[1] -> mean
// par[2] -> sigma
// par[3] -> const
// par[4] -> mean
// par[5] -> sigma
// par[6] -> const
// par[7] -> mean
// par[8] -> sigma
Double_t arg1(0.), arg2(0.), arg3(0.), fitval1(0.), fitval2(0.), fitval3(0.);
if (par[2] > 0) {
arg1 = (x[0] - par[1]) / par[2];
fitval1 = par[0]*TMath::Exp(-0.5*arg1*arg1);
}
if (par[5] > 0.) {
arg2 = (x[0] - par[4]) / par[5];
fitval2 = par[3]*par[0]*TMath::Exp(-0.5*arg2*arg2);
}
if (par[8] > 0.) {
arg3 = (x[0] - par[7]) / par[8];
fitval3 = par[6]*par[0]*TMath::Exp(-0.5*arg3*arg3);
}
Double_t fitval = fitval1 + fitval2 + fitval3;
return fitval;
}
int main(int argc, char* argv[])
{
switch (argc)
{
case 3:
strcpy(buffer1, argv[1]);
strcpy(buffer2, argv[2]);
arg2(buffer1, buffer2);
break;
case 4:
strcpy(buffer1, argv[1]);
strcpy(buffer2, argv[2]);
sscanf(argv[3], "%d", &buffer3);
arg3(buffer1, buffer2, buffer3);
break;
default:
arg0();
break;
}
return(0);
}
EXPORT_C void RMemSpySession::SetThreadPriorityL(TThreadId aId, TInt aPriority)
{
TPckgBuf<TThreadId> arg1( aId );
TPckgBuf<TInt> arg2( aPriority );
User::LeaveIfError(SendReceive( EMemSpyClientServerOpSetThreadPriority, TIpcArgs(&arg1, &arg2)));
}
const std::string& CmdServerStart::execute( const std::vector< std::string >& arguments )
{
_cmdResult = "";
if ( arguments.size() < 1 )
{
_cmdResult = getUsage();
return _cmdResult;
}
// get the full binary path
std::string cmd = yaf3d::Application::get()->getFullBinPath();
std::string levelfile = arguments[ 0 ];
std::string arg1( "-server" );
std::string arg2( "-level" );
std::string arg3( levelfile );
// use utility function to start the server
std::string args = arg1 + " " + arg2 + " " + arg3;
YAF3D_SPAWN_PROC_ID serverProcHandle = yaf3d::spawnApplication( cmd, args );
if ( serverProcHandle )
_cmdResult = "trying to start server with level file '" + levelfile + "'.";
else
_cmdResult = "* error starting server with level file '" + levelfile + "'.";
return _cmdResult;
}
void test_values()
{
RPN::Context cxt;
//Constant node (boring)
cxt.insert("c", new RPN::ConstantNode(42));
insist_equal(evaluate("c", cxt), 42.0);
//Variable node
double x;
cxt.insert("x", new RPN::VariableNode(&x));
x = 17;
RPN::Expression var("x", cxt);
insist_equal(var.evaluate(), 17.0);
x = 23;
insist_equal(var.evaluate(), 23.0);
//Expression node
cxt.insert("e", new RPN::ExpressionNode(&var));
insist_equal(evaluate("e", cxt), 23.0);
//Argument node
RPN::Evaluator eval;
//One argument...
cxt.insert("arg11", new RPN::ArgumentNode(1, 1));
RPN::Expression arg1("arg11", cxt, 1);
eval.push(12);
insist_equal(arg1.evaluate(eval), 12.0);
insist_equal(arg1.evaluate(7.5), 7.5);
insist_zero(eval.count());
//Two arguments...
cxt.insert("arg12", new RPN::ArgumentNode(-2));
cxt.insert("arg22", new RPN::ArgumentNode(-1));
RPN::Expression arg2("arg12 + arg22", cxt, 2);
eval.push(13);
eval.push(14);
insist_equal(arg2.evaluate(eval), 27.0);
insist_equal(arg2.evaluate(7.5, 8.5), 16.0);
insist_zero(eval.count());
//Three arguments...
cxt.insert("arg13", new RPN::ArgumentNode(1, 3));
cxt.insert("arg23", new RPN::ArgumentNode(-2));
cxt.insert("arg33", new RPN::ArgumentNode(3, 3));
RPN::Expression arg3("arg13 + arg23 + arg33", cxt, 3);
eval.push(101);
eval.push(202);
eval.push(303);
insist_equal(arg3.evaluate(eval), 606.0);
insist_equal(arg3.evaluate(1, 2, 3), 6.0);
insist_zero(eval.count());
}
QJsonObject Blink1Input::toJson3()
{
QJsonObject obj;
obj.insert("arg1",arg1());
obj.insert("iname", name());
obj.insert("lastTime",date());
if(mtype!="IFTTT.COM")
obj.insert("lastVal",arg2());
else{
QJsonArray ja;
ja.append(QJsonValue(arg2()));
obj.insert("possibleVals",ja);
}
obj.insert("pname",patternName());
obj.insert("type",type());
return obj;
}
ref<Expr> ShadowArray::createBinaryOfSameKind(ref<Expr> originalExpr,
ref<Expr> newLhs,
ref<Expr> newRhs) {
std::vector<Expr::CreateArg> exprs;
Expr::CreateArg arg1(newLhs);
Expr::CreateArg arg2(newRhs);
exprs.push_back(arg1);
exprs.push_back(arg2);
return Expr::createFromKind(originalExpr->getKind(), exprs);
}
EXPORT_C TInt RMemSpySession::EndThreadL( TThreadId aId, TMemSpyEndType aType )
{
TPckgBuf<TThreadId> arg1( aId );
TPckgBuf<TMemSpyEndType> arg2( aType );
TIpcArgs args( &arg1, &arg2 );
TInt error = SendReceive( EMemSpyClientServerOpEndThread, args );
return error;
}
EXPORT_C TInt RMemSpySession::SwitchToThread( TThreadId aId, TBool aBrought )
{
TPckgBuf<TThreadId> arg1( aId );
TPckgBuf<TBool> arg2( aBrought );
TIpcArgs args( &arg1, &arg2 );
TInt error = SendReceive( EMemSpyClientServerOpSwitchToThread, args );
return error;
}
/* Allocates memory */
void factor_vm::general_error(vm_error_type error, cell arg1_, cell arg2_) {
data_root<object> arg1(arg1_, this);
data_root<object> arg2(arg2_, this);
faulting_p = true;
/* If we had an underflow or overflow, data or retain stack
pointers might be out of bounds, so fix them before allocating
anything */
ctx->fix_stacks();
/* If error was thrown during heap scan, we re-enable the GC */
gc_off = false;
/* If the error handler is set, we rewind any C stack frames and
pass the error to user-space. */
if (!current_gc && to_boolean(special_objects[ERROR_HANDLER_QUOT])) {
#ifdef FACTOR_DEBUG
/* Doing a GC here triggers all kinds of funny errors */
primitive_compact_gc();
#endif
/* Now its safe to allocate and GC */
cell error_object =
allot_array_4(tag_fixnum(KERNEL_ERROR), tag_fixnum(error),
arg1.value(), arg2.value());
ctx->push(error_object);
/* Clear the data roots since arg1 and arg2's destructors won't be
called. */
data_roots.clear();
/* The unwind-native-frames subprimitive will clear faulting_p
if it was successfully reached. */
unwind_native_frames(special_objects[ERROR_HANDLER_QUOT],
ctx->callstack_top);
} /* Error was thrown in early startup before error handler is set, so just
crash. */
else {
std::cout << "You have triggered a bug in Factor. Please report.\n";
std::cout << "error: " << error << std::endl;
std::cout << "arg 1: ";
print_obj(std::cout, arg1.value());
std::cout << std::endl;
std::cout << "arg 2: ";
print_obj(std::cout, arg2.value());
std::cout << std::endl;
factorbug();
abort();
}
}
QJsonObject Blink1Input::toJson()
{
QJsonObject obj;
obj.insert("name", name());
obj.insert("type",type());
obj.insert("arg1",arg1());
obj.insert("arg2",arg2());
obj.insert("date",date());
obj.insert("patternName",patternName());
obj.insert("freq",freq());
obj.insert("freqCounter",freqCounter());
return obj;
}
EXPORT_C TInt RMemSpySession::GetInfoItemType( TInt aIndex, TThreadId aId, TMemSpyThreadInfoItemType &aType )
{
TPckgBuf<TInt> arg1( aIndex );
TPckgBuf<TThreadId> arg2( aId );
TPckgBuf<TMemSpyThreadInfoItemType> arg3;
TIpcArgs args( &arg1, &arg2, &arg3 );
TInt error = SendReceive( EMemSpyClientServerOpGetInfoItemType, args );
aType = arg3();
return error;
}
Variant c_Exception::ifa___construct(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
if (UNLIKELY(mcp.obj == 0)) {
return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___construct, coo_Exception);
}
c_Exception *self ATTRIBUTE_UNUSED (static_cast<c_Exception*>(mcp.obj));
if (UNLIKELY(count > 3)) return throw_toomany_arguments("Exception::__construct", 3, 2);
if (count <= 0) return (self->t___construct(), null);
CVarRef arg0(a0);
if (count <= 1) return (self->t___construct(arg0), null);
CVarRef arg1(a1);
if (count <= 2) return (self->t___construct(arg0, arg1), null);
CVarRef arg2(a2);
return (self->t___construct(arg0, arg1, arg2), null);
}
/*!
* \brief 範囲指定による順序付きリスト
* \param[in] line 行番号
* \param[in] arg_list マクロ実引数リスト
* \param[in] p_ctx マクロコンテキスト
* \retval マクロ返却値
* 第1マクロ実引数で最初の値を、第2マクロ実引数で最後の値を指定する。
* { 最初の値, 最初の値 + 1, ... 最後の値 }
* となる順序付きリストを生成する。
* 引数が正しくない場合は空値を返す。
*/
var_t bf_range( text_line const& line, std::vector< var_t > const& arg_list, context const* p_ctx )
{
var_t result;
if ( macro_processor::check_arity( line, arg_list.size(), 2, "RANGE" ) )
{
std::tr1::int64_t arg1( get_i( arg_list[0], p_ctx ) );
std::tr1::int64_t arg2( get_i( arg_list[1], p_ctx ) );
for ( ; arg1 <= arg2; ++arg1 )
{
element e;
e.i = arg1;
result.push_back( e );
}
}
return result;
}
int
main()
{
// construction
{
std::string const s( "test" );
breath::string_argument
arg( s ) ;
DO_TEST( arg.value() == "test" ) ;
char const * s2 = "test-2" ;
breath::string_argument
arg2( s2 ) ;
DO_TEST(arg2.value() == "test-2" ) ;
}
}
Variant NEVER_INLINE c_SoapFault::ifa___construct(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
if (UNLIKELY(mcp.obj == 0)) {
return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___construct, coo_SoapFault);
}
c_SoapFault *self ATTRIBUTE_UNUSED (static_cast<c_SoapFault*>(mcp.obj));
if (UNLIKELY(count < 2)) return throw_wrong_arguments("SoapFault::__construct", count, 2, 6, 2);
CVarRef arg0(a0);
CVarRef arg1(a1);
if (count <= 2) return (self->t___construct(arg0, arg1), null);
CVarRef arg2(a2);
if (count <= 3) return (self->t___construct(arg0, arg1, arg2), null);
CVarRef arg3(a3);
if (count <= 4) return (self->t___construct(arg0, arg1, arg2, arg3), null);
CVarRef arg4(a4);
if (count <= 5) return (self->t___construct(arg0, arg1, arg2, arg3, arg4), null);
CVarRef arg5(a5);
return (self->t___construct(arg0, arg1, arg2, arg3, arg4, arg5), null);
}
DEFINE_FUNCTION_DHLX_2(bool_t, bcmp)
{
T arg0(parse<T>(sc));
sc.get(SourceTokenDHLX::TT_OP_COMMA);
std::string arg1(sc.get(SourceTokenDHLX::TT_IDENTIFIER).getData());
sc.get(SourceTokenDHLX::TT_OP_COMMA);
T arg2(parse<T>(sc));
int cmpResult(cmp(arg0, arg2));
if (arg1 == cmp_name_eq()) return cmpResult == 0;
if (arg1 == cmp_name_ne()) return cmpResult != 0;
if (arg1 == cmp_name_gt()) return cmpResult > 0;
if (arg1 == cmp_name_ge()) return cmpResult >= 0;
if (arg1 == cmp_name_lt()) return cmpResult < 0;
if (arg1 == cmp_name_le()) return cmpResult <= 0;
throw FunctionException("unknown cmp:" + arg1);
}
// ----------------------------------------------------------------------
double f_2g(double *x, double *par) {
// par[0] -> const
// par[1] -> mean
// par[2] -> sigma
// par[3] -> fraction in second gaussian
// par[4] -> mean
// par[5] -> sigma
Double_t arg1(0.), arg2(0.), fitval1(0.), fitval2(0.);
if (par[2] > 0) {
arg1 = (x[0] - par[1]) / par[2];
fitval1 = par[0]*TMath::Exp(-0.5*arg1*arg1);
}
if (par[5] > 0.) {
arg2 = (x[0] - par[4]) / par[5];
fitval2 = par[3]*par[0]*TMath::Exp(-0.5*arg2*arg2);
}
Double_t fitval = fitval1 + fitval2;
return fitval;
}
int main()
{
Obj A;
compare arg1(boost::bind(&Obj::hello, &A));
compare arg2(boost::bind(&Obj::hello, &A));
std::set<compare> fset;
//fset.insert(arg1);
//fset.insert(arg2);
//if (boost::function_equal(arg1, arg2))
if (true/*arg1==arg2*/)
{
std::cout << "equal bind" << std::endl;
}
else
{
std::cout << "not equal bind" << std::endl;
}
return 0;
}
bool xpathplugin_xbn_or:: operator() (xbn_state &state, xbn_xpath *pxpath )
{
if( !state.pCurrentNode )
return false;
xbn_state arg1(state);
if( !pxpath->process( arg1, *(state.pCurrent_token) ) )
return false;
xbn_state arg2(state);
if( !pxpath->process( arg2, *(state.pCurrent_token) ) )
return false;
if( arg1.ResultNodeList.size()!=arg2.ResultNodeList.size() &&
(arg1.ResultNodeList.size()>1&&
arg2.ResultNodeList.size()>1) )
{
pxpath->raiseError( name+"() resultsizes arg1,arg2 does not match",&state, __FILE__, __LINE__ );
return false;
}
for( xbnode_list::iterator pc_arg1=arg1.ResultNodeList.begin(),pe_arg1=arg1.ResultNodeList.end(),
pc_arg2=arg2.ResultNodeList.begin(),pe_arg2=arg2.ResultNodeList.end();
pc_arg1!=pe_arg1 && pc_arg2!=pe_arg2;
++pc_arg1,++pc_arg2 )
{
if( pc_arg1==pe_arg1 ) pc_arg1=arg1.ResultNodeList.begin();
if( pc_arg2==pe_arg2 ) pc_arg2=arg2.ResultNodeList.begin();
if( (*pc_arg1)->getBool() || (*pc_arg2)->getBool() )
{
state.ResultNodeList.push_back( state.pStack->createTempNode("true") );
}
else
{
state.ResultNodeList.push_back( state.pStack->createTempNode("false") );
}
}
return true;
}
// ----------------------------------------------------------------------
double f_2G(double *x, double *par) {
// par[0] -> area
// par[1] -> mean
// par[2] -> sigma
// par[3] -> fraction in second gaussian
// par[4] -> mean
// par[5] -> sigma
double sqrt2pi = 2.506628275;
Double_t arg1(0.), arg2(0.), fitval1(0.), fitval2(0.);
if (par[2] > 0) {
arg1 = (x[0] - par[1]) / par[2];
fitval1 = (par[0]/(sqrt2pi*par[2]))*TMath::Exp(-0.5*arg1*arg1);
}
if (par[5] > 0.) {
arg2 = (x[0] - par[4]) / par[5];
fitval2 = (par[3]*par[0]/(sqrt2pi*par[2]))*TMath::Exp(-0.5*arg2*arg2);
}
Double_t fitval = fitval1 + fitval2;
return fitval;
}
scalar stokesFirstStanding::ddxPd
(
const point& x,
const scalar& time,
const vector& unitVector
) const
{
scalar Z(returnZ(x));
scalar arg1(omega_*time - (k_ & x) + phi_);
scalar arg2(omega_*time + (k_ & x) + phi_);
scalar ddxPd(0);
ddxPd = (
rhoWater_*mag(g_)*K_*H_/2.0*Foam::cosh(K_*(Z + h_))
/Foam::cosh(K_*h_)*Foam::sin(arg1)
- rhoWater_*mag(g_)*K_*H_/2.0*Foam::cosh(K_*(Z + h_))
/Foam::cosh(K_*h_)*Foam::sin(arg2)
)*factor(time);
return ddxPd;
}
// private
// runs in main thread
bool
MovieLoader::processCompletedRequest(const Request& r)
{
//GNASH_REPORT_FUNCTION;
boost::intrusive_ptr<movie_definition> md;
if (!r.getCompleted(md)) return false; // not completed yet
const std::string& target = r.getTarget();
DisplayObject* targetDO = _movieRoot.findCharacterByTarget(target);
as_object* handler = r.getHandler();
if (!md) {
if (targetDO && handler) {
// Signal load error
// Tested not to happen if target isn't found at time of loading
//
as_value arg1(getObject(targetDO));
// FIXME: docs suggest the string can be either "URLNotFound" or
// "LoadNeverCompleted". This is neither of them:
as_value arg2("Failed to load movie or jpeg");
// FIXME: The last argument is HTTP status, or 0 if no connection
// was attempted (sandbox) or no status information is available
// (supposedly the Adobe mozilla plugin).
as_value arg3(0.0);
callMethod(handler, NSV::PROP_BROADCAST_MESSAGE, "onLoadError",
arg1, arg2, arg3);
}
return true; // nothing to do, but completed
}
const URL& url = r.getURL();
Movie* extern_movie = md->createMovie(*_movieRoot.getVM().getGlobal());
if (!extern_movie) {
log_error(_("Can't create Movie instance "
"for definition loaded from %s"), url);
return true; // completed in any case...
}
// Parse query string
MovieClip::MovieVariables vars;
url.parse_querystring(url.querystring(), vars);
extern_movie->setVariables(vars);
if (targetDO) {
targetDO->getLoadedMovie(extern_movie);
}
else {
unsigned int levelno;
const int version = _movieRoot.getVM().getSWFVersion();
if (isLevelTarget(version, target, levelno)) {
log_debug(_("processCompletedRequest: _level loading "
"(level %u)"), levelno);
extern_movie->set_depth(levelno + DisplayObject::staticDepthOffset);
_movieRoot.setLevel(levelno, extern_movie);
}
else {
log_debug("Target %s of a loadMovie request doesn't exist at "
"load complete time", target);
return true;
}
}
if (handler && targetDO) {
// Dispatch onLoadStart
// FIXME: should be signalled before starting to load
// (0/-1 bytes loaded/total) but still with *new*
// display object as target (ie: the target won't
// contain members set either before or after loadClip.
callMethod(handler, NSV::PROP_BROADCAST_MESSAGE, "onLoadStart",
getObject(targetDO));
// Dispatch onLoadProgress
// FIXME: should be signalled on every readNonBlocking()
// with a buffer size of 65535 bytes.
//
size_t bytesLoaded = md->get_bytes_loaded();
size_t bytesTotal = md->get_bytes_total();
callMethod(handler, NSV::PROP_BROADCAST_MESSAGE, "onLoadProgress",
getObject(targetDO), bytesLoaded, bytesTotal);
// Dispatch onLoadComplete
// FIXME: find semantic of last arg
callMethod(handler, NSV::PROP_BROADCAST_MESSAGE, "onLoadComplete",
getObject(targetDO), as_value(0.0));
// Dispatch onLoadInit
// This event must be dispatched when actions
// in first frame of loaded clip have been executed.
//
// Since getLoadedMovie or setLevel above will invoke
// construct() and thus queue all actions in first
// frame, we'll queue the
// onLoadInit call next, so it happens after the former.
//
std::auto_ptr<ExecutableCode> code(
new DelayedFunctionCall(targetDO, handler,
NSV::PROP_BROADCAST_MESSAGE,
"onLoadInit", getObject(targetDO)));
getRoot(*handler).pushAction(code, movie_root::PRIORITY_DOACTION);
}
return true;
}
/*** Evaluate this object ***/
Object* SpecialFunction::evaluate()
{
if(args.size() == 0)
throw Excep(getLineNumber(), getColumnNumber(), "Expected argument to special function!");
std::auto_ptr<Object> arg1(args.at(0)->evaluate());
if(id == SPF_INDEX)
{
if(args.size() != 2)
throw Excep(getLineNumber(), getColumnNumber(), "Invalid number of arguments passed to special function!");
std::auto_ptr<Object> arg2(args.at(1)->evaluate());
if(arg2->getType() == OBJ_TEXT)
{
if(arg1->getType() != OBJ_TEXT)
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_TEXT, arg1->getType(), 1);
Text* cast1 = static_cast<Text*>(arg1.get());
Text* cast2 = static_cast<Text*>(arg2.get());
size_t index = cast2->getValue().find(cast1->getValue());
if(index != std::string::npos)
return new Integer(index + 1);
return new Integer(0);
}
if(arg2->getType() == OBJ_SEQUENCE)
{
Sequence* cast = dynamic_cast<Sequence*>(arg2.get());
for(unsigned int i = 0; i < cast->getLength(); i++)
{
std::auto_ptr<Logical> eqOp(static_cast<Logical*>(Equal(arg1->clone(), cast->getObject(i)->clone()).evaluate()));
if(eqOp->getValue() == true)
return new Integer(i + 1);
}
return new Integer(0);
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_TEXT | OBJ_SEQUENCE, arg2->getType(), 2);
}
if(args.size() > 1)
throw Excep(getLineNumber(), getColumnNumber(), "Invalid number of arguments passed to special function!");
if(id == SPF_ABS)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
if(cast->getValue() < 0)
return new Integer(-cast->getValue());
return new Integer(cast->getValue());
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
if(cast->getValue() < 0)
return new Real(-cast->getValue());
return new Real(cast->getValue());
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_SIGN)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
if(cast->getValue() < 0)
return new Integer(-1);
if(cast->getValue() > 0)
return new Integer(1);
return new Integer(0);
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
if(cast->getValue() < 0)
return new Integer(-1);
if(cast->getValue() > 0)
return new Integer(1);
return new Integer(0);
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_SQRT)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
if(cast->getValue() < 0)
throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1);
double res = sqrt((double) cast->getValue());
if((long) res == res)
return new Integer((long) res);
return new Real(res);
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
if(cast->getValue() < 0)
throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1);
double res = sqrt((double) cast->getValue());
return new Real(res);
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_ENTIER)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
return new Integer(cast->getValue());
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
return new Integer(floor(cast->getValue()));
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_ROUND)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
return new Integer(cast->getValue());
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
long rounded = cast->getValue() < 0.0 ? ceil(cast->getValue() - 0.5) : floor(cast->getValue() + 0.5);
return new Integer(rounded);
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_RAND)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
if(cast->getValue() < 0)
throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1);
double f = (double) rand() / RAND_MAX;
return new Real( f * cast->getValue() );
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
if(cast->getValue() < 0)
throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1);
double f = (double) rand() / RAND_MAX;
return new Real( f * cast->getValue() );
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_INTRAND)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
if(cast->getValue() < 0)
throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1);
return new Integer( rand() % cast->getValue() + 1 );
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
if(cast->getValue() < 0)
throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1);
return new Integer( rand() % (long) cast->getValue() + 1 );
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_ISEMPTY)
{
return new Logical(arg1->getType() == OBJ_EMPTY);
}
if(id == SPF_ISLOG)
{
return new Logical(arg1->getType() == OBJ_LOGICAL);
}
if(id == SPF_ISINT)
{
return new Logical(arg1->getType() == OBJ_INTEGER);
}
if(id == SPF_ISREAL)
{
return new Logical(arg1->getType() == OBJ_REAL);
}
if(id == SPF_ISTEXT)
{
return new Logical(arg1->getType() == OBJ_TEXT);
}
if(id == SPF_ISSEQ)
{
return new Logical(arg1->getType() == OBJ_SEQUENCE);
}
if(id == SPF_ISPROC)
{
return new Logical(arg1->getType() == OBJ_PROCEDURE);
}
if(id == SPF_ISFUN)
{
return new Logical(arg1->getType() == OBJ_FUNCTION || arg1->getType() == OBJ_SPFUNCTION);
}
if(id == SPF_SIN)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
return new Real(sin((double) cast->getValue()));
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
return new Real(sin(cast->getValue()));
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_COS)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
return new Real(cos((double) cast->getValue()));
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
return new Real(cos(cast->getValue()));
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_TG)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
return new Real(tan((double) cast->getValue()));
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
return new Real(tan(cast->getValue()));
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_ARCSIN)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
if(errno == EDOM)
throw new Excep(getLineNumber(), getColumnNumber(), "Invalid value passed to special function!");
return new Real(exp((double) cast->getValue()));
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
if(errno == EDOM)
throw new Excep(getLineNumber(), getColumnNumber(), "Invalid value passed to special function!");
return new Real(exp(cast->getValue()));
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_ARCTG)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
if(errno == EDOM)
throw new Excep(getLineNumber(), getColumnNumber(), "Invalid value passed to special function!");
return new Real(exp((double) cast->getValue()));
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
if(errno == EDOM)
throw new Excep(getLineNumber(), getColumnNumber(), "Invalid value passed to special function!");
return new Real(exp(cast->getValue()));
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_EXP)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
return new Real(exp((double) cast->getValue()));
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
return new Real(exp(cast->getValue()));
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_LN)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
return new Real(log((double) cast->getValue()));
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
return new Real(log(cast->getValue()));
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
if(id == SPF_LG)
{
if(arg1->getType() == OBJ_INTEGER)
{
Integer* cast = static_cast<Integer*>(arg1.get());
return new Real(log10((double) cast->getValue()));
}
if(arg1->getType() == OBJ_REAL)
{
Real* cast = static_cast<Real*>(arg1.get());
return new Real(log10(cast->getValue()));
}
throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1);
}
throw Excep(getLineNumber(), getColumnNumber(), "Invalid special function!");
}
int main(int argc, char *argv[])
{
// Initialize OSPRay.
ospInit(&argc, (const char **) argv);
// Initialize Qt.
QApplication *app = new QApplication(argc, argv);
// Print the command line usage.
if (argc < 2) {
std::cerr << " " << std::endl;
std::cerr << " USAGE: " << argv[0] << " <filename> [filename] ... [options]" << std::endl;
std::cerr << " " << std::endl;
std::cerr << " Options:" << std::endl;
std::cerr << " " << std::endl;
std::cerr << " -benchmark <warm-up frames> <frames> : run benchmark and report overall frame rate" << std::endl;
std::cerr << " -dt <dt> : use ray cast sample step size 'dt'" << std::endl;
std::cerr << " -module <moduleName> : load the module 'moduleName'" << std::endl;
std::cerr << " -ply <filename> : load PLY geometry from 'filename'" << std::endl;
std::cerr << " -rotate <rate> : automatically rotate view according to 'rate'" << std::endl;
std::cerr << " -showframerate : show the frame rate in the window title bar" << std::endl;
std::cerr << " -fullscreen : enter fullscreen mode" << std::endl;
std::cerr << " -ownmodelperobject : create a separate model for each object" << std::endl;
std::cerr << " -slice <filename> : load volume slice from 'filename'" << std::endl;
std::cerr << " -transferfunction <filename> : load transfer function from 'filename'" << std::endl;
std::cerr << " -viewsize <width>x<height> : force OSPRay view size to 'width'x'height'" << std::endl;
std::cerr << " -viewup <x> <y> <z> : set viewport up vector to ('x', 'y', 'z')" << std::endl;
std::cerr << " -writeframes <filename> : emit frames to 'filename_xxxxx.ppm'" << std::endl;
std::cerr << " " << std::endl;
return 1;
}
// // Parse the OSPRay object file filenames.
// std::vector<std::string> objectFileFilenames;
// for (size_t i=1 ; (i < argc) && (argv[i][0] != '-') ; i++)
// objectFileFilenames.push_back(std::string(argv[i]));
// Default values for the optional command line arguments.
float dt = 0.0f;
std::vector<std::string> plyFilenames;
float rotationRate = 0.0f;
std::vector<std::string> sliceFilenames;
std::string transferFunctionFilename;
int benchmarkWarmUpFrames = 0;
int benchmarkFrames = 0;
int viewSizeWidth = 0;
int viewSizeHeight = 0;
ospcommon::vec3f viewUp(0.f);
ospcommon::vec3f viewAt(0.f), viewFrom(0.f);
bool showFrameRate = false;
bool fullScreen = false;
bool ownModelPerObject = false;
std::string renderer = "dvr";
std::string writeFramesFilename;
std::vector<std::string> inFileName;
// Parse the optional command line arguments.
for (int i=// objectFileFilenames.size() +
1 ; i < argc ; i++) {
const std::string arg = argv[i];
if (arg == "-dt") {
if (i + 1 >= argc) throw std::runtime_error("missing <dt> argument");
dt = atof(argv[++i]);
std::cout << "got dt = " << dt << std::endl;
} else if (arg == "-ply") {
// Note: we use "-ply" since "-geometry" gets parsed elsewhere...
if (i + 1 >= argc) throw std::runtime_error("missing <filename> argument");
plyFilenames.push_back(std::string(argv[++i]));
std::cout << "got PLY filename = " << plyFilenames.back() << std::endl;
} else if (arg == "-rotate") {
if (i + 1 >= argc) throw std::runtime_error("missing <rate> argument");
rotationRate = atof(argv[++i]);
std::cout << "got rotationRate = " << rotationRate << std::endl;
} else if (arg == "-slice") {
if (i + 1 >= argc) throw std::runtime_error("missing <filename> argument");
sliceFilenames.push_back(std::string(argv[++i]));
std::cout << "got slice filename = " << sliceFilenames.back() << std::endl;
} else if (arg == "-showframerate" || arg == "-fps") {
showFrameRate = true;
std::cout << "set show frame rate" << std::endl;
} else if (arg == "-fullscreen") {
fullScreen = true;
std::cout << "go full screen" << std::endl;
} else if (arg == "-ownmodelperobject") {
ownModelPerObject = true;
} else if (arg == "-transferfunction") {
if (i + 1 >= argc) throw std::runtime_error("missing <filename> argument");
transferFunctionFilename = std::string(argv[++i]);
std::cout << "got transferFunctionFilename = " << transferFunctionFilename << std::endl;
} else if (arg == "-benchmark") {
if (i + 2 >= argc) throw std::runtime_error("missing <warm-up frames> <frames> arguments");
benchmarkWarmUpFrames = atoi(argv[++i]);
benchmarkFrames = atoi(argv[++i]);
std::cout << "got benchmarkWarmUpFrames = " << benchmarkWarmUpFrames << ", benchmarkFrames = " << benchmarkFrames << std::endl;
} else if (arg == "-r" || arg == "-renderer") {
renderer = argv[++i];
} else if (arg == "-viewsize") {
if (i + 1 >= argc) throw std::runtime_error("missing <width>x<height> argument");
std::string arg2(argv[++i]);
size_t pos = arg2.find("x");
if (pos != std::string::npos) {
arg2.replace(pos, 1, " ");
std::stringstream ss(arg2);
ss >> viewSizeWidth >> viewSizeHeight;
std::cout << "got viewSizeWidth = " << viewSizeWidth << ", viewSizeHeight = " << viewSizeHeight << std::endl;
} else throw std::runtime_error("improperly formatted <width>x<height> argument");
} else if (arg == "-viewup" || arg == "-vu") {
/**
* Generates unconstrained parameter element names in column-major order,
* e.g., order for 3-d array of matrices: col, row, d3, d2, d1
* Generated code consists of zero of more for loops, one per dimension,
* with the specified indentation level writing to the specified stream.
* If specified, declare named size_t variable for each dimension
* which avoids re-evaluation of size expression on each iteration.
*
* @param[in] var_decl variable declaration
* @param[in] declare_size_vars if true, generate size_t var decls
* @param[in] indent indentation level
* @param[in,out] o stream for generating
*/
void write_begin_param_elements_loop(const block_var_decl& var_decl,
bool declare_size_vars,
int indent, std::ostream& o) {
std::string name(var_decl.name());
expression arg1(var_decl.type().innermost_type().arg1());
expression arg2(var_decl.type().innermost_type().arg2());
if (var_decl.type().innermost_type().is_specialized()) {
// num dims for specialized matrices less than N*M
arg1 = var_decl.type().innermost_type().params_total();
arg2 = expression(nil());
}
// get values for loop bounds, generate loop bound declarations
std::vector<expression> ar_var_dims = var_decl.type().array_lens();
if (!is_nil(arg2)) {
generate_indent(indent, o);
if (declare_size_vars)
o << "size_t ";
o << name << "_j_2_max__ = ";
generate_expression(arg2, NOT_USER_FACING, o);
o << ";" << EOL;
}
if (!is_nil(arg1)) {
generate_indent(indent, o);
if (declare_size_vars)
o << "size_t ";
o << name << "_j_1_max__ = ";
generate_expression(arg1, NOT_USER_FACING, o);
o << ";" << EOL;
}
for (size_t i = 0; i < ar_var_dims.size(); ++i) {
generate_indent(indent, o);
if (declare_size_vars)
o << "size_t ";
o << name << "_k_" << i << "_max__ = ";
generate_expression(ar_var_dims[i], NOT_USER_FACING, o);
o << ";" << EOL;
}
// nested for stmts open, row, col indexes
if (!is_nil(arg2)) {
generate_indent(indent++, o);
o << "for (size_t j_2__ = 0; "
<< "j_2__ < " << name << "_j_2_max__;"
<< " ++j_2__) {" << EOL;
}
if (!is_nil(arg1)) {
generate_indent(indent++, o);
o << "for (size_t j_1__ = 0; "
<< "j_1__ < " << name << "_j_1_max__;"
<< " ++j_1__) {" << EOL;
}
for (size_t i = ar_var_dims.size(); i > 0; --i) {
int idx = i - 1; // size == N, indexes run from 0 .. N - 1
generate_indent(indent++, o);
o << "for (size_t k_" << idx << "__ = 0;"
<< " k_" << idx << "__ < "
<< name << "_k_" << idx << "_max__;"
<< " ++k_" << idx << "__) {" << EOL;
}
}
/**
* @brief implementation for call java static method
*/
JS_BINDED_FUNC_IMPL(JavascriptJavaBridge, callStaticMethod)
{
JS::CallArgs argv = JS::CallArgsFromVp(argc, vp);
if (argc == 3) {
JSStringWrapper arg0(argv[0]);
JSStringWrapper arg1(argv[1]);
JSStringWrapper arg2(argv[2]);
CallInfo call(arg0.get(), arg1.get(), arg2.get());
if(call.isValid()){
bool success = call.execute();
int errorCode = call.getErrorCode();
if(errorCode < 0)
JS_ReportError(cx, "js_cocos2dx_JSJavaBridge : call result code: %d", errorCode);
argv.rval().set(convertReturnValue(cx, call.getReturnValue(), call.getReturnValueType()));
return success;
}
}
else if(argc > 3){
JSStringWrapper arg0(argv[0]);
JSStringWrapper arg1(argv[1]);
JSStringWrapper arg2(argv[2]);
CallInfo call(arg0.get(), arg1.get(), arg2.get());
if(call.isValid() && call.getArgumentsCount() == (argc - 3)){
int count = argc - 3;
jvalue *args = new jvalue[count];
for (int i = 0; i < count; ++i){
int index = i + 3;
switch (call.argumentTypeAtIndex(i))
{
case TypeInteger:
double interger;
JS::ToNumber(cx, argv.get(index), &interger);
args[i].i = (int)interger;
break;
case TypeFloat:
double floatNumber;
JS::ToNumber(cx, argv.get(index), &floatNumber);
args[i].f = (float)floatNumber;
break;
case TypeBoolean:
args[i].z = JS::ToBoolean(argv.get(index)) ? JNI_TRUE : JNI_FALSE;
break;
case TypeString:
default:
JSStringWrapper arg(argv.get(index));
args[i].l = call.getEnv()->NewStringUTF(arg.get());
break;
}
}
bool success = call.executeWithArgs(args);
if (args) delete []args;
int errorCode = call.getErrorCode();
if(errorCode < 0)
JS_ReportError(cx, "js_cocos2dx_JSJavaBridge : call result code: %d", errorCode);
argv.rval().set(convertReturnValue(cx, call.getReturnValue(), call.getReturnValueType()));
return success;
}
}else{
JS_ReportError(cx, "js_cocos2dx_JSJavaBridge : wrong number of arguments: %d, was expecting more than 3", argc);
}
return false;
}
void ByteCode::setup(eOpCode opcode, m::u8 A, m::u8 B, m::u8 C)
{
opCode(opcode);
res(A);
arg1(B);
arg2(C);
}
