void ScriptPubKeyToJSON(const CScript& scriptPubKey, Object& out)
{
    txnouttype type;
    vector<CTxDestination> addresses;
    int nRequired;

    out.push_back(Pair("asm", scriptPubKey.ToString()));
    out.push_back(Pair("hex", HexStr(scriptPubKey.begin(), scriptPubKey.end())));

    if (!ExtractDestinations(scriptPubKey, type, addresses, nRequired))
    {
        out.push_back(Pair("type", GetTxnOutputType(TX_NONSTANDARD)));
        return;
    }

    out.push_back(Pair("reqSigs", nRequired));
    out.push_back(Pair("type", GetTxnOutputType(type)));

    Array a;
    BOOST_FOREACH(const CTxDestination& addr, addresses)
        a.push_back(CBitcoinAddress(addr).ToString());
    out.push_back(Pair("addresses", a));
}
Example #2
0
Object blockToJSON(const CBlock& block, const CBlockIndex* blockindex)
{
    Object result;
    result.push_back(Pair("hash", block.GetHash().GetHex()));
    CMerkleTx txGen(block.vtx[0]);
    txGen.SetMerkleBranch(&block);
    result.push_back(Pair("confirmations", (int)txGen.GetDepthInMainChain()));
    result.push_back(Pair("size", (int)blockindex->nSize));
    result.push_back(Pair("chainsize", blockindex->nChainSize));
    if (chainActive.Contains(blockindex))
        result.push_back(Pair("maxsize", (int)chainActive.MaxBlockSize(blockindex->nHeight)));
    result.push_back(Pair("height", blockindex->nHeight));
    
    result.push_back(Pair("version", (uint64_t)block.GetVersion()));
    result.push_back(Pair("ispok", block.IsPoKBlock()));
    if (block.IsPoKBlock())
        result.push_back(Pair("pok", (uint64_t)block.GetPoK()));
    result.push_back(Pair("merkleroot", block.hashMerkleRoot.GetHex()));
    result.push_back(Pair("time", block.GetBlockTime()));
    result.push_back(Pair("bits", HexBits(block.nBits)));
    result.push_back(Pair("nonce", (uint64_t)block.nNonce));
    Array txs;
    BOOST_FOREACH(const CTransaction&tx, block.vtx)
        txs.push_back(tx.GetHash().GetHex());
    result.push_back(Pair("tx", txs));
    result.push_back(Pair("difficulty", GetDifficulty(blockindex)));
    result.push_back(Pair("chainwork", blockindex->nChainWork.GetHex()));
    result.push_back(Pair("ntx", (int64_t)blockindex->nTx));
    result.push_back(Pair("nchaintx", (int64_t)blockindex->nChainTx));
    
    if (blockindex->pprev)
        result.push_back(Pair("previousblockhash", blockindex->pprev->GetBlockHash().GetHex()));
    CBlockIndex *pnext = chainActive.Next(blockindex);
    if (pnext)
        result.push_back(Pair("nextblockhash", pnext->GetBlockHash().GetHex()));
    return result;
}
Example #3
0
		Array<Monitor> EnumActiveMonitors()
		{
			Array<Monitor> results;
			
			int32 numMonitors;
			GLFWmonitor** monitors = ::glfwGetMonitors(&numMonitors);
			
			for (int32 i = 0; i < numMonitors; ++i)
			{
				GLFWmonitor* monitor = monitors[i];
				
				Monitor result;
				result.name = Unicode::Widen(::glfwGetMonitorName(monitor));
				
				uint32 displayID, unitNumber;
				int32 xPos, yPos, width, height;
				int32 wx, wy, ww, wh;
				glfwGetMonitorInfo_Siv3D(monitor, &displayID, &unitNumber,
										 &xPos, &yPos, &width, &height,
										 &wx, &wy, &ww, &wh);
				result.id = Format(displayID);
				result.displayDeviceName = Format(unitNumber);
				result.displayRect.x = xPos;
				result.displayRect.y = yPos;
				result.displayRect.w = width;
				result.displayRect.h = height;
				result.workArea.x = wx;
				result.workArea.y = wy;
				result.workArea.w = ww;
				result.workArea.h = wh;
				result.isPrimary = (i == 0);

				results.push_back(result);
			}
			
			return results;
		}
Example #4
0
int
Management_Connection::X_PropertyScan (Array < PropertyInfo > &p)
{
  p.resize (0);
  PropertyInfo p1;
  uchar obj, i;
  obj = 0;
  do
    {
      i = 0;
      do
	{
	  p1.obj = obj;
	  p1.property = 0;
	  if (A_Property_Desc
	      (obj, p1.property, i, p1.type, p1.count, p1.access) == -1)
	    return -1;
	  if (p1.property == 1 && p1.type == 4)
	    {
	      CArray a;
	      if (A_Property_Read (obj, 1, 1, 1, a) == -1)
		return -1;
	      if (a.size() != 2)
		return -1;
	      p1.count = (a[0] << 8) | (a[1]);
	    }
	  if (p1.property != 0)
	    p.push_back (p1);
	  i++;
	}
      while (p1.property != 0);
      obj++;
    }
  while (i != 1);
  return 0;
}
Example #5
0
Array Object::_get_signal_connection_list(const String &p_signal) const {

	List<Connection> conns;
	get_all_signal_connections(&conns);

	Array ret;

	for (List<Connection>::Element *E = conns.front(); E; E = E->next()) {

		Connection &c = E->get();
		if (c.signal == p_signal) {
			Dictionary rc;
			rc["signal"] = c.signal;
			rc["method"] = c.method;
			rc["source"] = c.source;
			rc["target"] = c.target;
			rc["binds"] = c.binds;
			rc["flags"] = c.flags;
			ret.push_back(rc);
		}
	}

	return ret;
}
int generateRSS(string uri, string *output)
{
#ifndef HAVE_BOOST_REGEX
    return RSS_ERROR_BOOST_REGEX;
#else
    map<string, string> parameterMap = parseQuery(uri);
    int max = 20; //default value
    string account = parameterMap["account"];
    string strMax = parameterMap["max"];
    if(strMax!="")
    {
        try
        {
            max = boost::lexical_cast<int>(strMax);
        }
        catch(boost::bad_lexical_cast e)
        {
            return RSS_ERROR_NOT_A_NUMBER;
        }
    }

    const Array emptyArray;
    Array accountsArray = listwalletusers(emptyArray,false).get_array();
    
    // if no account was specified, choose the first one
    if(account=="")
    {
        if(accountsArray.size()>0)
        {
            account = accountsArray[0].get_str();
        }
        else return RSS_ERROR_NO_ACCOUNT;
    }
    
    // if an account name was specified, check that it exists
    else
    {
        bool accountExists = false;
        for(int i=0;i<accountsArray.size();i++)
        {
            if(accountsArray[i]==account)
                accountExists=true;
        }
        if(!accountExists) return RSS_ERROR_BAD_ACCOUNT;	
    }

    // get an array of followed usernames and transform it to required format
    Array params1;
    params1.push_back(account);
    Array followingArray = getfollowing(params1,false).get_array();
    Array postSources;
    for(int i=0;i<followingArray.size();i++)
    {
        Object item;
        item.push_back(Pair("username",followingArray[i]));
        postSources.push_back(item);
    }

    Array params2;
    params2.push_back(max);
    params2.push_back(postSources);
    Array posts = getposts(params2,false).get_array();
    vector<Object> outputVector;   
    
    if(GetBoolArg("-rss_dm",false))     //synchronizing direct messages is disabled by default
    {
        Array params3;
        params3.push_back(account);
        params3.push_back(max);
        params3.push_back(postSources);
        Object messages = getdirectmsgs(params3,false).get_obj();
              
        for(int j=0;j<messages.size();j++)
        {
            Array userArray = messages[j].value_.get_array();
            for(int i=0;i<userArray.size();i++)
            {
                try
                {
                    if(find_value(userArray[i].get_obj(),"fromMe").get_bool())      //only report received messages
                      continue;
                    
                    string postTitle, postAuthor, postMsg;
                    postAuthor=messages[j].name_;
                    postTitle="Direct Message from "+postAuthor;
                    postMsg=find_value(userArray[i].get_obj(),"text").get_str();            
                    Value postTime = find_value(userArray[i].get_obj(),"time");
                    encodeXmlCharacters(postMsg);

                    Object item;
                    item.push_back(Pair("time",postTime));
                    item.push_back(Pair("title",postTitle));
                    item.push_back(Pair("author",postAuthor));
                    item.push_back(Pair("msg",postMsg));
                    outputVector.push_back(item);
                }
                catch(exception ex)
                {
                    fprintf(stderr, "Warning: RSS couldn't parse a direct message, skipping.\n");
                    continue;
                }
            }
        }
    }
        
    for(int i=0;i<posts.size();i++)
    {
        try
        {
            Object userpost = find_value(posts[i].get_obj(),"userpost").get_obj();
            string postTitle, postAuthor, postMsg;
            Value rt = find_value(userpost,"rt");

            if(rt.is_null())    // it's a normal post
            {
                postAuthor = find_value(userpost,"n").get_str();
                Value reply = find_value(userpost,"reply");
                if(!reply.is_null()&&find_value(reply.get_obj(),"n").get_str()==account)
                {
                    postTitle = "Reply from "+postAuthor;
                }
                else postTitle = postAuthor;
                postMsg = find_value(userpost,"msg").get_str();
            }
            else   // it's a retwist
            {               
                postAuthor = find_value(rt.get_obj(),"n").get_str();
                postTitle = postAuthor + " - via " + find_value(userpost,"n").get_str();
                postMsg = find_value(rt.get_obj(),"msg").get_str();
            }
            
            Value postTime = find_value(userpost,"time");
            encodeXmlCharacters(postMsg);
            
            Object item;
            item.push_back(Pair("time",postTime));
            item.push_back(Pair("title",postTitle));
            item.push_back(Pair("author",postAuthor));
            item.push_back(Pair("msg",postMsg));
            outputVector.push_back(item);
        }
        catch(exception ex)
        {
            fprintf(stderr, "Warning: RSS couldn't parse a public post, skipping.\n");
            continue;
        }
    }
    
    sort(outputVector.begin(),outputVector.end(),sortByTime);
    
    ostringstream ret;
    
    ret << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
        << "<rss version=\"2.0\">\n"
        << "<channel>\n"
        << "  <title>Twister Postboard - " << account << "</title>\n"
        << "  <description>New posts from Twister</description>\n";
    
    int outputSize = (outputVector.size()>max)?max:outputVector.size();
    
    for(int i=0;i<outputSize;i++)
    {
        Object item = outputVector[i];
        time_t postTime(find_value(item,"time").get_int64());
        char timeString[100];
        strftime(timeString, sizeof(timeString), "%a, %d %b %Y %H:%M:%S %z", gmtime(&postTime));

        ret << "  <item>\n"
            << "    <title>" << find_value(item,"title").get_str() << "</title>\n"
            << "    <author>" << find_value(item,"author").get_str() << "</author>\n"
            << "    <description>" << find_value(item,"msg").get_str() << "</description>\n"
            << "    <pubDate>" << timeString << "</pubDate>\n"
            << "  </item>\n";
    }

    ret << "</channel>\n"
        << "</rss>\n";

    *output = ret.str();
    return RSS_OK;
#endif
}
Example #7
0
static bool rest_getutxos(AcceptedConnection* conn,
                          const std::string& strURIPart,
                          const std::string& strRequest,
                          const std::map<std::string, std::string>& mapHeaders,
                          bool fRun)
{
    vector<string> params;
    enum RetFormat rf = ParseDataFormat(params, strURIPart);

    vector<string> uriParts;
    if (params.size() > 0 && params[0].length() > 1)
    {
        std::string strUriParams = params[0].substr(1);
        boost::split(uriParts, strUriParams, boost::is_any_of("/"));
    }

    // throw exception in case of a empty request
    if (strRequest.length() == 0 && uriParts.size() == 0)
        throw RESTERR(HTTP_INTERNAL_SERVER_ERROR, "Error: empty request");

    bool fInputParsed = false;
    bool fCheckMemPool = false;
    vector<COutPoint> vOutPoints;

    // parse/deserialize input
    // input-format = output-format, rest/getutxos/bin requires binary input, gives binary output, ...

    if (uriParts.size() > 0)
    {

        //inputs is sent over URI scheme (/rest/getutxos/checkmempool/txid1-n/txid2-n/...)
        if (uriParts.size() > 0 && uriParts[0] == "checkmempool")
            fCheckMemPool = true;

        for (size_t i = (fCheckMemPool) ? 1 : 0; i < uriParts.size(); i++)
        {
            uint256 txid;
            int32_t nOutput;
            std::string strTxid = uriParts[i].substr(0, uriParts[i].find("-"));
            std::string strOutput = uriParts[i].substr(uriParts[i].find("-")+1);

            if (!ParseInt32(strOutput, &nOutput) || !IsHex(strTxid))
                throw RESTERR(HTTP_INTERNAL_SERVER_ERROR, "Parse error");

            txid.SetHex(strTxid);
            vOutPoints.push_back(COutPoint(txid, (uint32_t)nOutput));
        }

        if (vOutPoints.size() > 0)
            fInputParsed = true;
        else
            throw RESTERR(HTTP_INTERNAL_SERVER_ERROR, "Error: empty request");
    }

    string strRequestMutable = strRequest; //convert const string to string for allowing hex to bin converting

    switch (rf) {
    case RF_HEX: {
        // convert hex to bin, continue then with bin part
        std::vector<unsigned char> strRequestV = ParseHex(strRequest);
        strRequestMutable.assign(strRequestV.begin(), strRequestV.end());
    }

    case RF_BINARY: {
        try {
            //deserialize only if user sent a request
            if (strRequestMutable.size() > 0)
            {
                if (fInputParsed) //don't allow sending input over URI and HTTP RAW DATA
                    throw RESTERR(HTTP_INTERNAL_SERVER_ERROR, "Combination of URI scheme inputs and raw post data is not allowed");

                CDataStream oss(SER_NETWORK, PROTOCOL_VERSION);
                oss << strRequestMutable;
                oss >> fCheckMemPool;
                oss >> vOutPoints;
            }
        } catch (const std::ios_base::failure& e) {
            // abort in case of unreadable binary data
            throw RESTERR(HTTP_INTERNAL_SERVER_ERROR, "Parse error");
        }
        break;
    }

    case RF_JSON: {
        if (!fInputParsed)
            throw RESTERR(HTTP_INTERNAL_SERVER_ERROR, "Error: empty request");
        break;
    }
    default: {
        throw RESTERR(HTTP_NOT_FOUND, "output format not found (available: " + AvailableDataFormatsString() + ")");
    }
    }

    // limit max outpoints
    if (vOutPoints.size() > MAX_GETUTXOS_OUTPOINTS)
        throw RESTERR(HTTP_INTERNAL_SERVER_ERROR, strprintf("Error: max outpoints exceeded (max: %d, tried: %d)", MAX_GETUTXOS_OUTPOINTS, vOutPoints.size()));

    // check spentness and form a bitmap (as well as a JSON capable human-readble string representation)
    vector<unsigned char> bitmap;
    vector<CCoin> outs;
    std::string bitmapStringRepresentation;
    boost::dynamic_bitset<unsigned char> hits(vOutPoints.size());
    {
        LOCK2(cs_main, mempool.cs);

        CCoinsView viewDummy;
        CCoinsViewCache view(&viewDummy);

        CCoinsViewCache& viewChain = *pcoinsTip;
        CCoinsViewMemPool viewMempool(&viewChain, mempool);

        if (fCheckMemPool)
            view.SetBackend(viewMempool); // switch cache backend to db+mempool in case user likes to query mempool

        for (size_t i = 0; i < vOutPoints.size(); i++) {
            CCoins coins;
            uint256 hash = vOutPoints[i].hash;
            if (view.GetCoins(hash, coins)) {
                mempool.pruneSpent(hash, coins);
                if (coins.IsAvailable(vOutPoints[i].n)) {
                    hits[i] = true;
                    // Safe to index into vout here because IsAvailable checked if it's off the end of the array, or if
                    // n is valid but points to an already spent output (IsNull).
                    CCoin coin;
                    coin.nTxVer = coins.nVersion;
                    coin.nHeight = coins.nHeight;
                    coin.out = coins.vout.at(vOutPoints[i].n);
                    assert(!coin.out.IsNull());
                    outs.push_back(coin);
                }
            }

            bitmapStringRepresentation.append(hits[i] ? "1" : "0"); // form a binary string representation (human-readable for json output)
        }
    }
    boost::to_block_range(hits, std::back_inserter(bitmap));

    switch (rf) {
    case RF_BINARY: {
        // serialize data
        // use exact same output as mentioned in Bip64
        CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION);
        ssGetUTXOResponse << chainActive.Height() << chainActive.Tip()->GetBlockHash() << bitmap << outs;
        string ssGetUTXOResponseString = ssGetUTXOResponse.str();

        conn->stream() << HTTPReplyHeader(HTTP_OK, fRun, ssGetUTXOResponseString.size(), "application/octet-stream") << ssGetUTXOResponseString << std::flush;
        return true;
    }

    case RF_HEX: {
        CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION);
        ssGetUTXOResponse << chainActive.Height() << chainActive.Tip()->GetBlockHash() << bitmap << outs;
        string strHex = HexStr(ssGetUTXOResponse.begin(), ssGetUTXOResponse.end()) + "\n";

        conn->stream() << HTTPReply(HTTP_OK, strHex, fRun, false, "text/plain") << std::flush;
        return true;
    }

    case RF_JSON: {
        Object objGetUTXOResponse;

        // pack in some essentials
        // use more or less the same output as mentioned in Bip64
        objGetUTXOResponse.push_back(Pair("chainHeight", chainActive.Height()));
        objGetUTXOResponse.push_back(Pair("chaintipHash", chainActive.Tip()->GetBlockHash().GetHex()));
        objGetUTXOResponse.push_back(Pair("bitmap", bitmapStringRepresentation));

        Array utxos;
        BOOST_FOREACH (const CCoin& coin, outs) {
            Object utxo;
            utxo.push_back(Pair("txvers", (int32_t)coin.nTxVer));
            utxo.push_back(Pair("height", (int32_t)coin.nHeight));
            utxo.push_back(Pair("value", ValueFromAmount(coin.out.nValue)));

            // include the script in a json output
            Object o;
            ScriptPubKeyToJSON(coin.out.scriptPubKey, o, true);
            utxo.push_back(Pair("scriptPubKey", o));
            utxos.push_back(utxo);
        }
        objGetUTXOResponse.push_back(Pair("utxos", utxos));

        // return json string
        string strJSON = write_string(Value(objGetUTXOResponse), false) + "\n";
        conn->stream() << HTTPReply(HTTP_OK, strJSON, fRun) << std::flush;
        return true;
    }
    default: {
        throw RESTERR(HTTP_NOT_FOUND, "output format not found (available: " + AvailableDataFormatsString() + ")");
    }
    }
