C++ CFunctionsScopePtr::newScriptVar方法代码示例

static void scStringSplit(const CFunctionsScopePtr &c, void *) {
	string str = c->getArgument("this")->getString();
	CScriptVarPtr sep_var = c->getArgument("separator");
	CScriptVarPtr limit_var = c->getArgument("limit");
	int limit = limit_var->isUndefined() ? 0x7fffffff : limit_var->getInt();

	CScriptVarPtr result(newScriptVar(c->getContext(), Array));
	c->setReturnVar(result);
	if(limit == 0 || !str.size())
		return;
	else if(sep_var->isUndefined()) {
		result->setArrayIndex(0, c->newScriptVar(str));
		return;
	}
	string sep = sep_var->getString();
	if(sep.size() == 0) {
		for(int i=0; i<min((int)sep.size(), limit); ++i)
			result->setArrayIndex(i, c->newScriptVar(str.substr(i,1)));
		return;
	}
	int length = 0;
	string::size_type pos = 0, last_pos=0;
	do {
		pos = str.find(sep, last_pos);
		result->setArrayIndex(length++, c->newScriptVar(str.substr(last_pos ,pos-last_pos)));
		if(length == limit || pos == string::npos) break;
		last_pos = pos+sep.size();
	} while (last_pos < str.size());
}

static void scStringCharAt(const CFunctionsScopePtr &c, void *) {
	string str = this2string(c);
	int p = c->getArgument("pos")->toNumber().toInt32();
	if (p>=0 && p<(int)str.length())
		c->setReturnVar(c->newScriptVar(str.substr(p, 1)));
	else
		c->setReturnVar(c->newScriptVar(""));
}

static void scStringCharCodeAt(const CFunctionsScopePtr &c, void *) {
	string str = c->getArgument("this")->getString();
	int p = c->getArgument("pos")->getInt();
	if (p>=0 && p<(int)str.length())
		c->setReturnVar(c->newScriptVar(str.at(p)));
	else
		c->setReturnVar(c->newScriptVar(0));
}

static void scStringReplace(const CFunctionsScopePtr &c, void *) {
	const string str = this2string(c);
	CScriptVarPtr newsubstrVar = c->getArgument("newsubstr");
	string substr, ret_str;
	bool global, ignoreCase, sticky;
	bool isRegExp = getRegExpData(c, "substr", false, "flags", substr, global, ignoreCase, sticky);
	if(isRegExp && !newsubstrVar->isFunction()) {
#ifndef NO_REGEXP
		regex::flag_type flags = regex_constants::ECMAScript;
		if(ignoreCase) flags |= regex_constants::icase;
		regex_constants::match_flag_type mflags = regex_constants::match_default;
		if(!global) mflags |= regex_constants::format_first_only;
		if(sticky) mflags |= regex_constants::match_continuous;
		ret_str = regex_replace(str, regex(substr, flags), newsubstrVar->toString(), mflags);
#endif /* NO_REGEXP */
	} else {
		bool (*search)(const string &, const string::const_iterator &, const string &, bool, bool, string::const_iterator &, string::const_iterator &);
#ifndef NO_REGEXP
		if(isRegExp) 
			search = regex_search;
		else
#endif /* NO_REGEXP */
			search = string_search;
		string newsubstr;
		vector<CScriptVarPtr> arguments;
		if(!newsubstrVar->isFunction()) 
			newsubstr = newsubstrVar->toString();
		global = global && substr.length();
		string::const_iterator search_begin=str.begin(), match_begin, match_end;
		if(search(str, search_begin, substr, ignoreCase, sticky, match_begin, match_end)) {
			do {
				ret_str.append(search_begin, match_begin);
				if(newsubstrVar->isFunction()) {
					arguments.push_back(c->newScriptVar(string(match_begin, match_end)));
					newsubstr = c->getContext()->callFunction(newsubstrVar, arguments)->toString();
					arguments.pop_back();
				}
				ret_str.append(newsubstr);
#if 1 /* Fix from "vcmpeq" (see Issue 14) currently untested */
				if (match_begin == match_end) {
					if (search_begin != str.end())
						++search_begin;
					else
						break;
				} else {
					search_begin = match_end;
				}
#else
				search_begin = match_end;
#endif
			} while(global && search(str, search_begin, substr, ignoreCase, sticky, match_begin, match_end));
		}
		ret_str.append(search_begin, str.end());
	}
	c->setReturnVar(c->newScriptVar(ret_str));
}

static void scStringSubstr(const CFunctionsScopePtr &c, void *userdata) {
	string str = this2string(c);
	int32_t length = c->getArgumentsLength()-ptr2int32(userdata);
	int32_t start = c->getArgument("start")->toNumber().toInt32();
	if(start<0 || start>=(int)str.size()) 
		c->setReturnVar(c->newScriptVar(""));
	else if(length>1) {
		int length = c->getArgument("length")->toNumber().toInt32();
		c->setReturnVar(c->newScriptVar(str.substr(start, length)));
	} else
		c->setReturnVar(c->newScriptVar(str.substr(start)));
}

static void scStringSubstr(const CFunctionsScopePtr &c, void *userdata) {
	string str = c->getArgument("this")->getString();
	int length = c->getArgumentsLength()-(int)userdata;
	int start = c->getArgument("start")->getInt();
	if(start<0 || start>=(int)str.size()) 
		c->setReturnVar(c->newScriptVar(""));
	else if(length>1) {
		int length = c->getArgument("length")->getInt();
		c->setReturnVar(c->newScriptVar(str.substr(start, length)));
	} else
		c->setReturnVar(c->newScriptVar(str.substr(start)));
}

static void scStringMatch(const CFunctionsScopePtr &c, void *) {
	string str = this2string(c);

	string flags="flags", substr, newsubstr, match;
	bool global, ignoreCase, sticky;
	CScriptVarRegExpPtr RegExp = getRegExpData(c, "regexp", true, "flags", substr, global, ignoreCase, sticky);
	if(!global) {
		if(!RegExp)
			RegExp = ::newScriptVar(c->getContext(), substr, flags);
		if(RegExp) {
			try {
				c->setReturnVar(RegExp->exec(str));
			} catch(regex_error e) {
				c->throwError(SyntaxError, string(e.what())+" - "+CScriptVarRegExp::ErrorStr(e.code()));
			}
		}
	} else {
		try { 
			CScriptVarArrayPtr retVar = c->newScriptVar(Array);
			int idx=0;
			string::size_type offset=0;
			global = global && substr.length();
			string::const_iterator search_begin=str.begin(), match_begin, match_end;
			if(regex_search(str, search_begin, substr, ignoreCase, sticky, match_begin, match_end)) {
				do {
					offset = match_begin-str.begin();
					retVar->addChild(int2string(idx++), c->newScriptVar(string(match_begin, match_end)));
#if 1 /* Fix from "vcmpeq" (see Issue 14) currently untested */
					if (match_begin == match_end) {
						if (search_begin != str.end())
							++search_begin;
						else
							break;
					} else {
						search_begin = match_end;
					}
#else
					search_begin = match_end;
#endif
				} while(global && regex_search(str, search_begin, substr, ignoreCase, sticky, match_begin, match_end));
			}
			if(idx) {
				retVar->addChild("input", c->newScriptVar(str));
				retVar->addChild("index", c->newScriptVar((int)offset));
				c->setReturnVar(retVar);
			} else
				c->setReturnVar(c->constScriptVar(Null));
		} catch(regex_error e) {
			c->throwError(SyntaxError, string(e.what())+" - "+CScriptVarRegExp::ErrorStr(e.code()));
		}
	}
}

static void scStringIndexOf(const CFunctionsScopePtr &c, void *userdata) {
	string str = this2string(c);
	string search = c->getArgument("search")->toString();
	CNumber pos_n = c->getArgument("pos")->toNumber();
	string::size_type pos;
	pos = (userdata) ? string::npos : 0;
	if(pos_n.sign()<0) pos = 0;
	else if(pos_n.isInfinity()) pos = string::npos;
	else if(pos_n.isFinite()) pos = pos_n.toInt32();
	string::size_type p = (userdata==0) ? str.find(search, pos) : str.rfind(search, pos);
	if(p==string::npos)
		c->setReturnVar(c->newScriptVar(-1));
	else
		c->setReturnVar(c->newScriptVar(p));
}

static void scStringIndexOf(const CFunctionsScopePtr &c, void *userdata) {
	string str = c->getArgument("this")->getString();
	string search = c->getArgument("search")->getString();
	size_t p = (userdata==0) ? str.find(search) : str.rfind(search);
	int val = (p==string::npos) ? -1 : p;
	c->setReturnVar(c->newScriptVar(val));
}

static void scStringConcat(const CFunctionsScopePtr &c, void *userdata) {
	int length = c->getArgumentsLength();
	string str = c->getArgument("this")->getString();
	for(int i=(int)userdata; i<length; i++)
		str.append(c->getArgument(i)->getString());
	c->setReturnVar(c->newScriptVar(str));
}

/*
static void scIntegerValueOf(const CFunctionsScopePtr &c, void *) {
	string str = c->getArgument("str")->toString();

	int val = 0;
	if (str.length()==1)
		val = str.operator[](0);
	c->setReturnVar(c->newScriptVar(val));
}
*/
static void scJSONStringify(const CFunctionsScopePtr &c, void *) {
	uint32_t UniqueID = c->getContext()->allocUniqueID();
	bool hasRecursion=false;
	c->setReturnVar(c->newScriptVar(c->getArgument("obj")->getParsableString("", "   ", UniqueID, hasRecursion)));
	c->getContext()->freeUniqueID();
	if(hasRecursion) c->throwError(TypeError, "cyclic object value");
}

static void scCharToInt(const CFunctionsScopePtr &c, void *) {
	string str = c->getArgument("ch")->toString();;
	int val = 0;
	if (str.length()>0)
		val = (int)str.c_str()[0];
	c->setReturnVar(c->newScriptVar(val));
}

static void scStringConcat(const CFunctionsScopePtr &c, void *userdata) {
	int length = c->getArgumentsLength();
	string str = this2string(c);
	for(int32_t i=ptr2int32(userdata); i<length; i++)
		str.append(c->getArgument(i)->toString());
	c->setReturnVar(c->newScriptVar(str));
}

static void scStringCharCodeAt(const CFunctionsScopePtr &c, void *) {
	string str = this2string(c);
	int p = c->getArgument("pos")->toNumber().toInt32();
	if (p>=0 && p<(int)str.length())
		c->setReturnVar(c->newScriptVar((unsigned char)str.at(p)));
	else
		c->setReturnVar(c->constScriptVar(NaN));
}

static void scStringLocaleCompare(const CFunctionsScopePtr &c, void *userdata) {
	string str = this2string(c);
	string compareString = c->getArgument("compareString")->toString();
	int32_t val = 0;
	if(str<compareString) val = -1;
	else if(str>compareString) val = 1;
	c->setReturnVar(c->newScriptVar(val));
}