Example #8
0
Value getpeerinfo(const Array& params, bool fHelp)
{
    if (fHelp || params.size() != 0)
        throw runtime_error(
            "getpeerinfo\n"
            "\nReturns data about each connected network node as a json array of objects.\n"
            "\nbResult:\n"
            "[\n"
            "  {\n"
            "    \"addr\":\"host:port\",      (string) The ip address and port of the peer\n"
            "    \"addrlocal\":\"ip:port\",   (string) local address\n"
            "    \"services\":\"00000001\",   (string) The services\n"
            "    \"lastsend\": ttt,           (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last send\n"
            "    \"lastrecv\": ttt,           (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last receive\n"
            "    \"bytessent\": n,            (numeric) The total bytes sent\n"
            "    \"bytesrecv\": n,            (numeric) The total bytes received\n"
            "    \"conntime\": ttt,           (numeric) The connection time in seconds since epoch (Jan 1 1970 GMT)\n"
            "    \"pingtime\": n,             (numeric) ping time\n"
            "    \"pingwait\": n,             (numeric) ping wait\n"
            "    \"version\": v,              (numeric) The peer version, such as 7001\n"
            "    \"subver\": \"/Satoshi:0.8.5/\",  (string) The string version\n"
            "    \"inbound\": true|false,     (boolean) Inbound (true) or Outbound (false)\n"
            "    \"startingheight\": n,       (numeric) The starting height (block) of the peer\n"
            "    \"banscore\": n,              (numeric) The ban score (stats.nMisbehavior)\n"
            "    \"syncnode\" : true|false     (booleamn) if sync node\n"
            "  }\n"
            "  ,...\n"
            "}\n"

            "\nExamples:\n"
            + HelpExampleCli("getpeerinfo", "")
            + HelpExampleRpc("getpeerinfo", "")
        );

    vector<CNodeStats> vstats;
    CopyNodeStats(vstats);

    Array ret;

    for(const CNodeStats& stats: vstats) {
        Object obj;
        CNodeStateStats statestats;
        bool fStateStats = GetNodeStateStats(stats.nodeid, statestats);
        obj.push_back(Pair("addr", stats.addrName));
        if (!(stats.addrLocal.empty()))
            obj.push_back(Pair("addrlocal", stats.addrLocal));
        obj.push_back(Pair("services", strprintf("%08x", stats.nServices)));
        obj.push_back(Pair("lastsend", stats.nLastSend));
        obj.push_back(Pair("lastrecv", stats.nLastRecv));
        obj.push_back(Pair("bytessent", stats.nSendBytes));
        obj.push_back(Pair("bytesrecv", stats.nRecvBytes));
        obj.push_back(Pair("conntime", stats.nTimeConnected));
        obj.push_back(Pair("pingtime", stats.dPingTime));
        if (stats.dPingWait > 0.0)
            obj.push_back(Pair("pingwait", stats.dPingWait));
        obj.push_back(Pair("version", stats.nVersion));
        // Use the sanitized form of subver here, to avoid tricksy remote peers from
        // corrupting or modifiying the JSON output by putting special characters in
        // their ver message.
        obj.push_back(Pair("subver", stats.cleanSubVer));
        obj.push_back(Pair("inbound", stats.fInbound));
        obj.push_back(Pair("startingheight", stats.nStartingHeight));
        if (fStateStats) {
            obj.push_back(Pair("banscore", statestats.nMisbehavior));
        }
        obj.push_back(Pair("syncnode", stats.fSyncNode));

        ret.push_back(obj);
    }

    return ret;
}
Example #9
0
// Convert strings to command-specific RPC representation
Array RPCConvertValues(const std::string &strMethod, const std::vector<std::string> &strParams)
{
    Array params;
    BOOST_FOREACH(const std::string &param, strParams)
        params.push_back(param);

    int n = params.size();

    //
    // Special case non-string parameter types
    //
    if (strMethod == "stop"                   && n > 0) ConvertTo<bool>(params[0]);
    if (strMethod == "getaddednodeinfo"       && n > 0) ConvertTo<bool>(params[0]);
    if (strMethod == "setgenerate"            && n > 0) ConvertTo<bool>(params[0]);
    if (strMethod == "setgenerate"            && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "getnetworkhashps"       && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "getnetworkhashps"       && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "sendtoaddress"          && n > 1) ConvertTo<double>(params[1]);
    if (strMethod == "settxfee"               && n > 0) ConvertTo<double>(params[0]);
    if (strMethod == "getreceivedbyaddress"   && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "getreceivedbyaccount"   && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "listreceivedbyaddress"  && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "listreceivedbyaddress"  && n > 1) ConvertTo<bool>(params[1]);
    if (strMethod == "listreceivedbyaccount"  && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "listreceivedbyaccount"  && n > 1) ConvertTo<bool>(params[1]);
    if (strMethod == "getbalance"             && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "getblockhash"           && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "move"                   && n > 2) ConvertTo<double>(params[2]);
    if (strMethod == "move"                   && n > 3) ConvertTo<int64_t>(params[3]);
    if (strMethod == "sendfrom"               && n > 2) ConvertTo<double>(params[2]);
    if (strMethod == "sendfrom"               && n > 3) ConvertTo<int64_t>(params[3]);
    if (strMethod == "listtransactions"       && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "listtransactions"       && n > 2) ConvertTo<int64_t>(params[2]);
    if (strMethod == "listaccounts"           && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "walletpassphrase"       && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "getblocktemplate"       && n > 0) ConvertTo<Object>(params[0]);
    if (strMethod == "listsinceblock"         && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "sendmany"               && n > 1) ConvertTo<Object>(params[1]);
    if (strMethod == "sendmany"               && n > 2) ConvertTo<int64_t>(params[2]);
    if (strMethod == "addmultisigaddress"     && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "addmultisigaddress"     && n > 1) ConvertTo<Array>(params[1]);
    if (strMethod == "createmultisig"         && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "createmultisig"         && n > 1) ConvertTo<Array>(params[1]);
    if (strMethod == "listunspent"            && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "listunspent"            && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "listunspent"            && n > 2) ConvertTo<Array>(params[2]);
    if (strMethod == "getblock"               && n > 1) ConvertTo<bool>(params[1]);
    if (strMethod == "getrawtransaction"      && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "createrawtransaction"   && n > 0) ConvertTo<Array>(params[0]);
    if (strMethod == "createrawtransaction"   && n > 1) ConvertTo<Object>(params[1]);
    if (strMethod == "signrawtransaction"     && n > 1) ConvertTo<Array>(params[1], true);
    if (strMethod == "signrawtransaction"     && n > 2) ConvertTo<Array>(params[2], true);
    if (strMethod == "sendrawtransaction"     && n > 1) ConvertTo<bool>(params[1], true);
    if (strMethod == "gettxout"               && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "gettxout"               && n > 2) ConvertTo<bool>(params[2]);
    if (strMethod == "lockunspent"            && n > 0) ConvertTo<bool>(params[0]);
    if (strMethod == "lockunspent"            && n > 1) ConvertTo<Array>(params[1]);
    if (strMethod == "importprivkey"          && n > 2) ConvertTo<bool>(params[2]);
    if (strMethod == "verifychain"            && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "verifychain"            && n > 1) ConvertTo<int64_t>(params[1]);
    if (strMethod == "keypoolrefill"          && n > 0) ConvertTo<int64_t>(params[0]);
    if (strMethod == "getrawmempool"          && n > 0) ConvertTo<bool>(params[0]);

    return params;
}
void ScriptDebuggerRemote::_send_object_id(ObjectID p_id) {

	Object *obj = ObjectDB::get_instance(p_id);
	if (!obj)
		return;

	typedef Pair<PropertyInfo, Variant> PropertyDesc;
	List<PropertyDesc> properties;

	if (ScriptInstance *si = obj->get_script_instance()) {
		if (!si->get_script().is_null()) {

			typedef Map<const Script *, Set<StringName> > ScriptMemberMap;
			typedef Map<const Script *, Map<StringName, Variant> > ScriptConstantsMap;

			ScriptMemberMap members;
			members[si->get_script().ptr()] = Set<StringName>();
			si->get_script()->get_members(&(members[si->get_script().ptr()]));

			ScriptConstantsMap constants;
			constants[si->get_script().ptr()] = Map<StringName, Variant>();
			si->get_script()->get_constants(&(constants[si->get_script().ptr()]));

			Ref<Script> base = si->get_script()->get_base_script();
			while (base.is_valid()) {

				members[base.ptr()] = Set<StringName>();
				base->get_members(&(members[base.ptr()]));

				constants[base.ptr()] = Map<StringName, Variant>();
				base->get_constants(&(constants[base.ptr()]));

				base = base->get_base_script();
			}

			for (ScriptMemberMap::Element *sm = members.front(); sm; sm = sm->next()) {
				for (Set<StringName>::Element *E = sm->get().front(); E; E = E->next()) {
					Variant m;
					if (si->get(E->get(), m)) {
						String script_path = sm->key() == si->get_script().ptr() ? "" : sm->key()->get_path().get_file() + "/";
						PropertyInfo pi(m.get_type(), "Members/" + script_path + E->get());
						properties.push_back(PropertyDesc(pi, m));
					}
				}
			}

			for (ScriptConstantsMap::Element *sc = constants.front(); sc; sc = sc->next()) {
				for (Map<StringName, Variant>::Element *E = sc->get().front(); E; E = E->next()) {
					String script_path = sc->key() == si->get_script().ptr() ? "" : sc->key()->get_path().get_file() + "/";
					if (E->value().get_type() == Variant::OBJECT) {
						Variant id = ((Object *)E->value())->get_instance_id();
						PropertyInfo pi(id.get_type(), "Constants/" + E->key(), PROPERTY_HINT_OBJECT_ID, "Object");
						properties.push_back(PropertyDesc(pi, id));
					} else {
						PropertyInfo pi(E->value().get_type(), "Constants/" + script_path + E->key());
						properties.push_back(PropertyDesc(pi, E->value()));
					}
				}
			}
		}
	}
	if (Node *node = Object::cast_to<Node>(obj)) {
		PropertyInfo pi(Variant::NODE_PATH, String("Node/path"));
		properties.push_front(PropertyDesc(pi, node->get_path()));
	} else if (Resource *res = Object::cast_to<Resource>(obj)) {
		if (Script *s = Object::cast_to<Script>(res)) {
			Map<StringName, Variant> constants;
			s->get_constants(&constants);
			for (Map<StringName, Variant>::Element *E = constants.front(); E; E = E->next()) {
				if (E->value().get_type() == Variant::OBJECT) {
					Variant id = ((Object *)E->value())->get_instance_id();
					PropertyInfo pi(id.get_type(), "Constants/" + E->key(), PROPERTY_HINT_OBJECT_ID, "Object");
					properties.push_front(PropertyDesc(pi, E->value()));
				} else {
					PropertyInfo pi(E->value().get_type(), String("Constants/") + E->key());
					properties.push_front(PropertyDesc(pi, E->value()));
				}
			}
		}
	}

	List<PropertyInfo> pinfo;
	obj->get_property_list(&pinfo, true);
	for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
		if (E->get().usage & (PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_CATEGORY)) {
			properties.push_back(PropertyDesc(E->get(), obj->get(E->get().name)));
		}
	}

	Array send_props;
	for (int i = 0; i < properties.size(); i++) {
		const PropertyInfo &pi = properties[i].first;
		Variant &var = properties[i].second;

		WeakRef *ref = Object::cast_to<WeakRef>(var);
		if (ref) {
			var = ref->get_ref();
		}

		RES res = var;

		Array prop;
		prop.push_back(pi.name);
		prop.push_back(pi.type);

		//only send information that can be sent..
		int len = 0; //test how big is this to encode
		encode_variant(var, NULL, len);
		if (len > packet_peer_stream->get_output_buffer_max_size()) { //limit to max size
			prop.push_back(PROPERTY_HINT_OBJECT_TOO_BIG);
			prop.push_back("");
			prop.push_back(pi.usage);
			prop.push_back(Variant());
		} else {
			prop.push_back(pi.hint);
			prop.push_back(pi.hint_string);
			prop.push_back(pi.usage);

			if (!res.is_null()) {
				var = res->get_path();
			}

			prop.push_back(var);
		}
		send_props.push_back(prop);
	}

	packet_peer_stream->put_var("message:inspect_object");
	packet_peer_stream->put_var(3);
	packet_peer_stream->put_var(p_id);
	packet_peer_stream->put_var(obj->get_class());
	packet_peer_stream->put_var(send_props);
}
Example #11
0
int
main (int argc, char *argv[])
{
  // global_size_t: Tpetra defines this unsigned integer type big
  // enough to hold any global dimension or amount of data.
  using Tpetra::global_size_t;
  using Teuchos::Array;
  using Teuchos::ArrayView;
  using Teuchos::ArrayRCP;
  using Teuchos::RCP;
  using Teuchos::rcp;

  // Put these typedefs here, to avoid global shadowing warnings.
  typedef Tpetra::Map<local_ordinal_type, global_ordinal_type> map_type;
  typedef Tpetra::CrsMatrix<scalar_type, local_ordinal_type, global_ordinal_type> mat_type;

  Teuchos::oblackholestream blackhole;
  Teuchos::GlobalMPISession mpiSession (&argc, &argv, &blackhole);
  RCP<const Teuchos::Comm<int> > comm =
    Tpetra::DefaultPlatform::getDefaultPlatform ().getComm ();
  const size_t myRank = comm->getRank ();

  global_ordinal_type nx=10, ny=10;
  scalar_type a=4,b=-1,c=-1,d=-1,e=-1;

  //global_size_t numMyElts;
  Array<global_ordinal_type> myElts;

  switch (myRank) {

  case 0:
    //numMyElts=40;
    for (int i=0; i<10; ++i) {
      for (int j=0; j<4; ++j) {
        myElts.push_back(i+10*j);
      }
    }
    break;

  case 1:
    //numMyElts=30;
    for (int i=40; i<50; ++i) {
      for (int j=0; j<3; ++j) {
        myElts.push_back(i+10*j);
      }
    }
    break;

  case 2:
    //numMyElts=30;
    for (int i=70; i<80; ++i) {
      for (int j=0; j<3; ++j) {
        myElts.push_back(i+10*j);
      }
    }
    break;
  }

/*
  My global indices: [0, 10, 20, 30, 1, 11, 21, 31, 2, 12, 22, 32, 3, 13, 23, 33, 4, 14, 24, 34, 5, 15, 25, 35, 6, 16, 26, 36, 7, 17, 27, 37, 8, 18, 28, 38, 9, 19, 29, 39]
 Process 1:
  My number of entries: 30
  My minimum global index: 40
  My maximum global index: 69
  My global indices: [40, 50, 60, 41, 51, 61, 42, 52, 62, 43, 53, 63, 44, 54, 64, 45, 55, 65, 46, 56, 66, 47, 57, 67, 48, 58, 68, 49, 59, 69]
 Process 2:
  My number of entries: 30
  My minimum global index: 70
  My maximum global index: 99
  My global indices: [70, 80, 90, 71, 81, 91, 72, 82, 92, 73, 83, 93, 74, 84, 94, 75, 85, 95, 76, 86, 96, 77, 87, 97, 78, 88, 98, 79, 89, 99]
*/

  const global_ordinal_type indexBase = 0;
  RCP<const map_type> map = rcp (new map_type (100, myElts (), indexBase, comm));

  RCP<Teuchos::FancyOStream> fos =
    Teuchos::fancyOStream (Teuchos::rcpFromRef (std::cout));
  //fos->setOutputToRootOnly(-1);
  //map->describe(*fos,Teuchos::VERB_EXTREME);

  const size_t numMyElements = map->getNodeNumElements ();
  switch (myRank) {
  case 0:
    assert(numMyElements==40);
    break;
  case 1:
    assert(numMyElements==30);
    break;
  case 2:
    assert(numMyElements==30);
    break;
  }

  // FIXME (mfh 19 Mar 2014) Once you set this
  // ("setOutputToRootOnly"), you can't unset it.
  fos->setOutputToRootOnly(0);
  *fos << std::endl << "Creating the sparse matrix" << std::endl;

  local_ordinal_type nnz=5;
  RCP<mat_type> A = rcp (new mat_type (map, nnz));

  ArrayView<const global_ordinal_type> myGlobalElements = map->getNodeElementList();

  global_ordinal_type center, left, right, lower, upper;
  std::vector<scalar_type>        vals(nnz);
  std::vector<global_ordinal_type> inds(nnz);

  //    e
  //  b a c
  //    d
  for (size_t i = 0; i < numMyElements; ++i)  {
    size_t n = 0;

    center = myGlobalElements[i] - indexBase;
    GetNeighboursCartesian2d(center, nx, ny, left, right, lower, upper);

    if (left  != -1) { inds[n] = left;  vals[n++] = b; }
    if (right != -1) { inds[n] = right; vals[n++] = c; }
    if (lower != -1) { inds[n] = lower; vals[n++] = d; }
    if (upper != -1) { inds[n] = upper; vals[n++] = e; }

    // diagonal
    scalar_type z = a;
    inds[n]   = center;
    vals[n++] = z;

    for (size_t j = 0; j < n; j++)
      inds[j] += indexBase;

    ArrayView<global_ordinal_type> iv(&inds[0], n);
    ArrayView<scalar_type>        av(&vals[0], n);
    A->insertGlobalValues(myGlobalElements[i], iv, av);
  }

  A->fillComplete ();

  // Make sure that all processes finished fillComplete, before
  // reporting success.
  comm->barrier ();
  if (comm->getRank () == 0) {
    std::cout << "End Result: TEST PASSED" << std::endl;
    return EXIT_SUCCESS;
  }
}
Object blockToJSON(const CBlock& block, const CBlockIndex* blockindex)
{


    Object result;
    result.push_back(Pair("hash", block.GetHash().GetHex()));
    CMerkleTx txGen(block.vtx[0]);
    txGen.SetMerkleBranch(&block);
    result.push_back(Pair("confirmations", (int)txGen.GetDepthInMainChain()));
    result.push_back(Pair("size", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION)));
    result.push_back(Pair("height", blockindex->nHeight));
    result.push_back(Pair("version", block.nVersion));
    result.push_back(Pair("merkleroot", block.hashMerkleRoot.GetHex()));
    Array txs;
    BOOST_FOREACH(const CTransaction&tx, block.vtx)
        txs.push_back(tx.GetHash().GetHex());
    result.push_back(Pair("tx", txs));
    result.push_back(Pair("time", (boost::int64_t)block.GetBlockTime()));
    result.push_back(Pair("nonce", (boost::uint64_t)block.nNonce));
    result.push_back(Pair("bits", HexBits(block.nBits)));
    result.push_back(Pair("difficulty", GetDifficulty(blockindex)));
	
	//result.push_back(Pair("boinchash", block.hashBoinc));

    MiningCPID bb = DeserializeBoincBlock(block.hashBoinc);
	uint256 blockhash = block.GetPoWHash();
	std::string sblockhash = blockhash.GetHex();
	result.push_back(Pair("BlockType", block.BlockType));
	result.push_back(Pair("CPID", bb.cpid));
	result.push_back(Pair("ProjectName", bb.projectname));
	result.push_back(Pair("BlockDiffBytes", (double)bb.diffbytes));
	result.push_back(Pair("RAC", bb.rac));
	result.push_back(Pair("NetworkRAC", bb.NetworkRAC));
	//if (block.hashBoinc.length() > 10) 
	//{
		//result.push_back(Pair("BoincHash",block.hashBoinc.substr(0,100)));
	//}
	result.push_back(Pair("PoBDifficulty", bb.pobdifficulty));
	result.push_back(Pair("AES512SkeinHash", bb.aesskein));
	std::string skein2 = aes_complex_hash(blockhash);
	result.push_back(Pair("AESCalcHash",skein2));
	uint256 boincpowhash = block.hashMerkleRoot + bb.nonce;

	int iav  = TestAESHash(bb.rac, (unsigned int)bb.diffbytes, boincpowhash, bb.aesskein);
	result.push_back(Pair("AES512Valid",iav));
	result.push_back(Pair("ClientVersion",bb.clientversion));	
	std::string hbd = AdvancedDecrypt(bb.enccpid);
	bool IsCpidValid = IsCPIDValid(bb.cpid, bb.enccpid);

	result.push_back(Pair("CPIDValid",IsCpidValid));
	result.push_back(Pair("PoWHash",blockhash.GetHex()));
	//Subsidy 6-29-2014

	result.push_back(Pair("Subsidy", ValueFromAmount(GetBlockValueByHash(block.GetHash()))));

    if (blockindex->pprev)
        result.push_back(Pair("previousblockhash", blockindex->pprev->GetBlockHash().GetHex()));
    if (blockindex->pnext)
        result.push_back(Pair("nextblockhash", blockindex->pnext->GetBlockHash().GetHex()));
    return result;
}
void ScriptEditorDebugger::_property_changed(Object*p_base,const StringName& p_property,const Variant& p_value){

	if (!p_base || !live_debug || !connection.is_valid() || !editor->get_edited_scene())
		return;

	Node *node = p_base->cast_to<Node>();

	if (node) {

		NodePath path = editor->get_edited_scene()->get_path_to(node);
		int pathid = _get_node_path_cache(path);


		if (p_value.is_ref()) {
			Ref<Resource> res = p_value;
			if (res.is_valid() && res->get_path()!=String()) {

				Array msg;
				msg.push_back("live_node_prop_res");
				msg.push_back(pathid);
				msg.push_back(p_property);
				msg.push_back(res->get_path());
				ppeer->put_var(msg);
			}
		} else {

			Array msg;
			msg.push_back("live_node_prop");
			msg.push_back(pathid);
			msg.push_back(p_property);
			msg.push_back(p_value);
			ppeer->put_var(msg);
		}


		return;

	}

	Resource *res = p_base->cast_to<Resource>();

	if (res && res->get_path()!=String()) {

		String respath = res->get_path();
		int pathid = _get_res_path_cache(respath);


		if (p_value.is_ref()) {
			Ref<Resource> res = p_value;
			if (res.is_valid() && res->get_path()!=String()) {

				Array msg;
				msg.push_back("live_res_prop_res");
				msg.push_back(pathid);
				msg.push_back(p_property);
				msg.push_back(res->get_path());
				ppeer->put_var(msg);
			}
		} else {

			Array msg;
			msg.push_back("live_res_prop");
			msg.push_back(pathid);
			msg.push_back(p_property);
			msg.push_back(p_value);
			ppeer->put_var(msg);
		}


		return;
	}


	//print_line("prop");
}
    virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {

        switch(func) {
        case VisualScriptBuiltinFunc::MATH_SIN: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::sin(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_COS: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::cos(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_TAN: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::tan(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_SINH: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::sinh(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_COSH: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::cosh(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_TANH: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::tanh(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_ASIN: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::asin(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_ACOS: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::acos(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_ATAN: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::atan(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_ATAN2: {

            VALIDATE_ARG_NUM(0);
            VALIDATE_ARG_NUM(1);
            *p_outputs[0]=Math::atan2(*p_inputs[0],*p_inputs[1]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_SQRT: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::sqrt(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_FMOD: {

            VALIDATE_ARG_NUM(0);
            VALIDATE_ARG_NUM(1);
            *p_outputs[0]=Math::fmod(*p_inputs[0],*p_inputs[1]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_FPOSMOD: {

            VALIDATE_ARG_NUM(0);
            VALIDATE_ARG_NUM(1);
            *p_outputs[0]=Math::fposmod(*p_inputs[0],*p_inputs[1]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_FLOOR: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::floor(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_CEIL: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::ceil(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_ROUND: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::round(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_ABS: {

            if (p_inputs[0]->get_type()==Variant::INT) {

                int64_t i = *p_inputs[0];
                *p_outputs[0]=ABS(i);
            } else if (p_inputs[0]->get_type()==Variant::REAL) {

                real_t r = *p_inputs[0];
                *p_outputs[0]=Math::abs(r);
            } else {

                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=0;
                r_error.expected=Variant::REAL;

            }
        }
        break;
        case VisualScriptBuiltinFunc::MATH_SIGN: {

            if (p_inputs[0]->get_type()==Variant::INT) {

                int64_t i = *p_inputs[0];
                *p_outputs[0]= i < 0 ? -1 : ( i > 0 ? +1 : 0);
            } else if (p_inputs[0]->get_type()==Variant::REAL) {

                real_t r = *p_inputs[0];
                *p_outputs[0]= r < 0.0 ? -1.0 : ( r > 0.0 ? +1.0 : 0.0);
            } else {

                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=0;
                r_error.expected=Variant::REAL;

            }
        }
        break;
        case VisualScriptBuiltinFunc::MATH_POW: {

            VALIDATE_ARG_NUM(0);
            VALIDATE_ARG_NUM(1);
            *p_outputs[0]=Math::pow(*p_inputs[0],*p_inputs[1]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_LOG: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::log(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_EXP: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::exp(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_ISNAN: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::is_nan(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_ISINF: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::is_inf(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_EASE: {

            VALIDATE_ARG_NUM(0);
            VALIDATE_ARG_NUM(1);
            *p_outputs[0]=Math::ease(*p_inputs[0],*p_inputs[1]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_DECIMALS: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::step_decimals(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_STEPIFY: {

            VALIDATE_ARG_NUM(0);
            VALIDATE_ARG_NUM(1);
            *p_outputs[0]=Math::stepify(*p_inputs[0],*p_inputs[1]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_LERP: {

            VALIDATE_ARG_NUM(0);
            VALIDATE_ARG_NUM(1);
            VALIDATE_ARG_NUM(2);
            *p_outputs[0]=Math::lerp(*p_inputs[0],*p_inputs[1],*p_inputs[2]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_DECTIME: {

            VALIDATE_ARG_NUM(0);
            VALIDATE_ARG_NUM(1);
            VALIDATE_ARG_NUM(2);
            *p_outputs[0]=Math::dectime(*p_inputs[0],*p_inputs[1],*p_inputs[2]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_RANDOMIZE: {
            Math::randomize();

        }
        break;
        case VisualScriptBuiltinFunc::MATH_RAND: {
            *p_outputs[0]=Math::rand();
        }
        break;
        case VisualScriptBuiltinFunc::MATH_RANDF: {
            *p_outputs[0]=Math::randf();
        }
        break;
        case VisualScriptBuiltinFunc::MATH_RANDOM: {

            VALIDATE_ARG_NUM(0);
            VALIDATE_ARG_NUM(1);
            *p_outputs[0]=Math::random(*p_inputs[0],*p_inputs[1]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_SEED: {

            VALIDATE_ARG_NUM(0);
            uint32_t seed=*p_inputs[0];
            Math::seed(seed);

        }
        break;
        case VisualScriptBuiltinFunc::MATH_RANDSEED: {

            VALIDATE_ARG_NUM(0);
            uint32_t seed=*p_inputs[0];
            int ret = Math::rand_from_seed(&seed);
            Array reta;
            reta.push_back(ret);
            reta.push_back(seed);
            *p_outputs[0]=reta;

        }
        break;
        case VisualScriptBuiltinFunc::MATH_DEG2RAD: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::deg2rad(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_RAD2DEG: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::rad2deg(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_LINEAR2DB: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::linear2db(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::MATH_DB2LINEAR: {

            VALIDATE_ARG_NUM(0);
            *p_outputs[0]=Math::db2linear(*p_inputs[0]);
        }
        break;
        case VisualScriptBuiltinFunc::LOGIC_MAX: {

            if (p_inputs[0]->get_type()==Variant::INT && p_inputs[1]->get_type()==Variant::INT) {

                int64_t a = *p_inputs[0];
                int64_t b = *p_inputs[1];
                *p_outputs[0]=MAX(a,b);
            } else {
                VALIDATE_ARG_NUM(0);
                VALIDATE_ARG_NUM(1);

                real_t a = *p_inputs[0];
                real_t b = *p_inputs[1];

                *p_outputs[0]=MAX(a,b);
            }

        }
        break;
        case VisualScriptBuiltinFunc::LOGIC_MIN: {

            if (p_inputs[0]->get_type()==Variant::INT && p_inputs[1]->get_type()==Variant::INT) {

                int64_t a = *p_inputs[0];
                int64_t b = *p_inputs[1];
                *p_outputs[0]=MIN(a,b);
            } else {
                VALIDATE_ARG_NUM(0);
                VALIDATE_ARG_NUM(1);

                real_t a = *p_inputs[0];
                real_t b = *p_inputs[1];

                *p_outputs[0]=MIN(a,b);
            }
        }
        break;
        case VisualScriptBuiltinFunc::LOGIC_CLAMP: {

            if (p_inputs[0]->get_type()==Variant::INT && p_inputs[1]->get_type()==Variant::INT && p_inputs[2]->get_type()==Variant::INT) {

                int64_t a = *p_inputs[0];
                int64_t b = *p_inputs[1];
                int64_t c = *p_inputs[2];
                *p_outputs[0]=CLAMP(a,b,c);
            } else {
                VALIDATE_ARG_NUM(0);
                VALIDATE_ARG_NUM(1);
                VALIDATE_ARG_NUM(2);

                real_t a = *p_inputs[0];
                real_t b = *p_inputs[1];
                real_t c = *p_inputs[2];

                *p_outputs[0]=CLAMP(a,b,c);
            }
        }
        break;
        case VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2: {

            VALIDATE_ARG_NUM(0);
            int64_t num = *p_inputs[0];
            *p_outputs[0] = nearest_power_of_2(num);
        }
        break;
        case VisualScriptBuiltinFunc::OBJ_WEAKREF: {

            if (p_inputs[0]->get_type()!=Variant::OBJECT) {

                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=0;
                r_error.expected=Variant::OBJECT;

                return 0;

            }

            if (p_inputs[0]->is_ref()) {

                REF r = *p_inputs[0];
                if (!r.is_valid()) {

                    return 0;
                }

                Ref<WeakRef> wref = memnew( WeakRef );
                wref->set_ref(r);
                *p_outputs[0]=wref;
            } else {
                Object *obj = *p_inputs[0];
                if (!obj) {

                    return 0;
                }
                Ref<WeakRef> wref = memnew( WeakRef );
                wref->set_obj(obj);
                *p_outputs[0]=wref;
            }




        }
        break;
        case VisualScriptBuiltinFunc::FUNC_FUNCREF: {

            if (p_inputs[0]->get_type()!=Variant::OBJECT) {

                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=0;
                r_error.expected=Variant::OBJECT;

                return 0;

            }
            if (p_inputs[1]->get_type()!=Variant::STRING && p_inputs[1]->get_type()!=Variant::NODE_PATH) {

                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=1;
                r_error.expected=Variant::STRING;

                return 0;

            }

            Ref<FuncRef> fr = memnew( FuncRef);

            fr->set_instance(*p_inputs[0]);
            fr->set_function(*p_inputs[1]);

            *p_outputs[0]=fr;

        }
        break;
        case VisualScriptBuiltinFunc::TYPE_CONVERT: {

            VALIDATE_ARG_NUM(1);
            int type=*p_inputs[1];
            if (type<0 || type>=Variant::VARIANT_MAX) {

                *p_outputs[0]=RTR("Invalid type argument to convert(), use TYPE_* constants.");
                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=0;
                r_error.expected=Variant::INT;
                return 0;

            } else {


                *p_outputs[0]=Variant::construct(Variant::Type(type),p_inputs,1,r_error);
            }
        }
        break;
        case VisualScriptBuiltinFunc::TYPE_OF: {


            *p_outputs[0] = p_inputs[0]->get_type();

        }
        break;
        case VisualScriptBuiltinFunc::TYPE_EXISTS: {


            *p_outputs[0] = ObjectTypeDB::type_exists(*p_inputs[0]);

        }
        break;
        case VisualScriptBuiltinFunc::TEXT_STR: {

            String str = *p_inputs[0];

            *p_outputs[0]=str;

        }
        break;
        case VisualScriptBuiltinFunc::TEXT_PRINT: {

            String str = *p_inputs[0];
            print_line(str);


        }
        break;

        case VisualScriptBuiltinFunc::TEXT_PRINTERR: {

            String str = *p_inputs[0];

            //str+="\n";
            OS::get_singleton()->printerr("%s\n",str.utf8().get_data());


        }
        break;
        case VisualScriptBuiltinFunc::TEXT_PRINTRAW: {
            String str = *p_inputs[0];

            //str+="\n";
            OS::get_singleton()->print("%s",str.utf8().get_data());


        }
        break;
        case VisualScriptBuiltinFunc::VAR_TO_STR: {

            String vars;
            VariantWriter::write_to_string(*p_inputs[0],vars);
            *p_outputs[0]=vars;
        }
        break;
        case VisualScriptBuiltinFunc::STR_TO_VAR: {

            if (p_inputs[0]->get_type()!=Variant::STRING) {
                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=0;
                r_error.expected=Variant::STRING;

                return 0;
            }

            VariantParser::StreamString ss;
            ss.s=*p_inputs[0];

            String errs;
            int line;
            Error err = VariantParser::parse(&ss,*p_outputs[0],errs,line);

            if (err!=OK) {
                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=0;
                r_error.expected=Variant::STRING;
                *p_outputs[0]="Parse error at line "+itos(line)+": "+errs;
                return 0;
            }

        }
        break;
        case VisualScriptBuiltinFunc::VAR_TO_BYTES: {


            ByteArray barr;
            int len;
            Error err = encode_variant(*p_inputs[0],NULL,len);
            if (err) {
                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=0;
                r_error.expected=Variant::NIL;
                *p_outputs[0]="Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
                return 0;
            }

            barr.resize(len);
            {
                ByteArray::Write w = barr.write();
                encode_variant(*p_inputs[0],w.ptr(),len);

            }
            *p_outputs[0]=barr;
        }
        break;
        case VisualScriptBuiltinFunc::BYTES_TO_VAR: {

            if (p_inputs[0]->get_type()!=Variant::RAW_ARRAY) {
                r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                r_error.argument=0;
                r_error.expected=Variant::RAW_ARRAY;

                return 0;
            }

            ByteArray varr=*p_inputs[0];
            Variant ret;
            {
                ByteArray::Read r=varr.read();
                Error err = decode_variant(ret,r.ptr(),varr.size(),NULL);
                if (err!=OK) {
                    *p_outputs[0]=RTR("Not enough bytes for decoding bytes, or invalid format.");
                    r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
                    r_error.argument=0;
                    r_error.expected=Variant::RAW_ARRAY;
                    return 0;
                }

            }

            *p_outputs[0]=ret;

        }
        break;
        default:
        {}
        }
        return 0;
    }
Example #15
0
Variable* add_assign(Variable* A, Variable* B)
{
    if(A == NULL || B == NULL)
    {
        interpreter.error("Error: Void variable in assignment.\n");
        return NULL;
    }
    if(!A->reference)
    {
        interpreter.error("Error: Assigning value to a non-reference variable.\n");
        return NULL;
    }

    TypeEnum a = A->getType();
    TypeEnum b = B->getType();

    bool mismatch = false;
    if(a == STRING)
    {
        if(b != STRING)
            mismatch = true;
        else
        {
            String* C = static_cast<String*>(A);
            String* D = static_cast<String*>(B);
            C->setValue(C->getValue() + D->getValue());
        }
    }
    else if(a == INT)
    {
        if(b != BOOL && b != INT && b != FLOAT)
            mismatch = true;
        else
        {
            Int* C = static_cast<Int*>(A);
            if(b == BOOL)
            {
                Bool* D = static_cast<Bool*>(B);
                C->setValue(C->getValue() + D->getValue());
            }
            else if(b == INT)
            {
                Int* D = static_cast<Int*>(B);
                C->setValue(C->getValue() + D->getValue());
            }
            else
            {
                Float* D = static_cast<Float*>(B);
                C->setValue(C->getValue() + D->getValue());
            }
        }
    }
    else if(a == FLOAT)
    {
        if(b != BOOL && b != INT && b != FLOAT)
            mismatch = true;
        else
        {
            Float* C = static_cast<Float*>(A);
            if(b == BOOL)
            {
                Bool* D = static_cast<Bool*>(B);
                C->setValue(C->getValue() + D->getValue());
            }
            else if(b == INT)
            {
                Int* D = static_cast<Int*>(B);
                C->setValue(C->getValue() + D->getValue());
            }
            else
            {
                Float* D = static_cast<Float*>(B);
                C->setValue(C->getValue() + D->getValue());
            }
        }
    }
    else if(a == BOOL)
    {
        if(b != BOOL && b != INT && b != FLOAT)
            mismatch = true;
        else
        {
            Bool* C = static_cast<Bool*>(A);
            if(b == BOOL)
            {
                Bool* D = static_cast<Bool*>(B);
                C->setValue(C->getValue() + D->getValue());
            }
            else if(b == INT)
            {
                Int* D = static_cast<Int*>(B);
                C->setValue(C->getValue() + D->getValue());
            }
            else
            {
                Float* D = static_cast<Float*>(B);
                C->setValue(C->getValue() + D->getValue());
            }
        }
    }
    else if(a == MACRO)
    {
        interpreter.error("Error: Addition operation not defined for type 'macro'.\n");
        return NULL;
    }
    else if(a == ARRAY)
    {
        if(b == ARRAY)
        {
            Array* C = static_cast<Array*>(A);
            Array* D = static_cast<Array*>(B);
            a = C->getValueType();
            b = C->getValueType();
            if(a != b)
            {
                interpreter.error("Error: Types do not match in assignment: Array<%s> vs Array<%s>\n", C->getValueTypeString().c_str(), D->getValueTypeString().c_str());
                return NULL;
            }
            C->push_back(D->getValue());
        }
        else
        {
            Array* C = static_cast<Array*>(A);
            if(b == C->getValueType())
            {
                C->push_back(B);
            }
            else
                mismatch = true;
        }
    }
    else if(a == LIST)
    {
        // Lists must be concatenated a different way...
        List* C = static_cast<List*>(A);
        C->push_back(B);
    }
    else if(a == FUNCTION)
    {
        interpreter.error("Error: Addition operation not defined for type 'function'.\n");
        return NULL;
    }
    else if(a == PROCEDURE)
    {
        interpreter.error("Error: Addition operation not defined for type 'procedure'.\n");
        return NULL;
    }

    if(mismatch)
    {
        interpreter.error("Error: Types do not match in assignment: %s vs %s\n", A->getTypeString().c_str(), B->getTypeString().c_str());
        return NULL;
    }
    return A;
}
Example #16
0
int main(int argc, char *argv[]) {
  using Teuchos::Array;
  using Teuchos::RCP;
  using Teuchos::rcp;
  using Teuchos::ParameterList;
  using Ifpack2::FunctionParameter;
  using Ifpack2::Hypre::Prec;
  using Ifpack2::Hypre::Solver;

  typedef Tpetra::CrsMatrix<>::scalar_type Scalar;
  typedef Tpetra::CrsMatrix<>::local_ordinal_type LO;
  typedef Tpetra::CrsMatrix<>::global_ordinal_type GO;
  typedef Tpetra::CrsMatrix<>::node_type Node;
  typedef Tpetra::DefaultPlatform::DefaultPlatformType Platform;
  typedef Tpetra::CrsMatrix<Scalar> CrsMatrix;
  typedef Tpetra::MultiVector<Scalar> MV;
  typedef Ifpack2::Preconditioner<Scalar> Preconditioner;
  typedef Tpetra::Map<> Map;

  // Initialize MPI
  Teuchos::oblackholestream blackhole;
  Teuchos::GlobalMPISession mpiSession(&argc,&argv,&blackhole);
  Platform &platform = Tpetra::DefaultPlatform::getDefaultPlatform();
  RCP<const Teuchos::Comm<int> > comm = platform.getComm();

  // Get parameters from command-line processor
  int nx = 10;
  Scalar tol = 1e-6;
  Teuchos::CommandLineProcessor cmdp(false,true);
  cmdp.setOption("nx",&nx, "Number of mesh points in x direction.");
  cmdp.setOption("tolerance",&tol, "Relative residual used for solver.");
  if(cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) {
    return -1;
  }

  // Create the 2D Laplace operator
  int n = nx*nx;
  RCP<Map> map = rcp(new Map(n,0,comm));
  RCP<CrsMatrix> A = rcp(new CrsMatrix(map,5));
  for(LO i = 0; i<nx; i++) {
    for(LO j = 0; j<nx; j++) {
      GO row = i*nx+j;
      if(!map->isNodeGlobalElement(row))
        continue;

      Array<LO> indices;
      Array<Scalar> values;

      if(i > 0) {
        indices.push_back(row - nx);
        values.push_back(-1.0);
      }
      if(i < nx-1) {
        indices.push_back(row + nx);
        values.push_back(-1.0);
      }
      indices.push_back(row);
      values.push_back(4.0);
      if(j > 0) {
        indices.push_back(row-1);
        values.push_back(-1.0);
      }
      if(j < nx-1) {
        indices.push_back(row+1);
        values.push_back(-1.0);
      }
      A->insertGlobalValues(row,indices,values);
    }
  }
  A->fillComplete();

  // Create the vectors
  RCP<MV> X = rcp(new MV(A->getRowMap(),1));
  RCP<MV> B = rcp(new MV(A->getRowMap(),1,false));
  B->randomize();

  // Create the parameters for hypre
  RCP<FunctionParameter> functs[10];
  functs[0] = rcp(new FunctionParameter(Prec,   &HYPRE_BoomerAMGSetPrintLevel, 1));  // print AMG solution info
  functs[1] = rcp(new FunctionParameter(Prec,   &HYPRE_BoomerAMGSetCoarsenType, 6)); // Falgout coarsening
  functs[2] = rcp(new FunctionParameter(Prec,   &HYPRE_BoomerAMGSetRelaxType, 6));   // Sym GS/Jacobi hybrid
  functs[3] = rcp(new FunctionParameter(Prec,   &HYPRE_BoomerAMGSetNumSweeps, 1));   // Sweeps on each level
  functs[4] = rcp(new FunctionParameter(Prec,   &HYPRE_BoomerAMGSetTol, 0.0));       // Conv tolerance zero
  functs[5] = rcp(new FunctionParameter(Prec,   &HYPRE_BoomerAMGSetMaxIter, 1));     // Do only one iteration!
  functs[6] = rcp(new FunctionParameter(Solver, &HYPRE_PCGSetMaxIter, 1000));        // Maximum iterations
  functs[7] = rcp(new FunctionParameter(Solver, &HYPRE_PCGSetTol, tol));             // Convergence tolerance
  functs[8] = rcp(new FunctionParameter(Solver, &HYPRE_PCGSetTwoNorm, 1));           // Use the two-norm as the stopping criteria
  functs[9] = rcp(new FunctionParameter(Solver, &HYPRE_PCGSetPrintLevel, 2));        // Print solve info

  // Create the hypre solver and preconditioner
  RCP<Preconditioner> prec = rcp(new Ifpack2::Ifpack2_Hypre<Scalar,LO,GO,Node>(A));
  ParameterList hypreList;
  hypreList.set("SolveOrPrecondition", Solver);
  hypreList.set("Solver", Ifpack2::Hypre::PCG);
  hypreList.set("Preconditioner", Ifpack2::Hypre::BoomerAMG);
  hypreList.set("SetPreconditioner", true);
  hypreList.set("NumFunctions", 10);
  hypreList.set<RCP<FunctionParameter>*>("Functions", functs);
  prec->setParameters(hypreList);
  prec->compute();

  // Perform solve
  prec->apply(*B,*X);

  return 0;
}
void ScriptEditorDebugger::_notification(int p_what) {

	switch(p_what) {

		case NOTIFICATION_ENTER_TREE: {

			inspector->edit(variables);

			step->set_icon( get_icon("DebugStep","EditorIcons"));
			next->set_icon( get_icon("DebugNext","EditorIcons"));
			back->set_icon( get_icon("Back","EditorIcons"));
			forward->set_icon( get_icon("Forward","EditorIcons"));
			dobreak->set_icon( get_icon("Pause","EditorIcons"));
			docontinue->set_icon( get_icon("DebugContinue","EditorIcons"));
			//scene_tree_refresh->set_icon( get_icon("Reload","EditorIcons"));
			le_set->connect("pressed",this,"_live_edit_set");
			le_clear->connect("pressed",this,"_live_edit_clear");
			error_list->connect("item_selected",this,"_error_selected");
			error_stack->connect("item_selected",this,"_error_stack_selected");
			vmem_refresh->set_icon( get_icon("Reload","EditorIcons"));

		} break;
		case NOTIFICATION_PROCESS: {

			if (connection.is_valid()) {
				inspect_scene_tree_timeout-=get_process_delta_time();
				if (inspect_scene_tree_timeout<0) {
					inspect_scene_tree_timeout=EditorSettings::get_singleton()->get("debugger/scene_tree_refresh_interval");
					if (inspect_scene_tree->is_visible()) {
						_scene_tree_request();

						if (inspected_object_id!=0) {
							//take the chance and re-inspect selected object
							Array msg;
							msg.push_back("inspect_object");
							msg.push_back(inspected_object_id);
							ppeer->put_var(msg);
						}
					}
				}

				inspect_edited_object_timeout-=get_process_delta_time();
				if (inspect_edited_object_timeout<0) {
					inspect_edited_object_timeout=EditorSettings::get_singleton()->get("debugger/remote_inspect_refresh_interval");
					if (inspect_scene_tree->is_visible() && inspected_object_id) {
						//take the chance and re-inspect selected object
						Array msg;
						msg.push_back("inspect_object");
						msg.push_back(inspected_object_id);
						ppeer->put_var(msg);
					}
				}
			}

			if (error_count!=last_error_count) {

				if (error_count==0) {
					error_split->set_name(TTR("Errors"));
					debugger_button->set_text(TTR("Debugger"));
					debugger_button->set_icon(Ref<Texture>());
					tabs->set_tab_icon(error_split->get_index(),Ref<Texture>());
				} else {
					error_split->set_name(TTR("Errors")+" ("+itos(error_count)+")");
					debugger_button->set_text(TTR("Debugger")+" ("+itos(error_count)+")");
					debugger_button->set_icon(get_icon("Error","EditorIcons"));
					tabs->set_tab_icon(error_split->get_index(),get_icon("Error","EditorIcons"));
				}
				last_error_count=error_count;
			}

			if (connection.is_null()) {

				if (server->is_connection_available()) {

					connection = server->take_connection();
					if (connection.is_null())
						break;

					EditorNode::get_log()->add_message("** Debug Process Started **");
					log_forced_visible=false;

					ppeer->set_stream_peer(connection);

					//EditorNode::get_singleton()->make_bottom_panel_item_visible(this);
					//emit_signal("show_debugger",true);

					dobreak->set_disabled(false);
					tabs->set_current_tab(0);

					reason->set_text(TTR("Child Process Connected"));
					reason->set_tooltip(TTR("Child Process Connected"));
					profiler->clear();

					inspect_scene_tree->clear();
					le_set->set_disabled(true);
					le_clear->set_disabled(false);
					error_list->clear();
					error_stack->clear();
					error_count=0;
					profiler_signature.clear();
					//live_edit_root->set_text("/root");

					EditorNode::get_singleton()->get_pause_button()->set_pressed(false);
					EditorNode::get_singleton()->get_pause_button()->set_disabled(false);

					update_live_edit_root();
					if (profiler->is_profiling()) {
						_profiler_activate(true);
					}


				} else {

					break;
				}
			};

			if (!connection->is_connected()) {
				stop();
				editor->notify_child_process_exited(); //somehow, exited
				break;
			};

			if (ppeer->get_available_packet_count() <= 0) {
				break;
			};

			while(ppeer->get_available_packet_count() > 0) {

				if (pending_in_queue) {

					int todo = MIN( ppeer->get_available_packet_count(), pending_in_queue );

					for(int i=0;i<todo;i++) {

						Variant cmd;
						Error ret = ppeer->get_var(cmd);
						if (ret!=OK) {
							stop();
							ERR_FAIL_COND(ret!=OK);
						}

						message.push_back(cmd);
						pending_in_queue--;
					}


					if (pending_in_queue==0) {
						_parse_message(message_type,message);
						message.clear();

					}


				} else {

					if (ppeer->get_available_packet_count()>=2) {


						Variant cmd;
						Error ret = ppeer->get_var(cmd);
						if (ret!=OK) {
							stop();
							ERR_FAIL_COND(ret!=OK);
						}
						if (cmd.get_type()!=Variant::STRING) {
							stop();
							ERR_FAIL_COND(cmd.get_type()!=Variant::STRING);
						}

						message_type=cmd;
						//print_line("GOT: "+message_type);

						ret = ppeer->get_var(cmd);
						if (ret!=OK) {
							stop();
							ERR_FAIL_COND(ret!=OK);
						}
						if (cmd.get_type()!=Variant::INT) {
							stop();
							ERR_FAIL_COND(cmd.get_type()!=Variant::INT);
						}

						pending_in_queue=cmd;

						if (pending_in_queue==0) {
							_parse_message(message_type,Array());
							message.clear();
						}

					} else {


						break;
					}

				}
			}



		} break;
	}

}
void ScriptEditorDebugger::_parse_message(const String& p_msg,const Array& p_data) {



	if (p_msg=="debug_enter") {

		Array msg;
		msg.push_back("get_stack_dump");
		ppeer->put_var(msg);
		ERR_FAIL_COND(p_data.size()!=2);
		bool can_continue=p_data[0];
		String error = p_data[1];
		step->set_disabled(!can_continue);
		next->set_disabled(!can_continue);
		reason->set_text(error);
		reason->set_tooltip(error);
		breaked=true;
		dobreak->set_disabled(true);
		docontinue->set_disabled(false);
		emit_signal("breaked",true,can_continue);
		OS::get_singleton()->move_window_to_foreground();
		if (error!="") {
			tabs->set_current_tab(0);
		}

		profiler->set_enabled(false);

		EditorNode::get_singleton()->get_pause_button()->set_pressed(true);


		EditorNode::get_singleton()->make_bottom_panel_item_visible(this);

	} else if (p_msg=="debug_exit") {

		breaked=false;
		step->set_disabled(true);
		next->set_disabled(true);
		reason->set_text("");
		reason->set_tooltip("");
		back->set_disabled(true);
		forward->set_disabled(true);
		dobreak->set_disabled(false);
		docontinue->set_disabled(true);
		emit_signal("breaked",false,false,Variant());
		//tabs->set_current_tab(0);
		profiler->set_enabled(true);
		profiler->disable_seeking();

		EditorNode::get_singleton()->get_pause_button()->set_pressed(false);


	} else if (p_msg=="message:click_ctrl") {

		clicked_ctrl->set_text(p_data[0]);
		clicked_ctrl_type->set_text(p_data[1]);

	} else if (p_msg=="message:scene_tree") {

		inspect_scene_tree->clear();
		Map<int,TreeItem*> lv;

		updating_scene_tree=true;

		for(int i=0;i<p_data.size();i+=4) {

			TreeItem *p;
			int level = p_data[i];
			if (level==0) {
				p = NULL;
			} else {
				ERR_CONTINUE(!lv.has(level-1));
				p=lv[level-1];
			}


			TreeItem *it = inspect_scene_tree->create_item(p);

			ObjectID id = ObjectID(p_data[i+3]);

			it->set_text(0,p_data[i+1]);
			if (has_icon(p_data[i+2],"EditorIcons"))
				it->set_icon(0,get_icon(p_data[i+2],"EditorIcons"));
			it->set_metadata(0,id);
			if (id==inspected_object_id) {
				it->select(0);
			}

			if (p) {
				if (!unfold_cache.has(id)) {
					it->set_collapsed(true);
				}
			} else {
				if (unfold_cache.has(id)) { //reverse for root
					it->set_collapsed(true);
				}
			}
			lv[level]=it;
		}
		updating_scene_tree=false;

		le_clear->set_disabled(false);
		le_set->set_disabled(false);
	} else if (p_msg=="message:inspect_object") {


		ObjectID id = p_data[0];
		String type = p_data[1];
		Variant path = p_data[2]; //what to do yet, i don't  know
		int prop_count=p_data[3];

		int idx=4;


		if (inspected_object->last_edited_id!=id) {
			inspected_object->prop_list.clear();
			inspected_object->prop_values.clear();
		}

		for(int i=0;i<prop_count;i++) {

			PropertyInfo pinfo;
			pinfo.name=p_data[idx++];
			pinfo.type=Variant::Type(int(p_data[idx++]));
			pinfo.hint=PropertyHint(int(p_data[idx++]));
			pinfo.hint_string=p_data[idx++];
			if (pinfo.name.begins_with("*")) {
				pinfo.name=pinfo.name.substr(1,pinfo.name.length());
				pinfo.usage=PROPERTY_USAGE_CATEGORY;
			} else {
				pinfo.usage=PROPERTY_USAGE_EDITOR;
			}

			if (inspected_object->last_edited_id!=id) {
				//don't update.. it's the same, instead refresh
				inspected_object->prop_list.push_back(pinfo);
			}


			inspected_object->prop_values[pinfo.name]=p_data[idx++];

			if (inspected_object->last_edited_id==id) {
				//same, just update value, don't rebuild
				inspected_object->update_single(pinfo.name.ascii().get_data());
			}

		}



		if (inspected_object->last_edited_id!=id) {
			//only if different
			inspected_object->update();
		}

		inspected_object->last_edited_id=id;


		inspect_properties->edit(inspected_object);

	} else if (p_msg=="message:video_mem") {

		vmem_tree->clear();
		TreeItem* root=vmem_tree->create_item();

		int total=0;

		for(int i=0;i<p_data.size();i+=4) {

			TreeItem *it = vmem_tree->create_item(root);
			String type=p_data[i+1];
			int bytes=p_data[i+3].operator int();
			it->set_text(0,p_data[i+0]); //path
			it->set_text(1,type); //type
			it->set_text(2,p_data[i+2]); //type
			it->set_text(3,String::humanize_size(bytes)); //type
			total+=bytes;

			if (has_icon(type,"EditorIcons"))
				it->set_icon(0,get_icon(type,"EditorIcons"));
		}

		vmem_total->set_tooltip(TTR("Bytes:")+" "+itos(total));
		vmem_total->set_text(String::humanize_size(total));

	} else if (p_msg=="stack_dump") {

		stack_dump->clear();
		TreeItem *r = stack_dump->create_item();

		for(int i=0;i<p_data.size();i++) {

			Dictionary d = p_data[i];
			ERR_CONTINUE(!d.has("function"));
			ERR_CONTINUE(!d.has("file"));
			ERR_CONTINUE(!d.has("line"));
			ERR_CONTINUE(!d.has("id"));
			TreeItem *s = stack_dump->create_item(r);
			d["frame"]=i;
			s->set_metadata(0,d);

//			String line = itos(i)+" - "+String(d["file"])+":"+itos(d["line"])+" - at func: "+d["function"];
			String line = itos(i)+" - "+String(d["file"])+":"+itos(d["line"]);
			s->set_text(0,line);

			if (i==0)
				s->select(0);
		}
	} else if (p_msg=="stack_frame_vars") {


		variables->clear();



		int ofs =0;
		int mcount = p_data[ofs];

		ofs++;
		for(int i=0;i<mcount;i++) {

			String n = p_data[ofs+i*2+0];
			Variant v = p_data[ofs+i*2+1];

			if (n.begins_with("*")) {

				n=n.substr(1,n.length());
			}

			variables->add_property("members/"+n,v);
		}
		ofs+=mcount*2;

		mcount = p_data[ofs];

		ofs++;
		for(int i=0;i<mcount;i++) {

			String n = p_data[ofs+i*2+0];
			Variant v = p_data[ofs+i*2+1];

			if (n.begins_with("*")) {

				n=n.substr(1,n.length());
			}


			variables->add_property("locals/"+n,v);
		}

		variables->update();
		inspector->edit(variables);

	} else if (p_msg=="output") {

		//OUT
		for(int i=0;i<p_data.size();i++) {

			String t = p_data[i];
			//LOG

			if (EditorNode::get_log()->is_hidden()) {
				log_forced_visible=true;
				if (EditorNode::get_singleton()->are_bottom_panels_hidden()) {
					EditorNode::get_singleton()->make_bottom_panel_item_visible(EditorNode::get_log());
				}
			}
			EditorNode::get_log()->add_message(t);

		}

	} else if (p_msg=="performance") {
		Array arr = p_data[0];
		Vector<float> p;
		p.resize(arr.size());
		for(int i=0;i<arr.size();i++) {
			p[i]=arr[i];
			if (i<perf_items.size()) {
				perf_items[i]->set_text(1,rtos(p[i]));
				if (p[i]>perf_max[i])
					perf_max[i]=p[i];
			}

		}
		perf_history.push_front(p);
		perf_draw->update();

	} else if (p_msg=="error") {

		Array err = p_data[0];

		Array vals;
		vals.push_back(err[0]);
		vals.push_back(err[1]);
		vals.push_back(err[2]);
		vals.push_back(err[3]);

		bool warning = err[9];
		bool e;
		String time = String("%d:%02d:%02d:%04d").sprintf(vals,&e);
		String txt=time+" - "+(err[8].is_zero()?String(err[7]):String(err[8]));

		String tooltip=TTR("Type:")+String(warning?TTR("Warning"):TTR("Error"));
		tooltip+="\n"+TTR("Description:")+" "+String(err[8]);
		tooltip+="\n"+TTR("Time:")+" "+time;
		tooltip+="\nC "+TTR("Error:")+" "+String(err[7]);
		tooltip+="\nC "+TTR("Source:")+" "+String(err[5])+":"+String(err[6]);
		tooltip+="\nC "+TTR("Function:")+" "+String(err[4]);



		error_list->add_item(txt,EditorNode::get_singleton()->get_gui_base()->get_icon(warning?"Warning":"Error","EditorIcons"));
		error_list->set_item_tooltip( error_list->get_item_count() -1,tooltip );

		int scc = p_data[1];

		Array stack;
		stack.resize(scc);
		for(int i=0;i<scc;i++) {
			stack[i]=p_data[2+i];
		}

		error_list->set_item_metadata( error_list->get_item_count() -1,stack );

		error_count++;
		/*
		int count = p_data[1];

		Array cstack;

		OutputError oe = errors.front()->get();

		packet_peer_stream->put_var(oe.hr);
		packet_peer_stream->put_var(oe.min);
		packet_peer_stream->put_var(oe.sec);
		packet_peer_stream->put_var(oe.msec);
		packet_peer_stream->put_var(oe.source_func);
		packet_peer_stream->put_var(oe.source_file);
		packet_peer_stream->put_var(oe.source_line);
		packet_peer_stream->put_var(oe.error);
		packet_peer_stream->put_var(oe.error_descr);
		packet_peer_stream->put_var(oe.warning);
		packet_peer_stream->put_var(oe.callstack);
		*/

	} else if (p_msg=="profile_sig") {
		//cache a signature
		print_line("SIG: "+String(Variant(p_data)));
		profiler_signature[p_data[1]]=p_data[0];

	} else if (p_msg=="profile_frame" || p_msg=="profile_total") {

		EditorProfiler::Metric metric;
		metric.valid=true;
		metric.frame_number=p_data[0];
		metric.frame_time=p_data[1];
		metric.idle_time=p_data[2];
		metric.fixed_time=p_data[3];
		metric.fixed_frame_time=p_data[4];
		int frame_data_amount = p_data[6];
		int frame_function_amount = p_data[7];


		if (frame_data_amount) {
			EditorProfiler::Metric::Category frame_time;
			frame_time.signature="category_frame_time";
			frame_time.name="Frame Time";
			frame_time.total_time=metric.frame_time;

			EditorProfiler::Metric::Category::Item item;
			item.calls=1;
			item.line=0;
			item.name="Fixed Time";
			item.total=metric.fixed_time;
			item.self=item.total;
			item.signature="fixed_time";


			frame_time.items.push_back(item);

			item.name="Idle Time";
			item.total=metric.idle_time;
			item.self=item.total;
			item.signature="idle_time";

			frame_time.items.push_back(item);

			item.name="Fixed Frame Time";
			item.total=metric.fixed_frame_time;
			item.self=item.total;
			item.signature="fixed_frame_time";

			frame_time.items.push_back(item);

			metric.categories.push_back(frame_time);

		}



		int idx=8;
		for(int i=0;i<frame_data_amount;i++) {

			EditorProfiler::Metric::Category c;
			String name=p_data[idx++];
			Array values=p_data[idx++];
			c.name=name.capitalize();
			c.items.resize(values.size()/2);
			c.total_time=0;
			c.signature="categ::"+name;
			for(int i=0;i<values.size();i+=2) {

				EditorProfiler::Metric::Category::Item item;
				item.name=values[i];
				item.calls=1;
				item.self=values[i+1];
				item.total=item.self;
				item.signature="categ::"+name+"::"+item.name;
				item.name=item.name.capitalize();
				c.total_time+=item.total;
				c.items[i/2]=item;


			}
			metric.categories.push_back(c);
		}

		EditorProfiler::Metric::Category funcs;
		funcs.total_time=p_data[5]; //script time
		funcs.items.resize(frame_function_amount);
		funcs.name="Script Functions";
		funcs.signature="script_functions";
		for(int i=0;i<frame_function_amount;i++) {

			int signature = p_data[idx++];
			int calls = p_data[idx++];
			float total = p_data[idx++];
			float self = p_data[idx++];



			EditorProfiler::Metric::Category::Item item;
			if (profiler_signature.has(signature)) {

				item.signature=profiler_signature[signature];

				String name = profiler_signature[signature];
				Vector<String> strings = name.split("::");
				if (strings.size()==3) {
					item.name=strings[2];
					item.script=strings[0];
					item.line=strings[1].to_int();
				}

			} else {
				item.name="SigErr "+itos(signature);
			}




			item.calls=calls;
			item.self=self;
			item.total=total;
			funcs.items[i]=item;

		}

		metric.categories.push_back(funcs);

		if (p_msg=="profile_frame")
			profiler->add_frame_metric(metric,false);
		else
			profiler->add_frame_metric(metric,true);

	} else if (p_msg=="kill_me") {

		editor->call_deferred("stop_child_process");
	}

}
Example #19
0
// Original comment:
//   Triangulation happens in 2d. We could inverse transform the polygon around the normal direction, or we just use the two
//   most signficant axes. Here we find the two longest axes and use them to triangulate.  Inverse transforming them would
//   introduce more doubling point error and isn't worth it.
//
// SC says:
//   This doesn't work: the vertices can be collinear when projected onto the plane of the two longest axes of the bounding box.
//   Example (from real data):
//
//     v[0] = (-13.7199, 4.45725, -8.00059)
//     v[1] = (-0.115787, 12.3116, -4.96109)
//     v[2] = (0.88992, 12.8922, -3.80342)
//     v[3] = (-0.115787, 12.3116, -2.64576)
//     v[4] = (-13.7199, 4.45725, 0.393742)
//     v[5] = (-13.7199, 4.45725, -0.856258)
//     v[6] = (-12.5335, 5.14221, -3.80342)
//     v[7] = (-13.7199, 4.45725, -6.75059)
//
//   Instead, we will project onto the plane of the polygon.
long
Polygon3::triangulate(Array<long> & tri_indices, Real epsilon) const
{
  if (epsilon < 0)
    epsilon = Math::eps<Real>();

  if (vertices.size() < 3)
  {
    tri_indices.clear();
  }
  else if (vertices.size() == 3)
  {
    tri_indices.resize(3);
    tri_indices[0] = vertices[0].index;
    tri_indices[1] = vertices[1].index;
    tri_indices[2] = vertices[2].index;
  }
  else if (vertices.size() > 3)
  {
    tri_indices.clear();

    size_t n = vertices.size();
    proj_vertices.resize(n);

    Vector3 normal = computeNormal();
    Matrix3 basis = Math::orthonormalBasis(normal);
    Vector3 axis0 = basis.col(0);
    Vector3 axis1 = basis.col(1);

    Vector3 v0 = vertices[0].position;  // a reference point for the plane of the polygon
    for (size_t i = 0; i < n; ++i)
    {
      Vector3 v = vertices[i].position - v0;
      proj_vertices[i] = Vector2(v.dot(axis0), v.dot(axis1));
    }

    Array<size_t> indices(n);
    bool flipped = false;
    if (projArea() > 0)
    {
      for (size_t v = 0; v < n; ++v)
        indices[v] = v;
    }
    else
    {
      for (size_t v = 0; v < n; ++v)
        indices[v] = (n - 1) - v;

      flipped = true;
    }

    size_t nv = n;
    size_t count = 2 * nv;
    for (size_t v = nv - 1; nv > 2; )
    {
      if ((count--) <= 0)
        break;

      size_t u = v;
      if (nv <= u) u = 0;

      v = u + 1;
      if (nv <= v) v = 0;

      size_t w = v + 1;
      if (nv <= w) w = 0;

      if (snip(u, v, w, nv, indices, epsilon))
      {
        size_t a = indices[u];
        size_t b = indices[v];
        size_t c = indices[w];
        if (flipped)
        {
          tri_indices.push_back(vertices[c].index);
          tri_indices.push_back(vertices[b].index);
          tri_indices.push_back(vertices[a].index);
        }
        else
        {
          tri_indices.push_back(vertices[a].index);
          tri_indices.push_back(vertices[b].index);
          tri_indices.push_back(vertices[c].index);
        }

        size_t s = v, t = v + 1;
        for ( ; t < nv; ++s, ++t)
          indices[s] = indices[t];

        nv--;
        count = 2 * nv;
      }
    }
  }

  return (long)tri_indices.size() / 3;
}
Example #20
0
void TxToJSON(const CTransaction& tx, const uint256 hashBlock, Object& entry)
{
    entry.push_back(Pair("txid", tx.GetHash().GetHex()));
    entry.push_back(Pair("version", tx.nVersion));
    entry.push_back(Pair("time", (boost::int64_t)tx.nTime));
    entry.push_back(Pair("locktime", (boost::int64_t)tx.nLockTime));
    Array vin;
    BOOST_FOREACH(const CTxIn& txin, tx.vin)
    {
        Object in;
        if (tx.IsCoinBase())
            in.push_back(Pair("coinbase", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
        else
        {
            in.push_back(Pair("txid", txin.prevout.hash.GetHex()));
			in.push_back(Pair("vout", (boost::int64_t)txin.prevout.n));
			
			CTransaction txoutspent;
			uint256 tempHash = 0;
			if(GetTransaction( txin.prevout.hash, txoutspent, tempHash))
			{
				in.push_back(Pair("value", ValueFromAmount(txoutspent.vout[txin.prevout.n].nValue)));
				CTxDestination inputAddress;
				ExtractDestination(txoutspent.vout[txin.prevout.n].scriptPubKey, inputAddress);
				in.push_back(Pair("addressfrom", CBitcoinAddress(inputAddress).ToString()));
			}
            
            Object o;
            o.push_back(Pair("asm", txin.scriptSig.ToString()));
            o.push_back(Pair("hex", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
            in.push_back(Pair("scriptSig", o));
        }
        in.push_back(Pair("sequence", (boost::int64_t)txin.nSequence));
        vin.push_back(in);
    }
    entry.push_back(Pair("vin", vin));
    Array vout;
    for (unsigned int i = 0; i < tx.vout.size(); i++)
    {
        const CTxOut& txout = tx.vout[i];
        Object out;
        out.push_back(Pair("value", ValueFromAmount(txout.nValue)));
        out.push_back(Pair("n", (boost::int64_t)i));
        Object o;
        ScriptPubKeyToJSON(txout.scriptPubKey, o);
        out.push_back(Pair("scriptPubKey", o));
        vout.push_back(out);
    }
    entry.push_back(Pair("vout", vout));

    if (hashBlock != 0)
    {
        entry.push_back(Pair("blockhash", hashBlock.GetHex()));
        map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
        if (mi != mapBlockIndex.end() && (*mi).second)
        {
            CBlockIndex* pindex = (*mi).second;
            if (pindex->IsInMainChain())
            {
                entry.push_back(Pair("confirmations", 1 + nBestHeight - pindex->nHeight));
                entry.push_back(Pair("time", (boost::int64_t)pindex->nTime));
                entry.push_back(Pair("blocktime", (boost::int64_t)pindex->nTime));
            }
            else
                entry.push_back(Pair("confirmations", 0));
        }
    }
}
Example #21
0
void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Variant &r_ret,Variant::CallError &r_error) {

	r_error.error=Variant::CallError::CALL_OK;
#ifdef DEBUG_ENABLED

#define VALIDATE_ARG_COUNT(m_count) \
	if (p_arg_count<m_count) {\
		r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;\
		r_error.argument=m_count;\
		r_ret=Variant();\
		return;\
	}\
	if (p_arg_count>m_count) {\
		r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;\
		r_error.argument=m_count;\
		r_ret=Variant();\
		return;\
	}

#define VALIDATE_ARG_NUM(m_arg) \
	if (!p_args[m_arg]->is_num()) {\
		r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;\
		r_error.argument=m_arg;\
		r_error.expected=Variant::REAL;\
		r_ret=Variant();\
		return;\
	}

#else

#define VALIDATE_ARG_COUNT(m_count)
#define VALIDATE_ARG_NUM(m_arg)
#endif

	//using a switch, so the compiler generates a jumptable

	switch(p_func) {

		case MATH_SIN: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::sin((double)*p_args[0]);
		} break;
		case MATH_COS: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::cos((double)*p_args[0]);
		} break;
		case MATH_TAN: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::tan((double)*p_args[0]);
		} break;
		case MATH_SINH: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::sinh((double)*p_args[0]);
		} break;
		case MATH_COSH: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::cosh((double)*p_args[0]);
		} break;
		case MATH_TANH: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::tanh((double)*p_args[0]);
		} break;
		case MATH_ASIN: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::asin((double)*p_args[0]);
		} break;
		case MATH_ACOS: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::acos((double)*p_args[0]);
		} break;
		case MATH_ATAN: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::atan((double)*p_args[0]);
		} break;
		case MATH_ATAN2: {
			VALIDATE_ARG_COUNT(2);
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			r_ret=Math::atan2((double)*p_args[0],(double)*p_args[1]);
		} break;
		case MATH_SQRT: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::sqrt((double)*p_args[0]);
		} break;
		case MATH_FMOD: {
			VALIDATE_ARG_COUNT(2);
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			r_ret=Math::fmod((double)*p_args[0],(double)*p_args[1]);
		} break;
		case MATH_FPOSMOD: {
			VALIDATE_ARG_COUNT(2);
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			r_ret=Math::fposmod((double)*p_args[0],(double)*p_args[1]);
		} break;
		case MATH_FLOOR: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::floor((double)*p_args[0]);
		  } break;
		case MATH_CEIL: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::ceil((double)*p_args[0]);
		} break;
		case MATH_ROUND: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::round((double)*p_args[0]);
		} break;
		case MATH_ABS: {
			VALIDATE_ARG_COUNT(1);
			if (p_args[0]->get_type()==Variant::INT) {

				int64_t i = *p_args[0];
				r_ret=ABS(i);
			} else if (p_args[0]->get_type()==Variant::REAL) {

				double r = *p_args[0];
				r_ret=Math::abs(r);
			} else {

				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::REAL;
				r_ret=Variant();
			}
		} break;
		case MATH_SIGN: {
				VALIDATE_ARG_COUNT(1);
				if (p_args[0]->get_type()==Variant::INT) {

					int64_t i = *p_args[0];
					r_ret= i < 0 ? -1 : ( i > 0 ? +1 : 0);
				} else if (p_args[0]->get_type()==Variant::REAL) {

					real_t r = *p_args[0];
					r_ret= r < 0.0 ? -1.0 : ( r > 0.0 ? +1.0 : 0.0);
				} else {

					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
					r_error.argument=0;
					r_error.expected=Variant::REAL;
					r_ret=Variant();
				}
		} break;
		case MATH_POW: {
			VALIDATE_ARG_COUNT(2);
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			r_ret=Math::pow((double)*p_args[0],(double)*p_args[1]);
		} break;
		case MATH_LOG: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::log((double)*p_args[0]);
		} break;
		case MATH_EXP: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::exp((double)*p_args[0]);
		} break;
		case MATH_ISNAN: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::is_nan((double)*p_args[0]);
		} break;
		case MATH_ISINF: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::is_inf((double)*p_args[0]);
		} break;
		case MATH_EASE: {
			VALIDATE_ARG_COUNT(2);
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			r_ret=Math::ease((double)*p_args[0],(double)*p_args[1]);
		} break;
		case MATH_DECIMALS: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::step_decimals((double)*p_args[0]);
		} break;
		case MATH_STEPIFY: {
			VALIDATE_ARG_COUNT(2);
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			r_ret=Math::stepify((double)*p_args[0],(double)*p_args[1]);
		} break;
		case MATH_LERP: {
			VALIDATE_ARG_COUNT(3);
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);
			r_ret=Math::lerp((double)*p_args[0],(double)*p_args[1],(double)*p_args[2]);
		} break;
		case MATH_DECTIME: {
			VALIDATE_ARG_COUNT(3);
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);
			r_ret=Math::dectime((double)*p_args[0],(double)*p_args[1],(double)*p_args[2]);
		} break;
		case MATH_RANDOMIZE: {
			Math::randomize();
			r_ret=Variant();
		} break;
		case MATH_RAND: {
			r_ret=Math::rand();
		} break;
		case MATH_RANDF: {
			r_ret=Math::randf();
		} break;
		case MATH_RANDOM: {
			VALIDATE_ARG_COUNT(2);
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			r_ret=Math::random((double)*p_args[0],(double)*p_args[1]);
		} break;
		case MATH_SEED: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			uint64_t seed=*p_args[0];
			Math::seed(seed);
			r_ret=Variant();
		} break;
		case MATH_RANDSEED: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			uint64_t seed=*p_args[0];
			int ret = Math::rand_from_seed(&seed);
			Array reta;
			reta.push_back(ret);
			reta.push_back(seed);
			r_ret=reta;

		} break;
		case MATH_DEG2RAD: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::deg2rad((double)*p_args[0]);
		} break;
		case MATH_RAD2DEG: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::rad2deg((double)*p_args[0]);
		} break;
		case MATH_LINEAR2DB: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::linear2db((double)*p_args[0]);
		} break;
		case MATH_DB2LINEAR: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			r_ret=Math::db2linear((double)*p_args[0]);
		} break;
		case LOGIC_MAX: {
			VALIDATE_ARG_COUNT(2);
			if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {

				int64_t a = *p_args[0];
				int64_t b = *p_args[1];
				r_ret=MAX(a,b);
			} else {
				VALIDATE_ARG_NUM(0);
				VALIDATE_ARG_NUM(1);

				real_t a = *p_args[0];
				real_t b = *p_args[1];

				r_ret=MAX(a,b);
			}

		} break;
		case LOGIC_MIN: {
			VALIDATE_ARG_COUNT(2);
			if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {

				int64_t a = *p_args[0];
				int64_t b = *p_args[1];
				r_ret=MIN(a,b);
			} else {
				VALIDATE_ARG_NUM(0);
				VALIDATE_ARG_NUM(1);

				real_t a = *p_args[0];
				real_t b = *p_args[1];

				r_ret=MIN(a,b);
			}
		} break;
		case LOGIC_CLAMP: {
			VALIDATE_ARG_COUNT(3);
			if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT && p_args[2]->get_type()==Variant::INT) {

				int64_t a = *p_args[0];
				int64_t b = *p_args[1];
				int64_t c = *p_args[2];
				r_ret=CLAMP(a,b,c);
			} else {
				VALIDATE_ARG_NUM(0);
				VALIDATE_ARG_NUM(1);
				VALIDATE_ARG_NUM(2);

				real_t a = *p_args[0];
				real_t b = *p_args[1];
				real_t c = *p_args[2];

				r_ret=CLAMP(a,b,c);
			}
		} break;
		case LOGIC_NEAREST_PO2: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			int64_t num = *p_args[0];
			r_ret = nearest_power_of_2(num);
		} break;
		case OBJ_WEAKREF: {
			VALIDATE_ARG_COUNT(1);
			if (p_args[0]->get_type()!=Variant::OBJECT) {

				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::OBJECT;
				r_ret=Variant();
				return;

			}

			if (p_args[0]->is_ref()) {

				REF r = *p_args[0];
				if (!r.is_valid()) {
					r_ret=Variant();
					return;
				}

				Ref<WeakRef> wref = memnew( WeakRef );
				wref->set_ref(r);
				r_ret=wref;
			} else {
				Object *obj = *p_args[0];
				if (!obj) {
					r_ret=Variant();
					return;
				}
				Ref<WeakRef> wref = memnew( WeakRef );
				wref->set_obj(obj);
				r_ret=wref;
			}




		} break;
		case FUNC_FUNCREF: {
			VALIDATE_ARG_COUNT(2);
			if (p_args[0]->get_type()!=Variant::OBJECT) {

				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::OBJECT;
				r_ret=Variant();				
				return;

			}
			if (p_args[1]->get_type()!=Variant::STRING && p_args[1]->get_type()!=Variant::NODE_PATH) {

				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=1;
				r_error.expected=Variant::STRING;
				r_ret=Variant();
				return;

			}

			Ref<FuncRef> fr = memnew( FuncRef);

			fr->set_instance(*p_args[0]);
			fr->set_function(*p_args[1]);

			r_ret=fr;

		} break;
		case TYPE_CONVERT: {
			VALIDATE_ARG_COUNT(2);
			VALIDATE_ARG_NUM(1);
			int type=*p_args[1];
			if (type<0 || type>=Variant::VARIANT_MAX) {

				r_ret=RTR("Invalid type argument to convert(), use TYPE_* constants.");
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::INT;
				return;

			} else {


				r_ret=Variant::construct(Variant::Type(type),p_args,1,r_error);
			}
		} break;
		case TYPE_OF: {

			VALIDATE_ARG_COUNT(1);
			r_ret = p_args[0]->get_type();

		} break;
		case TYPE_EXISTS: {

			VALIDATE_ARG_COUNT(1);
			r_ret = ClassDB::class_exists(*p_args[0]);

		} break;
		case TEXT_CHAR: {
			VALIDATE_ARG_COUNT(1);
			VALIDATE_ARG_NUM(0);
			CharType result[2] = {*p_args[0], 0};
			r_ret=String(result);
		} break;
		case TEXT_STR: {

			String str;
			for(int i=0;i<p_arg_count;i++) {

				String os = p_args[i]->operator String();

				if (i==0)
					str=os;
				else
					str+=os;
			}

			r_ret=str;

		} break;
		case TEXT_PRINT: {

			String str;
			for(int i=0;i<p_arg_count;i++) {

				str+=p_args[i]->operator String();
			}

			//str+="\n";
			print_line(str);
			r_ret=Variant();


		} break;
		case TEXT_PRINT_TABBED: {

			String str;
			for(int i=0;i<p_arg_count;i++) {

				if (i)
					str+="\t";
				str+=p_args[i]->operator String();
			}

			//str+="\n";
			print_line(str);
			r_ret=Variant();


		} break;
		case TEXT_PRINT_SPACED: {

			String str;
			for(int i=0;i<p_arg_count;i++) {

				if (i)
					str+=" ";
				str+=p_args[i]->operator String();
			}

			//str+="\n";
			print_line(str);
			r_ret=Variant();


		} break;

		case TEXT_PRINTERR: {

			String str;
			for(int i=0;i<p_arg_count;i++) {

				str+=p_args[i]->operator String();
			}

			//str+="\n";
			OS::get_singleton()->printerr("%s\n",str.utf8().get_data());
			r_ret=Variant();

		} break;
		case TEXT_PRINTRAW: {
			String str;
			for(int i=0;i<p_arg_count;i++) {

				str+=p_args[i]->operator String();
			}

			//str+="\n";
			OS::get_singleton()->print("%s",str.utf8().get_data());
			r_ret=Variant();

		} break;
		case VAR_TO_STR: {
			VALIDATE_ARG_COUNT(1);
			String vars;
			VariantWriter::write_to_string(*p_args[0],vars);
			r_ret=vars;
		} break;
		case STR_TO_VAR: {
			VALIDATE_ARG_COUNT(1);
			if (p_args[0]->get_type()!=Variant::STRING) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::STRING;
				r_ret=Variant();
				return;
			}

			VariantParser::StreamString ss;
			ss.s=*p_args[0];

			String errs;
			int line;
			Error err = VariantParser::parse(&ss,r_ret,errs,line);

			if (err!=OK) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::STRING;
				r_ret="Parse error at line "+itos(line)+": "+errs;
				return;
			}

		} break;
		case VAR_TO_BYTES: {
			VALIDATE_ARG_COUNT(1);

			PoolByteArray barr;
			int len;
			Error err = encode_variant(*p_args[0],NULL,len);
			if (err) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::NIL;
				r_ret="Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
				return;
			}

			barr.resize(len);
			{
				PoolByteArray::Write w = barr.write();
				encode_variant(*p_args[0],w.ptr(),len);

			}
			r_ret=barr;
		} break;
		case BYTES_TO_VAR: {
			VALIDATE_ARG_COUNT(1);
			if (p_args[0]->get_type()!=Variant::POOL_BYTE_ARRAY) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::POOL_BYTE_ARRAY;
				r_ret=Variant();
				return;
			}

			PoolByteArray varr=*p_args[0];
			Variant ret;
			{
				PoolByteArray::Read r=varr.read();
				Error err = decode_variant(ret,r.ptr(),varr.size(),NULL);
				if (err!=OK) {
					r_ret=RTR("Not enough bytes for decoding bytes, or invalid format.");
					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
					r_error.argument=0;
					r_error.expected=Variant::POOL_BYTE_ARRAY;
					return;
				}

			}

			r_ret=ret;

		} break;
		case GEN_RANGE: {

			switch(p_arg_count) {

				case 0: {

					r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
					r_error.argument=1;
					r_ret=Variant();

				} break;
				case 1: {

					VALIDATE_ARG_NUM(0);
					int count=*p_args[0];
					Array arr;
					if (count<=0) {
						r_ret=arr;
						return;
					}
					Error err = arr.resize(count);
					if (err!=OK) {
						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
						r_ret=Variant();
						return;
					}

					for(int i=0;i<count;i++) {
						arr[i]=i;
					}

					r_ret=arr;
				} break;
				case 2: {

					VALIDATE_ARG_NUM(0);
					VALIDATE_ARG_NUM(1);

					int from=*p_args[0];
					int to=*p_args[1];

					Array arr;
					if (from>=to) {
						r_ret=arr;
						return;
					}
					Error err = arr.resize(to-from);
					if (err!=OK) {
						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
						r_ret=Variant();
						return;
					}
					for(int i=from;i<to;i++)
						arr[i-from]=i;
					r_ret=arr;
				} break;
				case 3: {

					VALIDATE_ARG_NUM(0);
					VALIDATE_ARG_NUM(1);
					VALIDATE_ARG_NUM(2);

					int from=*p_args[0];
					int to=*p_args[1];
					int incr=*p_args[2];
					if (incr==0) {

						r_ret=RTR("step argument is zero!");
						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
						return;
					}

					Array arr;
					if (from>=to && incr>0) {
						r_ret=arr;
						return;
					}
					if (from<=to && incr<0) {
						r_ret=arr;
						return;
					}

					//calculate how many
					int count=0;
					if (incr>0) {

						count=((to-from-1)/incr)+1;
					} else {

						count=((from-to-1)/-incr)+1;
					}


					Error err = arr.resize(count);

					if (err!=OK) {
						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
						r_ret=Variant();
						return;
					}

					if (incr>0) {
						int idx=0;
						for(int i=from;i<to;i+=incr) {
							arr[idx++]=i;
						}
					} else {

						int idx=0;
						for(int i=from;i>to;i+=incr) {
							arr[idx++]=i;
						}
					}

					r_ret=arr;
				} break;
				default: {

					r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
					r_error.argument=3;
					r_ret=Variant();

				} break;
			}

		} break;
		case RESOURCE_LOAD: {
			VALIDATE_ARG_COUNT(1);
			if (p_args[0]->get_type()!=Variant::STRING) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::STRING;
				r_ret=Variant();
			} else {
				r_ret=ResourceLoader::load(*p_args[0]);
			}

		} break;
		case INST2DICT: {

			VALIDATE_ARG_COUNT(1);

			if (p_args[0]->get_type()==Variant::NIL) {
				r_ret=Variant();
			} else if (p_args[0]->get_type()!=Variant::OBJECT) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_ret=Variant();
			} else {

				Object *obj = *p_args[0];
				if (!obj) {
					r_ret=Variant();

				} else if (!obj->get_script_instance() || obj->get_script_instance()->get_language()!=GDScriptLanguage::get_singleton()) {

					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
					r_error.argument=0;
					r_error.expected=Variant::DICTIONARY;
					r_ret=RTR("Not a script with an instance");
					return;
				} else {

					GDInstance *ins = static_cast<GDInstance*>(obj->get_script_instance());
					Ref<GDScript> base = ins->get_script();
					if (base.is_null()) {

						r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
						r_error.argument=0;
						r_error.expected=Variant::DICTIONARY;
						r_ret=RTR("Not based on a script");
						return;

					}


					GDScript *p = base.ptr();
					Vector<StringName> sname;

					while(p->_owner) {

						sname.push_back(p->name);
						p=p->_owner;
					}
					sname.invert();


					if (!p->path.is_resource_file()) {
						r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
						r_error.argument=0;
						r_error.expected=Variant::DICTIONARY;
						r_ret=Variant();


						r_ret=RTR("Not based on a resource file");

						return;
					}

					NodePath cp(sname,Vector<StringName>(),false);

					Dictionary d;
					d["@subpath"]=cp;
					d["@path"]=p->path;


					p = base.ptr();

					while(p) {

						for(Set<StringName>::Element *E=p->members.front();E;E=E->next()) {

							Variant value;
							if (ins->get(E->get(),value)) {

								String k = E->get();
								if (!d.has(k)) {
									d[k]=value;
								}
							}
						}

						p=p->_base;
					}

					r_ret=d;

				}
			}

		} break;
		case DICT2INST: {

			VALIDATE_ARG_COUNT(1);

			if (p_args[0]->get_type()!=Variant::DICTIONARY) {

				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::DICTIONARY;
				r_ret=Variant();

				return;
			}

			Dictionary d = *p_args[0];

			if (!d.has("@path")) {

				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::OBJECT;
				r_ret=RTR("Invalid instance dictionary format (missing @path)");

				return;
			}

			Ref<Script> scr = ResourceLoader::load(d["@path"]);
			if (!scr.is_valid()) {

				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::OBJECT;
				r_ret=RTR("Invalid instance dictionary format (can't load script at @path)");
				return;
			}

			Ref<GDScript> gdscr = scr;

			if (!gdscr.is_valid()) {

				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::OBJECT;
				r_ret=Variant();
				r_ret=RTR("Invalid instance dictionary format (invalid script at @path)");
				return;
			}

			NodePath sub;
			if (d.has("@subpath")) {
				sub=d["@subpath"];
			}

			for(int i=0;i<sub.get_name_count();i++) {

				gdscr = gdscr->subclasses[ sub.get_name(i)];
				if (!gdscr.is_valid()) {

					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
					r_error.argument=0;
					r_error.expected=Variant::OBJECT;
					r_ret=Variant();
					r_ret=RTR("Invalid instance dictionary (invalid subclasses)");
					return;
				}
			}

			r_ret = gdscr->_new(NULL,0,r_error);

			GDInstance *ins = static_cast<GDInstance*>(static_cast<Object*>(r_ret)->get_script_instance());
			Ref<GDScript> gd_ref = ins->get_script();

			for(Map<StringName,GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
				if(d.has(E->key())) {
					ins->members[E->get().index] = d[E->key()];
				}
			}

		} break;
		case VALIDATE_JSON: {

			VALIDATE_ARG_COUNT(1);

			if (p_args[0]->get_type()!=Variant::STRING) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::STRING;
				r_ret=Variant();
				return;
			}

			String errs;
			int errl;

			Error err = JSON::parse(*p_args[0],r_ret,errs,errl);

			if (err!=OK) {
				r_ret=itos(errl)+":"+errs;
			} else {
				r_ret="";
			}

		} break;
		case PARSE_JSON: {

			VALIDATE_ARG_COUNT(1);

			if (p_args[0]->get_type()!=Variant::STRING) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::STRING;
				r_ret=Variant();
				return;
			}

			String errs;
			int errl;

			Error err = JSON::parse(*p_args[0],r_ret,errs,errl);

			if (err!=OK) {
				r_ret=Variant();
			}

		} break;
		case TO_JSON: {
			VALIDATE_ARG_COUNT(1);

			r_ret = JSON::print(*p_args[0]);
		} break;
		case HASH: {

			VALIDATE_ARG_COUNT(1);
			r_ret=p_args[0]->hash();

		} break;
		case COLOR8: {

			if (p_arg_count<3) {
				r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
				r_error.argument=3;
				r_ret=Variant();

				return;
			}
			if (p_arg_count>4) {
				r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
				r_error.argument=4;
				r_ret=Variant();

				return;
			}

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);

			Color color((float)*p_args[0]/255.0f,(float)*p_args[1]/255.0f,(float)*p_args[2]/255.0f);

			if (p_arg_count==4) {
				VALIDATE_ARG_NUM(3);
				color.a=(float)*p_args[3]/255.0f;
			}

			r_ret=color;

		} break;
		case COLORN: {

			if (p_arg_count<1) {
				r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
				r_error.argument=1;
				r_ret=Variant();
				return;
			}

			if (p_arg_count>2) {
				r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
				r_error.argument=2;
				r_ret=Variant();
				return;
			}
			
			if (p_args[0]->get_type()!=Variant::STRING) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_ret=Variant();
			} else {
				Color color = Color::named(*p_args[0]);
				if (p_arg_count==2) {
					VALIDATE_ARG_NUM(1);
					color.a=*p_args[1];
				}
				r_ret=color;
			}

		} break;

		case PRINT_STACK: {

			ScriptLanguage* script = GDScriptLanguage::get_singleton();
			for (int i=0; i < script->debug_get_stack_level_count(); i++) {

				print_line("Frame "+itos(i)+" - "+script->debug_get_stack_level_source(i)+":"+itos(script->debug_get_stack_level_line(i))+" in function '"+script->debug_get_stack_level_function(i)+"'");
			};
		} break;

		case INSTANCE_FROM_ID: {

			VALIDATE_ARG_COUNT(1);
			if (p_args[0]->get_type()!=Variant::INT && p_args[0]->get_type()!=Variant::REAL) {
				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument=0;
				r_error.expected=Variant::INT;
				r_ret=Variant();
				break;
			}

			uint32_t id=*p_args[0];
			r_ret=ObjectDB::get_instance(id);

		} break;
		case FUNC_MAX: {

			ERR_FAIL();
		} break;

	}

}
void DenseContainer<MatrixType,LocalScalarType>::
extract (const Teuchos::RCP<const row_matrix_type>& globalMatrix)
{
    using Teuchos::Array;
    using Teuchos::ArrayView;
    using Teuchos::toString;
    typedef local_ordinal_type LO;
    typedef global_ordinal_type GO;
    typedef Tpetra::Map<LO, GO, node_type> map_type;
    const size_t inputMatrixNumRows = globalMatrix->getNodeNumRows ();
    // We only use the rank of the calling process and the number of MPI
    // processes for generating error messages.  Extraction itself is
    // entirely local to each participating MPI process.
    const int myRank = globalMatrix->getRowMap ()->getComm ()->getRank ();
    const int numProcs = globalMatrix->getRowMap ()->getComm ()->getSize ();

    // Sanity check that the local row indices to extract fall within
    // the valid range of local row indices for the input matrix.
    ArrayView<const LO> localRows = this->getLocalRows ();
    for (size_t j = 0; j < numRows_; ++j) {
        TEUCHOS_TEST_FOR_EXCEPTION(
            localRows[j] < 0 ||
            static_cast<size_t> (localRows[j]) >= inputMatrixNumRows,
            std::runtime_error, "Ifpack2::DenseContainer::extract: On process " <<
            myRank << " of " << numProcs << ", localRows[j=" << j << "] = " <<
            localRows[j] << ", which is out of the valid range of local row indices "
            "indices [0, " << (inputMatrixNumRows - 1) << "] for the input matrix.");
    }

    // Convert the local row indices we want into local column indices.
    // For every local row ii_local = localRows[i] we take, we also want
    // to take the corresponding column.  To find the corresponding
    // column, we use the row Map to convert the local row index
    // ii_local into a global index ii_global, and then use the column
    // Map to convert ii_global into a local column index jj_local.  If
    // the input matrix doesn't have a column Map, we need to be using
    // global indices anyway...

    // We use the domain Map to exclude off-process global entries.
    const map_type& globalRowMap = * (globalMatrix->getRowMap ());
    const map_type& globalColMap = * (globalMatrix->getColMap ());
    const map_type& globalDomMap = * (globalMatrix->getDomainMap ());

    bool rowIndsValid = true;
    bool colIndsValid = true;
    Array<LO> localCols (numRows_);
    // For error messages, collect the sets of invalid row indices and
    // invalid column indices.  They are otherwise not useful.
    Array<LO> invalidLocalRowInds;
    Array<GO> invalidGlobalColInds;
    for (size_t i = 0; i < numRows_; ++i) {
        // ii_local is the (local) row index we want to look up.
        const LO ii_local = localRows[i];
        // Find the global index jj_global corresponding to ii_local.
        // Global indices are the same (rather, are required to be the
        // same) in all three Maps, which is why we use jj (suggesting a
        // column index, which is how we will use it below).
        const GO jj_global = globalRowMap.getGlobalElement (ii_local);
        if (jj_global == Teuchos::OrdinalTraits<GO>::invalid ()) {
            // If ii_local is not a local index in the row Map on the
            // calling process, that means localRows is incorrect.  We've
            // already checked for this in the constructor, but we might as
            // well check again here, since it's cheap to do so (just an
            // integer comparison, since we need jj_global anyway).
            rowIndsValid = false;
            invalidLocalRowInds.push_back (ii_local);
            break;
        }
        // Exclude "off-process" entries: that is, those in the column Map
        // on this process that are not in the domain Map on this process.
        if (globalDomMap.isNodeGlobalElement (jj_global)) {
            // jj_global is not an off-process entry.  Look up its local
            // index in the column Map; we want to extract this column index
            // from the input matrix.  If jj_global is _not_ in the column
            // Map on the calling process, that could mean that the column
            // in question is empty on this process.  That would be bad for
            // solving linear systems with the extract submatrix.  We could
            // solve the resulting singular linear systems in a minimum-norm
            // least-squares sense, but for now we simply raise an exception.
            const LO jj_local = globalColMap.getLocalElement (jj_global);
            if (jj_local == Teuchos::OrdinalTraits<local_ordinal_type>::invalid ()) {
                colIndsValid = false;
                invalidGlobalColInds.push_back (jj_global);
                break;
            }
            localCols[i] = jj_local;
        }
    }
    TEUCHOS_TEST_FOR_EXCEPTION(
        ! rowIndsValid, std::logic_error, "Ifpack2::DenseContainer::extract: "
        "On process " << myRank << ", at least one row index in the set of local "
        "row indices given to the constructor is not a valid local row index in "
        "the input matrix's row Map on this process.  This should be impossible "
        "because the constructor checks for this case.  Here is the complete set "
        "of invalid local row indices: " << toString (invalidLocalRowInds) << ".  "
        "Please report this bug to the Ifpack2 developers.");
    TEUCHOS_TEST_FOR_EXCEPTION(
        ! colIndsValid, std::runtime_error, "Ifpack2::DenseContainer::extract: "
        "On process " << myRank << ", "
        "At least one row index in the set of row indices given to the constructor "
        "does not have a corresponding column index in the input matrix's column "
        "Map.  This probably means that the column(s) in question is/are empty on "
        "this process, which would make the submatrix to extract structurally "
        "singular.  Here is the compete set of invalid global column indices: "
        << toString (invalidGlobalColInds) << ".");

    diagBlock_.putScalar (Teuchos::ScalarTraits<local_scalar_type>::zero ());

    const size_t maxNumEntriesInRow = globalMatrix->getNodeMaxNumRowEntries ();
    Array<scalar_type> val (maxNumEntriesInRow);
    Array<local_ordinal_type> ind (maxNumEntriesInRow);

    const local_ordinal_type INVALID =
        Teuchos::OrdinalTraits<local_ordinal_type>::invalid ();
    for (size_t i = 0; i < numRows_; ++i) {
        const local_ordinal_type localRow = localRows[i];
        size_t numEntries;
        globalMatrix->getLocalRowCopy (localRow, ind (), val (), numEntries);

        for (size_t k = 0; k < numEntries; ++k) {
            const local_ordinal_type localCol = ind[k];

            // Skip off-process elements
            //
            // FIXME (mfh 24 Aug 2013) This assumes the following:
            //
            // 1. The column and row Maps begin with the same set of
            //    on-process entries, in the same order.  That is,
            //    on-process row and column indices are the same.
            // 2. All off-process indices in the column Map of the input
            //    matrix occur after that initial set.
            if (localCol >= 0 && static_cast<size_t> (localCol) < inputMatrixNumRows) {
                // for local column IDs, look for each ID in the list
                // of columns hosted by this object
                local_ordinal_type jj = INVALID;
                for (size_t kk = 0; kk < numRows_; ++kk) {
                    if (localRows[kk] == localCol) {
                        jj = kk;
                    }
                }
                if (jj != INVALID) {
                    diagBlock_ (i, jj) += val[k]; // ???
                }
            }
        }
    }
}
Value listitem(const Array& params, bool fHelp)
{
    if (fHelp || (params.size() != 1  && params.size() != 2))
        throw runtime_error(
		"listitem <string::itemname>\n"
        "Returns details of a given item by name.");

    std::string sitem = params[0].get_str();
	
	std::string args = "";
	if (params.size()==2)
	{
		args=params[1].get_str();
	}
	
	if (sitem=="") throw runtime_error("Item invalid.");

    Array results;
	Object e2;
	e2.push_back(Pair("Command",sitem));
	results.push_back(e2);



	if (sitem == "sumofsubsidies")
	{

			Object entry;
			double total = SumOfSubsidiesForRTM();

			entry.push_back(Pair("Subsidies",total));
			results.push_back(entry);

			return results;

	}


	if (sitem == "projects") 
	{

		for(map<string,StructCPID>::iterator ii=mvBoincProjects.begin(); ii!=mvBoincProjects.end(); ++ii) 
		{

			StructCPID structcpid = mvBoincProjects[(*ii).first];

	        if (structcpid.initialized) 
			{ 
				Object entry;
				entry.push_back(Pair("Project",structcpid.projectname));
				entry.push_back(Pair("URL",structcpid.link));
				results.push_back(entry);

			}
		}
		return results;

	}

	if (sitem == "leder")
	{
		
		double subsidy = Lederstrumpf(1000,1000);
		Object entry;
		entry.push_back(Pair("Subsidy",subsidy));
		if (args.length() > 1)
		{
			double myrac=cdbl(args,0);
			subsidy = Lederstrumpf(myrac,1000);
			entry.push_back(Pair("Subsidy",subsidy));//7-19-2014
		}
		results.push_back(entry);

	}




	if (sitem == "network") 
	{
		//4-9-2014

		for(map<string,StructCPID>::iterator ii=mvNetwork.begin(); ii!=mvNetwork.end(); ++ii) 
		{

			StructCPID structcpid = mvNetwork[(*ii).first];

	        if (structcpid.initialized) 
			{ 
				Object entry;
				entry.push_back(Pair("Project",structcpid.projectname));
				entry.push_back(Pair("RAC",structcpid.rac));
				entry.push_back(Pair("Avg RAC",structcpid.AverageRAC));

				entry.push_back(Pair("Entries",structcpid.entries));

				
				if (structcpid.projectname=="NETWORK") 
				{
						entry.push_back(Pair("Network Projects",structcpid.NetworkProjects));

				}
				results.push_back(entry);

			}
		}
		return results;

	}






	if (sitem=="cpids") {
		//Dump vectors:
		
		if (mvCPIDs.size() < 1) 
		{
			HarvestCPIDs(false);
		}
		printf ("generating cpid report %s",sitem.c_str());


		for(map<string,StructCPID>::iterator ii=mvCPIDs.begin(); ii!=mvCPIDs.end(); ++ii) 
		{

			StructCPID structcpid = mvCPIDs[(*ii).first];

	        if (structcpid.initialized) 
			{ 
				Object entry;
	
				entry.push_back(Pair("Project",structcpid.projectname));
				entry.push_back(Pair("CPID",structcpid.cpid));
				entry.push_back(Pair("CPIDhash",structcpid.cpidhash));
				entry.push_back(Pair("Email",structcpid.emailhash));
				entry.push_back(Pair("UTC",structcpid.utc));
				entry.push_back(Pair("RAC",structcpid.rac));
				entry.push_back(Pair("Team",structcpid.team));
				entry.push_back(Pair("RecTime",structcpid.rectime));
				entry.push_back(Pair("Age",structcpid.age));
				entry.push_back(Pair("Verified UTC",structcpid.verifiedutc));
				entry.push_back(Pair("Verified RAC",structcpid.verifiedrac));
				entry.push_back(Pair("Verified Team",structcpid.verifiedteam));
				entry.push_back(Pair("Verified RecTime",structcpid.verifiedrectime));
				entry.push_back(Pair("Verified RAC Age",structcpid.verifiedage));
				entry.push_back(Pair("Is my CPID Valid?",structcpid.Iscpidvalid));
				
				entry.push_back(Pair("CPID Link",structcpid.link));
				entry.push_back(Pair("Errors",structcpid.errors));


				results.push_back(entry);

			}
		}


    }

    return results;


		
}
Example #24
0
INT_PTR CALLBACK NewPerspective(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		LoadRoles(GetDlgItem(hDlg, IDC_ROLE_COMBO));
		return (INT_PTR)TRUE;

	case WM_COMMAND:

		if ( LOWORD(wParam) == IDOK ){
			HWND nameEdit = GetDlgItem(hDlg, IDC_NAME_COMBO);
			HWND combo = GetDlgItem(hDlg, IDC_ROLE_COMBO);

			int len = GetWindowTextLength(nameEdit) + 1;
			LPWSTR nameStr = new WCHAR[len];
			GetWindowText(nameEdit, nameStr, len);

			int roleIndex = ComboBox_GetCurSel(combo);

			string name = ws2s(nameStr);
			string label = name;

			for(unsigned int i=0; i<name.length(); i++){
				if ( name[i] == ' ' ) name[i] = '_';
				name[i] = tolower(name[i]);
			}

			Object role = roles[roleIndex].getObject();
			Object roleDoc = role["doc"].getObject();


			Object newPerspective;
			newPerspective["cinch_type"] = "perspective_definition";
			newPerspective["name"] = name;
			newPerspective["label"] = label;
			Array appliesTo = Array();
			appliesTo.push_back(roleDoc["name"]);
			newPerspective["applies_to_roles"] = appliesTo;

			Document doc = db.createDocument(JsonBox::Value(newPerspective));
			Object updatedObj = doc.getData().getObject();
			PROPVARIANT val;
			HRESULT res = g_pFramework->GetUICommandProperty(IDR_CMD_SWITCHPERSPECTIVE, UI_PKEY_ItemsSource, &val);
			if ( res == S_OK ){
				IUICollection* pCollection;
				res = val.punkVal->QueryInterface(IID_PPV_ARGS(&pCollection));
			
				perspectiveHandler->AddPerspective(pCollection, updatedObj);
				 
				pCollection->Release();
				val.punkVal->Release();
			}
			delete nameStr;
			

		}

		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}
Value execute(const Array& params, bool fHelp)
{
    if (fHelp || params.size() != 1)
        throw runtime_error(
		"execute <string::itemname>\n"
        "Executes an arbitrary command by name.");

    std::string sItem = params[0].get_str();

	if (sItem=="") throw runtime_error("Item invalid.");

    Array results;
	Object oOut;
	oOut.push_back(Pair("Command",sItem));
	results.push_back(oOut);
    Object entry;
		
	if (sItem == "restorepoint")
	{
			int r=-1;
			#if defined(WIN32) && defined(QT_GUI)
			//We must stop the node before we can do this
			r = CreateRestorePoint();
			RestartGridcoin3();

			#endif 
			entry.push_back(Pair("Restore Point",r));
			results.push_back(entry);
	}
	else if (sItem == "downloadblocks")
	{
			int r=-1;
			#if defined(WIN32) && defined(QT_GUI)
				r = DownloadBlocks();
			#endif 
			entry.push_back(Pair("Download Blocks",r));
			results.push_back(entry);
	}
	else if (sItem == "tally")
	{
			TallyNetworkAverages();
			entry.push_back(Pair("Tally Network Averages",1));
			results.push_back(entry);
	}
	else if (sItem == "resetcpids")
	{
			mvCPIDCache.clear();
    	    HarvestCPIDs(true);
		    entry.push_back(Pair("Reset",1));
			results.push_back(entry);
	}
	else if (sItem == "backupwallet")
	{
			std::string result = BackupGridcoinWallet();
		    entry.push_back(Pair("Backup Wallet Result", result));
		    results.push_back(entry);
	}
	else if (sItem == "restorewallet")
	{
			std::string result = RestoreGridcoinBackupWallet();
			entry.push_back(Pair("Restore Wallet Result", result));
			results.push_back(entry);
	}
	else if (sItem == "resendwallettx")
	{
			ResendWalletTransactions2();
			entry.push_back(Pair("Resending unsent wallet transactions...",1));
			results.push_back(entry);
	} 
	else if (sItem == "postcpid")
	{
			std::string result = GetHttpPage("859038ff4a9",true);
			entry.push_back(Pair("POST Result",result));
	        results.push_back(entry);
	}
	else if (sItem == "encrypt")
	{
			std::string s1 = "1234";
			std::string s1dec = AdvancedCrypt(s1);
			std::string s1out = AdvancedDecrypt(s1dec);
		    entry.push_back(Pair("Execute Encrypt result1",s1));
		    entry.push_back(Pair("Execute Encrypt result2",s1dec));
			entry.push_back(Pair("Execute Encrypt result3",s1out));
			results.push_back(entry);
	}
	else if (sItem == "restartnet")
	{
			printf("Restarting gridcoin's network layer;");
			RestartGridcoin3();
			entry.push_back(Pair("Execute","Restarted Gridcoins network layer."));
	   		results.push_back(entry);
	}
	else if (sItem == "findrac")
	{
			int position = 0;
			std::string out_errors = "";
	    	std::string TargetCPID = "123";
			std::string TargetProjectName="Docking";
			bool result = FindRAC(false,TargetCPID, TargetProjectName, 1, false,out_errors, position);
			entry.push_back(Pair("TargetCPID",TargetCPID));
			entry.push_back(Pair("Errors",out_errors));
		   	results.push_back(entry);
	}
	else if (sItem=="genminingkey")
	{
		 //7-3-2014
		 std::string grc = DefaultWalletAddress();
		 GetNextGPUProject(true);
		 bool IsCpidValid = IsCPIDValid(msGPUMiningCPID, msGPUENCboincpublickey);
		 if (!IsCpidValid)
		 {
			entry.push_back(Pair("Errors","Failed to retrieve boinc CPID"));

		 }
		 std::string bpk = AdvancedDecrypt(msGPUENCboincpublickey);
		 std::string bpmd5 = RetrieveMd5(bpk);
		 std::string concatminingkey = grc + ";" + bpk;
    	 //entry.push_back(Pair("BPK",bpk));
		 //entry.push_back(Pair("md5",bpmd5));
		 //entry.push_back(Pair("concat",concatminingkey));
	 	 std::string miningkey = EncodeBase64(concatminingkey);
		 entry.push_back(Pair("miningkey",miningkey));
         results.push_back(entry);
	
	}
	else
	{
			entry.push_back(Pair("Command " + sItem + " not found.",-1));
			results.push_back(entry);
	}
	return results;    
		
}
Example #26
0
File: Fixed.hpp Project: jxv/Fixed
 void push_back(A a) {
     arr.push_back(a);
 }
Example #27
0
static void test_pod() {
    Array<unsigned> array;

    const size_t initial_capacity = 20, grow_capacity = 12, alignment = 4;
    UAllocTraits_t traits = {0};
    MBED_HOSTTEST_ASSERT(array.init(initial_capacity, grow_capacity, traits, alignment));

    // Start filling the array
    for (unsigned i = 0; i < initial_capacity; i ++ ) {
        array.push_back(i);
    }
    MBED_HOSTTEST_ASSERT(array.get_num_elements() == initial_capacity);
    for (unsigned i = 0; i < initial_capacity; i ++) {
        MBED_HOSTTEST_ASSERT(array[i] == i);
    }
    MBED_HOSTTEST_ASSERT(array.get_num_zones() == 1);

    // Add another element, this should trigger the creation of another zone
    array.push_back(1000);
    MBED_HOSTTEST_ASSERT(array.get_num_zones() == 2);
    MBED_HOSTTEST_ASSERT(array.get_num_elements() == initial_capacity + 1);
    // Fill the second zone too
    for (unsigned i = 1; i < grow_capacity; i ++) {
        array.push_back(1000 + i);
    }
    MBED_HOSTTEST_ASSERT(array.get_num_elements() == initial_capacity + grow_capacity);
    for (unsigned i = 0; i < grow_capacity; i ++) {
        MBED_HOSTTEST_ASSERT(array.at(i + initial_capacity) == 1000 + i);
    }
    MBED_HOSTTEST_ASSERT(array.get_num_zones() == 2);
    unsigned save_for_later = array[initial_capacity + grow_capacity - 1];
    // Add yet another element, which should result in the creation of another zone
    array.push_back(10000);
    MBED_HOSTTEST_ASSERT(array[initial_capacity + grow_capacity] == 10000);
    MBED_HOSTTEST_ASSERT(array.get_num_zones() == 3);
    MBED_HOSTTEST_ASSERT(array.get_num_elements() == initial_capacity + grow_capacity + 1);

    // Remove the last element
    array.pop_back();
    MBED_HOSTTEST_ASSERT(array.get_num_elements() == initial_capacity + grow_capacity);
    MBED_HOSTTEST_ASSERT(array[array.get_num_elements() - 1] == save_for_later);
    MBED_HOSTTEST_ASSERT(array.get_num_zones() == 3); // the array doesn't (yet?) shrink

    // Simple bubble sort test illustrating moving around elements in the array
    const size_t total = initial_capacity + grow_capacity;
    for (unsigned i = 0; i < total; i ++) {
        array.at(i) = total - i - 1;
    }

    for (unsigned i = 0; i < total - 1; i ++) {
        for (unsigned j = i + 1; j < total; j ++) {
            if (array[i] > array[j]) {
                unsigned temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
    }
    for (unsigned i = 0; i < total; i ++) {
        MBED_HOSTTEST_ASSERT(array[i] == i);
    }

    MBED_HOSTTEST_ASSERT(array.get_num_zones() == 3);
}
void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant *r_return, Variant::CallError &r_error, String &r_error_str) {

	switch (p_func) {
		case VisualScriptBuiltinFunc::MATH_SIN: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::sin((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_COS: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::cos((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_TAN: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::tan((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_SINH: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::sinh((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_COSH: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::cosh((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_TANH: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::tanh((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_ASIN: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::asin((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_ACOS: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::acos((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_ATAN: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::atan((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_ATAN2: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			*r_return = Math::atan2((double)*p_inputs[0], (double)*p_inputs[1]);
		} break;
		case VisualScriptBuiltinFunc::MATH_SQRT: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::sqrt((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_FMOD: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			*r_return = Math::fmod((double)*p_inputs[0], (double)*p_inputs[1]);
		} break;
		case VisualScriptBuiltinFunc::MATH_FPOSMOD: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			*r_return = Math::fposmod((double)*p_inputs[0], (double)*p_inputs[1]);
		} break;
		case VisualScriptBuiltinFunc::MATH_FLOOR: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::floor((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_CEIL: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::ceil((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_ROUND: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::round((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_ABS: {

			if (p_inputs[0]->get_type() == Variant::INT) {

				int64_t i = *p_inputs[0];
				*r_return = ABS(i);
			} else if (p_inputs[0]->get_type() == Variant::REAL) {

				real_t r = *p_inputs[0];
				*r_return = Math::abs(r);
			} else {

				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 0;
				r_error.expected = Variant::REAL;
			}
		} break;
		case VisualScriptBuiltinFunc::MATH_SIGN: {

			if (p_inputs[0]->get_type() == Variant::INT) {

				int64_t i = *p_inputs[0];
				*r_return = i < 0 ? -1 : (i > 0 ? +1 : 0);
			} else if (p_inputs[0]->get_type() == Variant::REAL) {

				real_t r = *p_inputs[0];
				*r_return = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
			} else {

				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 0;
				r_error.expected = Variant::REAL;
			}
		} break;
		case VisualScriptBuiltinFunc::MATH_POW: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			*r_return = Math::pow((double)*p_inputs[0], (double)*p_inputs[1]);
		} break;
		case VisualScriptBuiltinFunc::MATH_LOG: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::log((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_EXP: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::exp((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_ISNAN: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::is_nan((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_ISINF: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::is_inf((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_EASE: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			*r_return = Math::ease((double)*p_inputs[0], (double)*p_inputs[1]);
		} break;
		case VisualScriptBuiltinFunc::MATH_DECIMALS: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::step_decimals((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_STEPIFY: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			*r_return = Math::stepify((double)*p_inputs[0], (double)*p_inputs[1]);
		} break;
		case VisualScriptBuiltinFunc::MATH_LERP: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);
			*r_return = Math::lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
		} break;
		case VisualScriptBuiltinFunc::MATH_INVERSE_LERP: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);
			*r_return = Math::inverse_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
		} break;
		case VisualScriptBuiltinFunc::MATH_RANGE_LERP: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);
			VALIDATE_ARG_NUM(3);
			VALIDATE_ARG_NUM(4);
			*r_return = Math::range_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2], (double)*p_inputs[3], (double)*p_inputs[4]);
		} break;
		case VisualScriptBuiltinFunc::MATH_SMOOTHSTEP: {
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);
			*r_return = Math::smoothstep((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
		} break;
		case VisualScriptBuiltinFunc::MATH_DECTIME: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);
			*r_return = Math::dectime((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
		} break;
		case VisualScriptBuiltinFunc::MATH_RANDOMIZE: {
			Math::randomize();

		} break;
		case VisualScriptBuiltinFunc::MATH_RAND: {
			*r_return = Math::rand();
		} break;
		case VisualScriptBuiltinFunc::MATH_RANDF: {
			*r_return = Math::randf();
		} break;
		case VisualScriptBuiltinFunc::MATH_RANDOM: {

			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			*r_return = Math::random((double)*p_inputs[0], (double)*p_inputs[1]);
		} break;
		case VisualScriptBuiltinFunc::MATH_SEED: {

			VALIDATE_ARG_NUM(0);
			uint64_t seed = *p_inputs[0];
			Math::seed(seed);

		} break;
		case VisualScriptBuiltinFunc::MATH_RANDSEED: {

			VALIDATE_ARG_NUM(0);
			uint64_t seed = *p_inputs[0];
			int ret = Math::rand_from_seed(&seed);
			Array reta;
			reta.push_back(ret);
			reta.push_back(seed);
			*r_return = reta;

		} break;
		case VisualScriptBuiltinFunc::MATH_DEG2RAD: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::deg2rad((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_RAD2DEG: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::rad2deg((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_LINEAR2DB: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::linear2db((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_DB2LINEAR: {

			VALIDATE_ARG_NUM(0);
			*r_return = Math::db2linear((double)*p_inputs[0]);
		} break;
		case VisualScriptBuiltinFunc::MATH_POLAR2CARTESIAN: {
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			double r = *p_inputs[0];
			double th = *p_inputs[1];
			*r_return = Vector2(r * Math::cos(th), r * Math::sin(th));
		} break;
		case VisualScriptBuiltinFunc::MATH_CARTESIAN2POLAR: {
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			double x = *p_inputs[0];
			double y = *p_inputs[1];
			*r_return = Vector2(Math::sqrt(x * x + y * y), Math::atan2(y, x));
		} break;
		case VisualScriptBuiltinFunc::MATH_WRAP: {
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);
			*r_return = Math::wrapi((int64_t)*p_inputs[0], (int64_t)*p_inputs[1], (int64_t)*p_inputs[2]);
		} break;
		case VisualScriptBuiltinFunc::MATH_WRAPF: {
			VALIDATE_ARG_NUM(0);
			VALIDATE_ARG_NUM(1);
			VALIDATE_ARG_NUM(2);
			*r_return = Math::wrapf((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
		} break;
		case VisualScriptBuiltinFunc::LOGIC_MAX: {

			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {

				int64_t a = *p_inputs[0];
				int64_t b = *p_inputs[1];
				*r_return = MAX(a, b);
			} else {
				VALIDATE_ARG_NUM(0);
				VALIDATE_ARG_NUM(1);

				real_t a = *p_inputs[0];
				real_t b = *p_inputs[1];

				*r_return = MAX(a, b);
			}

		} break;
		case VisualScriptBuiltinFunc::LOGIC_MIN: {

			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {

				int64_t a = *p_inputs[0];
				int64_t b = *p_inputs[1];
				*r_return = MIN(a, b);
			} else {
				VALIDATE_ARG_NUM(0);
				VALIDATE_ARG_NUM(1);

				real_t a = *p_inputs[0];
				real_t b = *p_inputs[1];

				*r_return = MIN(a, b);
			}
		} break;
		case VisualScriptBuiltinFunc::LOGIC_CLAMP: {

			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT && p_inputs[2]->get_type() == Variant::INT) {

				int64_t a = *p_inputs[0];
				int64_t b = *p_inputs[1];
				int64_t c = *p_inputs[2];
				*r_return = CLAMP(a, b, c);
			} else {
				VALIDATE_ARG_NUM(0);
				VALIDATE_ARG_NUM(1);
				VALIDATE_ARG_NUM(2);

				real_t a = *p_inputs[0];
				real_t b = *p_inputs[1];
				real_t c = *p_inputs[2];

				*r_return = CLAMP(a, b, c);
			}
		} break;
		case VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2: {

			VALIDATE_ARG_NUM(0);
			int64_t num = *p_inputs[0];
			*r_return = next_power_of_2(num);
		} break;
		case VisualScriptBuiltinFunc::OBJ_WEAKREF: {

			if (p_inputs[0]->get_type() != Variant::OBJECT) {

				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 0;
				r_error.expected = Variant::OBJECT;

				return;
			}

			if (p_inputs[0]->is_ref()) {

				REF r = *p_inputs[0];
				if (!r.is_valid()) {

					return;
				}

				Ref<WeakRef> wref = memnew(WeakRef);
				wref->set_ref(r);
				*r_return = wref;
			} else {
				Object *obj = *p_inputs[0];
				if (!obj) {

					return;
				}
				Ref<WeakRef> wref = memnew(WeakRef);
				wref->set_obj(obj);
				*r_return = wref;
			}

		} break;
		case VisualScriptBuiltinFunc::FUNC_FUNCREF: {

			if (p_inputs[0]->get_type() != Variant::OBJECT) {

				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 0;
				r_error.expected = Variant::OBJECT;

				return;
			}
			if (p_inputs[1]->get_type() != Variant::STRING && p_inputs[1]->get_type() != Variant::NODE_PATH) {

				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 1;
				r_error.expected = Variant::STRING;

				return;
			}

			Ref<FuncRef> fr = memnew(FuncRef);

			fr->set_instance(*p_inputs[0]);
			fr->set_function(*p_inputs[1]);

			*r_return = fr;

		} break;
		case VisualScriptBuiltinFunc::TYPE_CONVERT: {

			VALIDATE_ARG_NUM(1);
			int type = *p_inputs[1];
			if (type < 0 || type >= Variant::VARIANT_MAX) {

				r_error_str = RTR("Invalid type argument to convert(), use TYPE_* constants.");
				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 0;
				r_error.expected = Variant::INT;
				return;

			} else {

				*r_return = Variant::construct(Variant::Type(type), p_inputs, 1, r_error);
			}
		} break;
		case VisualScriptBuiltinFunc::TYPE_OF: {

			*r_return = p_inputs[0]->get_type();

		} break;
		case VisualScriptBuiltinFunc::TYPE_EXISTS: {

			*r_return = ClassDB::class_exists(*p_inputs[0]);

		} break;
		case VisualScriptBuiltinFunc::TEXT_CHAR: {

			CharType result[2] = { *p_inputs[0], 0 };

			*r_return = String(result);

		} break;
		case VisualScriptBuiltinFunc::TEXT_STR: {

			String str = *p_inputs[0];

			*r_return = str;

		} break;
		case VisualScriptBuiltinFunc::TEXT_PRINT: {

			String str = *p_inputs[0];
			print_line(str);

		} break;

		case VisualScriptBuiltinFunc::TEXT_PRINTERR: {

			String str = *p_inputs[0];
			print_error(str);

		} break;
		case VisualScriptBuiltinFunc::TEXT_PRINTRAW: {

			String str = *p_inputs[0];
			OS::get_singleton()->print("%s", str.utf8().get_data());

		} break;
		case VisualScriptBuiltinFunc::VAR_TO_STR: {

			String vars;
			VariantWriter::write_to_string(*p_inputs[0], vars);
			*r_return = vars;
		} break;
		case VisualScriptBuiltinFunc::STR_TO_VAR: {

			if (p_inputs[0]->get_type() != Variant::STRING) {
				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 0;
				r_error.expected = Variant::STRING;

				return;
			}

			VariantParser::StreamString ss;
			ss.s = *p_inputs[0];

			String errs;
			int line;
			Error err = VariantParser::parse(&ss, *r_return, errs, line);

			if (err != OK) {
				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 0;
				r_error.expected = Variant::STRING;
				*r_return = "Parse error at line " + itos(line) + ": " + errs;
				return;
			}

		} break;
		case VisualScriptBuiltinFunc::VAR_TO_BYTES: {

			if (p_inputs[1]->get_type() != Variant::BOOL) {
				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 1;
				r_error.expected = Variant::BOOL;
				return;
			}
			PoolByteArray barr;
			int len;
			bool full_objects = *p_inputs[1];
			Error err = encode_variant(*p_inputs[0], NULL, len, full_objects);
			if (err) {
				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 0;
				r_error.expected = Variant::NIL;
				r_error_str = "Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
				return;
			}

			barr.resize(len);
			{
				PoolByteArray::Write w = barr.write();
				encode_variant(*p_inputs[0], w.ptr(), len, full_objects);
			}
			*r_return = barr;
		} break;
		case VisualScriptBuiltinFunc::BYTES_TO_VAR: {

			if (p_inputs[0]->get_type() != Variant::POOL_BYTE_ARRAY) {
				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 0;
				r_error.expected = Variant::POOL_BYTE_ARRAY;
				return;
			}
			if (p_inputs[1]->get_type() != Variant::BOOL) {
				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
				r_error.argument = 1;
				r_error.expected = Variant::BOOL;
				return;
			}

			PoolByteArray varr = *p_inputs[0];
			bool allow_objects = *p_inputs[1];
			Variant ret;
			{
				PoolByteArray::Read r = varr.read();
				Error err = decode_variant(ret, r.ptr(), varr.size(), NULL, allow_objects);
				if (err != OK) {
					r_error_str = RTR("Not enough bytes for decoding bytes, or invalid format.");
					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
					r_error.argument = 0;
					r_error.expected = Variant::POOL_BYTE_ARRAY;
					return;
				}
			}

			*r_return = ret;

		} break;
		case VisualScriptBuiltinFunc::COLORN: {

			VALIDATE_ARG_NUM(1);

			Color color = Color::named(*p_inputs[0]);
			color.a = *p_inputs[1];

			*r_return = String(color);

		} break;
		default: {
		}
	}
}
Example #29
0
void threadFile(int start,int finish,char * buffer,mutex &mut,Array<snp> &snp_arr,int &tnum,int locnum)
{
    vector<string> chroms;
    Array<snp> snp_arr_temp;
    int position = start;
    int iter = 0;
    while(position<=finish)
    {
        iter++;
        char temp [10000];
        if(buffer[position]=='c')
        {
            snp SNP;
            SNP.file_pos = position;
            position += gets_term(temp,'\t',&buffer[position]);
            SNP.chr=(string)temp;
            int chr_pos = find_string(chroms,SNP.chr);
            if(chr_pos<0)
            {
                chroms.push_back(SNP.chr);
                snp_arr_temp.resize(snp_arr_temp.size()+1);
                chr_pos=snp_arr_temp.size()-1;
            }
            position += gets_term(temp,'\t',&buffer[position]);
            SNP.pos = atoi(temp);
            position += gets_term(temp,'\t',&buffer[position]);
            position += gets_term(temp,'\t',&buffer[position]);
            position += gets_term(temp,'\t',&buffer[position]);
            SNP.alt=temp[0];
            position += gets_term(temp,'\n',&buffer[position]);
            snp_arr_temp[chr_pos].push_back(SNP);
        }
        else
        {
            position += gets_term(temp,'\n',&buffer[position]);
        }
    }
    bool terminate = false;
    while(!terminate)
    {
        mut.lock();
        if((tnum+1)==locnum)
        {
            for(uint i=0;i<snp_arr_temp.size();i++)
            {
                int found = -1;
                for(uint j=0;j<snp_arr.size();j++)
                {
                    if(snp_arr_temp[i][0].chr==snp_arr[j][0].chr) {found = j; break;}
                }
                if(found<0)
                {
                    snp_arr.push_back(snp_arr_temp[i]);
                }
                else
                {
                    snp_arr[found].insert(snp_arr[found].end(),snp_arr_temp[i].begin(),snp_arr_temp[i].end());
                }
            }
            tnum++;
            mut.unlock();
            terminate = true;
        }
        else mut.unlock();
    }
}
Example #30
0
Value getaddednodeinfo(const Array& params, bool fHelp)
{
    if (fHelp || params.size() < 1 || params.size() > 2)
        throw runtime_error(
            "getaddednodeinfo dns ( \"node\" )\n"
            "\nReturns information about the given added node, or all added nodes\n"
            "(note that onetry addnodes are not listed here)\n"
            "If dns is false, only a list of added nodes will be provided,\n"
            "otherwise connected information will also be available.\n"
            "\nArguments:\n"
            "1. dns        (boolean, required) If false, only a list of added nodes will be provided, otherwise connected information will also be available.\n"
            "2. \"node\"   (string, optional) If provided, return information about this specific node, otherwise all nodes are returned.\n"
            "\nResult:\n"
            "[\n"
            "  {\n"
            "    \"addednode\" : \"192.168.0.201\",   (string) The node ip address\n"
            "    \"connected\" : true|false,          (boolean) If connected\n"
            "    \"addresses\" : [\n"
            "       {\n"
            "         \"address\" : \"192.168.0.201:8333\",  (string) The Dacrs server host and port\n"
            "         \"connected\" : \"outbound\"           (string) connection, inbound or outbound\n"
            "       }\n"
            "       ,...\n"
            "     ]\n"
            "  }\n"
            "  ,...\n"
            "]\n"
            "\nExamples:\n"
            + HelpExampleCli("getaddednodeinfo", "true")
            + HelpExampleCli("getaddednodeinfo", "true \"192.168.0.201\"")
            + HelpExampleRpc("getaddednodeinfo", "true, \"192.168.0.201\"")
        );

    bool fDns = params[0].get_bool();

    list<string> laddedNodes(0);
    if (params.size() == 1)
    {
        LOCK(cs_vAddedNodes);
        for (auto& strAddNode : vAddedNodes)
            laddedNodes.push_back(strAddNode);
    }
    else
    {
        string strNode = params[1].get_str();
        LOCK(cs_vAddedNodes);
        for (auto & strAddNode : vAddedNodes)
            if (strAddNode == strNode)
            {
                laddedNodes.push_back(strAddNode);
                break;
            }
        if (laddedNodes.size() == 0)
            throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added.");
    }

    Array ret;
    if (!fDns)
    {
        for (auto & strAddNode : laddedNodes)
        {
            Object obj;
            obj.push_back(Pair("addednode", strAddNode));
            ret.push_back(obj);
        }
        return ret;
    }

    list<pair<string, vector<CService> > > laddedAddreses(0);
    for (auto& strAddNode : laddedNodes)
    {
        vector<CService> vservNode(0);
        if(Lookup(strAddNode.c_str(), vservNode, SysCfg().GetDefaultPort(), fNameLookup, 0))
            laddedAddreses.push_back(make_pair(strAddNode, vservNode));
        else
        {
            Object obj;
            obj.push_back(Pair("addednode", strAddNode));
            obj.push_back(Pair("connected", false));
            Array addresses;
            obj.push_back(Pair("addresses", addresses));
        }
    }

    LOCK(cs_vNodes);
    for (list<pair<string, vector<CService> > >::iterator it = laddedAddreses.begin(); it != laddedAddreses.end(); it++)
    {
        Object obj;
        obj.push_back(Pair("addednode", it->first));

        Array addresses;
        bool fConnected = false;
        for (auto& addrNode : it->second)
        {
            bool fFound = false;
            Object node;
            node.push_back(Pair("address", addrNode.ToString()));
            for (auto pnode : vNodes)
                if (pnode->addr == addrNode)
                {
                    fFound = true;
                    fConnected = true;
                    node.push_back(Pair("connected", pnode->fInbound ? "inbound" : "outbound"));
                    break;
                }
            if (!fFound)
                node.push_back(Pair("connected", "false"));
            addresses.push_back(node);
        }
        obj.push_back(Pair("connected", fConnected));
        obj.push_back(Pair("addresses", addresses));
        ret.push_back(obj);
    }

    return ret;
}