/* static */ OP_STATUS
DOM_LSInput::GetStringData(const uni_char *&stringData, ES_Object *input, DOM_EnvironmentImpl *environment)
{
	DOM_Runtime *runtime = environment->GetDOMRuntime();
	OP_BOOLEAN result;
	ES_Value value;

	stringData = NULL;

	RETURN_IF_ERROR(result = runtime->GetName(input, UNI_L("characterStream"), &value));
	if (result == OpBoolean::IS_TRUE && value.type != VALUE_NULL && value.type != VALUE_UNDEFINED && !(value.type == VALUE_STRING && *value.value.string))
		return OpStatus::OK;

	RETURN_IF_ERROR(result = runtime->GetName(input, UNI_L("byteStream"), &value));
	if (result == OpBoolean::IS_TRUE && value.type != VALUE_NULL && value.type != VALUE_UNDEFINED && !(value.type == VALUE_STRING && *value.value.string))
		return OpStatus::OK;

	RETURN_IF_ERROR(result = runtime->GetName(input, UNI_L("stringData"), &value));
	if (result == OpBoolean::IS_TRUE && value.type == VALUE_STRING && *value.value.string)
	{
		TempBuffer *buffer = environment->GetWindow()->GetEmptyTempBuf();
		RETURN_IF_ERROR(buffer->Append(value.value.string));
		stringData = buffer->GetStorage();
	}

	return OpStatus::OK;
}

double
XPath_ConversionExpressionHelper::GetNumberL (XPath_Context *context, BOOL initial)
{
  OP_ASSERT (!numberexpression);

  StartL (context, initial);

  TempBuffer buffer; ANCHOR (TempBuffer, buffer);
  if (GetStringValueL (context, initial, buffer))
    return XPath_Value::AsNumber (buffer.GetStorage ());
  else if (booleanexpression)
    return booleanexpression->EvaluateToBooleanL (context, initial) ? 1. : 0.;
  else if (stringexpression)
    return XPath_Value::AsNumber (stringexpression->EvaluateToStringL (context, initial, buffer));

#ifdef XPATH_EXTENSION_SUPPORT
  OP_ASSERT (unknown);
  XPath_Value *value = unknown->EvaluateL (context, initial);
  double number = value->AsNumberL ();
  XPath_Value::DecRef (context, value);
  return number;
#else // XPATH_EXTENSION_SUPPORT
  OP_ASSERT (FALSE);
  return op_nan (0);
#endif // XPATH_EXTENSION_SUPPORT
}

/**
 * Returns OpStatus:ERR if there is no legal mapping.
 */
static OP_STATUS MapAttributeToPropertyName(const uni_char* attr, TempBuffer& prop)
{
	if (uni_strncmp(attr, "data-", 5) != 0)
		return OpStatus::ERR;

	attr += 5;
	const uni_char* p = attr;
	while (*p)
	{
		if (*p >= 'A' && *p <= 'Z')
			return OpStatus::ERR;
		p++;
	}

	while (*attr)
	{
		if (*attr == '-' && attr[1] >= 'a' && attr[1] <= 'z')
		{
			RETURN_IF_ERROR(prop.Append(attr[1] - 'a' + 'A'));
			attr++;
		}
		else
			RETURN_IF_ERROR(prop.Append(*attr));
		attr++;
	}

	return OpStatus::OK;
}

/* static */ double
XPath_Value::AsNumberL (const uni_char *string, unsigned string_length)
{
  TempBuffer buffer; ANCHOR (TempBuffer, buffer);
  buffer.AppendL (string, string_length);

  uni_char *endptr;
  return uni_strtod (buffer.GetStorage (), &endptr);
}

/* static */ OP_STATUS
JS_Console::AppendValue(const ES_Value &value, TempBuffer &buf)
{
	switch (value.type)
	{
	case VALUE_UNDEFINED:
		return buf.Append("undefined");
	case VALUE_NULL:
		return buf.Append("null");
	case VALUE_BOOLEAN:
		return buf.Append(value.value.boolean ? "true" : "false");
	case VALUE_NUMBER:
		return buf.AppendDouble(value.value.number);
	case VALUE_STRING:
		return buf.Append(value.value.string);
	case VALUE_OBJECT:
		RETURN_IF_ERROR(buf.Append("[object "));
		RETURN_IF_ERROR(buf.Append(ES_Runtime::GetClass(value.value.object)));
		return buf.Append("]");
	case VALUE_STRING_WITH_LENGTH:
		return buf.Append(value.value.string_with_length->string, value.value.string_with_length->length);
	}

	return OpStatus::OK;
}

XMLTreeAccessor::Node *
XPath_Node::GetTreeNodeByIdL (const uni_char *id, unsigned id_length)
{
  TempBuffer buffer; ANCHOR (TempBuffer, buffer);
  buffer.AppendL (id, id_length);

  XMLTreeAccessor::Node *node;
  LEAVE_IF_ERROR (tree->GetElementById (node, buffer.GetStorage ()));

  return node;
}

std::string app2net(const wchar_t * w, int cp)
{
	if (!w)
		return std::string();

	// utf16 -> utf8
	TempBuffer<char> str;

	// 计算大小
	int size = WideCharToMultiByte(cp, 0, w, -1, NULL, NULL, NULL, NULL);

	// 转换
	WideCharToMultiByte(cp, 0, w, -1, str.Allocate(size), size, NULL, NULL);

	return std::string(str.data());
}

void Scale_BGRA_Generic(unsigned int in_w, unsigned int in_h, const uint8_t* in_data, int in_stride,
						unsigned int out_w, unsigned int out_h, uint8_t* out_data, int out_stride,
						MipMapFunction mipmap_function, BilinearFunction bilinear_function) {

	// no scaling?
	if(in_w == out_w && in_h == out_h) {
		if(in_stride == out_stride) {
			memcpy(out_data, in_data, in_stride * in_h);
		} else {
			for(unsigned int out_j = 0; out_j < out_h; ++out_j) {
				memcpy(out_data, in_data, in_w * 4);
				in_data += in_stride;
				out_data += out_stride;
			}
		}
		return;
	}

	// calculate mipmap factors
	unsigned int mx = 0, my = 0;
	while((out_w << (mx + 1)) <= in_w) ++mx;
	while((out_h << (my + 1)) <= in_h) ++my;
	if(mx + my > 8) {
		if(mx <= 4)
			my = 8 - mx;
		else if(my <= 4)
			mx = 8 - my;
		else
			mx = my = 4;
	}

	// pure mipmap scaling?
	if((out_w << mx) == in_w && (out_h << my) == in_h) {
		mipmap_function(in_w, in_h, in_data, in_stride, out_data, out_stride, mx, my);
		return;
	}

	// create mipmap
	TempBuffer<uint8_t> mipmap;
	if(mx != 0 || my != 0) {
		unsigned int mipmap_w = ((in_w - 1) >> mx) + 1, mipmap_h = ((in_h - 1) >> my) + 1;
		int mipmap_stride = grow_align16(mipmap_w * 4);
		mipmap.Alloc(mipmap_stride * mipmap_h);
		mipmap_function(in_w, in_h, in_data, in_stride, mipmap.GetData(), mipmap_stride, mx, my);
		in_data = mipmap.GetData();
		in_stride = mipmap_stride;
	}

/**
 * Returns OpStatus:ERR if there is no legal mapping.
 */
static OP_STATUS MapPropertyToAttributeName(const uni_char* prop, TempBuffer& attr)
{
	RETURN_IF_ERROR(attr.Append("data-"));
	while (*prop)
	{
		if (*prop == '-' && prop[1] >= 'a' && prop[1] <= 'z')
			return OpStatus::ERR;

		if (*prop >= 'A' && *prop <= 'Z')
		{
			RETURN_IF_ERROR(attr.Append('-'));
			RETURN_IF_ERROR(attr.Append(*prop - 'A' + 'a'));
		}
		else
			RETURN_IF_ERROR(attr.Append(*prop));

		prop++;
	}
	return OpStatus::OK;
}

static OP_STATUS
XMLWriteToFileEscaped (OpFile &file, const uni_char *string)
{
  if (*string)
    {
      TempBuffer buffer;

      while (*string)
        {
          if (*string == '&')
            RETURN_IF_ERROR (buffer.Append ("&"));
          else if (*string == '<')
            RETURN_IF_ERROR (buffer.Append ("&#60;"));
          else if (*string == '\'')
            RETURN_IF_ERROR (buffer.Append ("&#27;"));
          else
            RETURN_IF_ERROR (buffer.Append (*string));

          ++string;
        }

      return XMLWriteToFile (file, buffer.GetStorage ());
    }
  else
    return OpStatus::OK;
}

OP_STATUS
DOM_CSSStyleDeclaration::MutationState::AfterChange()
{
	if (send_attrmodified)
	{
		TempBuffer newBuffer;
		StyleAttribute* styleattr = element->GetThisElement()->GetStyleAttribute();
		if (styleattr)
			OpStatus::Ignore(styleattr->ToString(&newBuffer));

		const uni_char *prevValue = prevBuffer.GetStorage(), *newValue = newBuffer.GetStorage();
		if (!(prevValue == newValue || prevValue && newValue && uni_strcmp(prevValue, newValue) == 0))
		{
			DOM_Attr* attr;
			PUT_FAILED_IF_ERROR(element->GetAttributeNode(attr, ATTR_XML, UNI_L("style"), NS_IDX_DEFAULT, TRUE, TRUE, TRUE));
			if (attr)
				PUT_FAILED_IF_ERROR(element->SendAttrModified(DOM_Object::GetCurrentThread(origining_runtime), attr, prevValue, newValue));
		}
	}

	return OpStatus::OK;
}

void
XPath_Node::GetQualifiedNameL (TempBuffer &qname)
{
  OP_ASSERT (type == XP_NODE_ELEMENT || type == XP_NODE_ATTRIBUTE);

  XMLCompleteName temporary, *completename;

  if (type == XP_NODE_ELEMENT)
    {
      tree->GetName (temporary, treenode);
      completename = &temporary;
    }
  else
    completename = &name;

  const uni_char *prefix = completename->GetPrefix ();
  if (prefix)
    {
      qname.AppendL (prefix);
      qname.AppendL (":");
    }

  qname.AppendL (completename->GetLocalPart ());
}

/* virtual */ ES_GetState
JS_Location::GetName(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime)
{
	TempBuffer *buffer = GetEmptyTempBuf();
	URL url;

	if (fakewindow)
		url = fakewindow->GetURL();
#ifdef SELFTEST
	else if (!do_navigation)
		url = current_url;
#endif // SELFTEST
	else if (FramesDocument *frames_doc = GetFramesDocument())
	{
		url = frames_doc->GetURL();

		// The anchors (hash) might be better in DocumentManager
		URL doc_man_url = frames_doc->GetDocManager()->GetCurrentURL();
		if (doc_man_url == url) // Doesn't compare anchors
			url = doc_man_url;
	}
#ifdef DOM_WEBWORKERS_SUPPORT
	/* No FramesDocument to query, so consult the origin DocumentManager for the Worker */
	if (!GetFramesDocument())
	{
		DOM_WebWorkerController *web_workers = GetEnvironment()->GetWorkerController();
		if (DOM_WebWorker *ww = web_workers->GetWorkerObject())
			url = ww->GetLocationURL();
		else if (DocumentManager *doc = web_workers->GetWorkerDocManager())
			url = doc->GetCurrentURL();
		OP_ASSERT(!url.IsEmpty());
	}
#endif // DOM_WEBWORKERS_SUPPORT

	switch (property_name)
	{
	case OP_ATOM_href:
		DOMSetString(value, url.GetAttribute(URL::KUniName_With_Fragment_Escaped).CStr());
		return GET_SUCCESS;

	case OP_ATOM_protocol:
		if (value)
		{
			const char *protocol = url.GetAttribute(URL::KProtocolName).CStr();
			if (protocol)
			{
				GET_FAILED_IF_ERROR(buffer->Append(protocol));
				GET_FAILED_IF_ERROR(buffer->Append(":"));
			}

			DOMSetString(value, buffer);
		}
		return GET_SUCCESS;

	case OP_ATOM_host:
	case OP_ATOM_hostname:
		if (value)
		{
			const uni_char *name = url.GetServerName() ? url.GetServerName()->UniName() : NULL;

			if (property_name == OP_ATOM_host)
			{
				unsigned short port = url.GetServerPort();
				if (port)
				{
					GET_FAILED_IF_ERROR(buffer->Append(name));
					GET_FAILED_IF_ERROR(buffer->Append(":"));
					GET_FAILED_IF_ERROR(buffer->AppendUnsignedLong(port));
					name = buffer->GetStorage();
				}
			}

			DOMSetString(value, name);
		}
		return GET_SUCCESS;

	case OP_ATOM_port:
		if (value)
		{
			unsigned short port = url.GetServerPort();
			if (port)
				GET_FAILED_IF_ERROR(buffer->AppendUnsignedLong(port));

			DOMSetString(value, buffer);
		}
		return GET_SUCCESS;

	case OP_ATOM_pathname:
		if (value)
		{
			const uni_char *path = url.GetAttribute(URL::KUniPath).CStr();

			if (path)
			{
				GET_FAILED_IF_ERROR(buffer->Append(path));
				uni_char *path_tmp = buffer->GetStorage();

				/* It isn't obvious from the JS spec and the relevant RFC, but in
				   Javascript the 'pathname' excludes any arguments passed to the page. */
				if (uni_char *query_start = uni_strchr(path_tmp, '?'))
//.........这里部分代码省略.........

/* virtual */
ES_GetState DOM_JILRadioInfo::InternalGetName(OpAtom property_atom, ES_Value* value, DOM_Runtime* origining_runtime, ES_Value* restart_value)
{
	switch (property_atom)
	{
		case OP_ATOM_isRadioEnabled:
		{
			if (value)
			{
				OP_BOOLEAN is_radio_enabled = g_op_telephony_network_info->IsRadioEnabled();
				if (!OpStatus::IsError(is_radio_enabled))
					DOMSetBoolean(value, is_radio_enabled == OpBoolean::IS_TRUE);
				else if (is_radio_enabled == OpStatus::ERR_NOT_SUPPORTED)
					DOMSetUndefined(value);
				else
					return ConvertCallToGetName(HandleJILError(is_radio_enabled, value, origining_runtime), value);
			}
			return GET_SUCCESS;
		}
		case OP_ATOM_isRoaming:
		{
			if (value)
			{
				OP_BOOLEAN is_roaming = g_op_telephony_network_info->IsRoaming();
				if (!OpStatus::IsError(is_roaming))
					DOMSetBoolean(value, is_roaming == OpBoolean::IS_TRUE);
				else if (is_roaming == OpStatus::ERR_NOT_SUPPORTED)
					DOMSetUndefined(value);
				else
					return ConvertCallToGetName(HandleJILError(is_roaming, value, origining_runtime), value);
			}
			return GET_SUCCESS;
		}
		case OP_ATOM_radioSignalSource:
		{
			if (value)
			{
				OpTelephonyNetworkInfo::RadioSignalSource radio_source;
				OP_STATUS ret_val = g_op_telephony_network_info->GetRadioSignalSource(&radio_source);
				if (!OpStatus::IsError(ret_val))
				{
					TempBuffer* buffer = GetEmptyTempBuf();
					ret_val = buffer->Append(RadioSignalSourceValueToString(radio_source));
					if (OpStatus::IsSuccess(ret_val))
						DOMSetString(value, buffer);
				}
				else if (ret_val == OpStatus::ERR_NOT_SUPPORTED)
					DOMSetUndefined(value);
				if (OpStatus::IsError(ret_val))
					return ConvertCallToGetName(HandleJILError(ret_val, value, origining_runtime), value);
			}
			return GET_SUCCESS;
		}
		case OP_ATOM_radioSignalStrengthPercent:
		{
			if (value)
			{
				double signal_strength;
				OP_STATUS ret_val = g_op_telephony_network_info->GetRadioSignalStrength(&signal_strength);
				if (!OpStatus::IsError(ret_val))
					DOMSetNumber(value, signal_strength);
				else if (ret_val == OpStatus::ERR_NOT_SUPPORTED)
					DOMSetUndefined(value);
				else
					return ConvertCallToGetName(HandleJILError(ret_val, value, origining_runtime), value);
			}
			return GET_SUCCESS;
		}
		case OP_ATOM_onSignalSourceChange:
			DOMSetObject(value, m_on_radio_source_changed);
			return GET_SUCCESS;
	}
	return GET_FAILED;
}

/* virtual */ ES_PutState
JS_Location::PutName(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime)
{
	if (GetName(property_name, NULL, origining_runtime) != GET_SUCCESS)
		return PUT_FAILED;

	FramesDocument *frames_doc = GetFramesDocument();
	if (!frames_doc)
		return PUT_SUCCESS;

	if (value->type != VALUE_STRING)
		return PUT_NEEDS_STRING;

	const uni_char *value_string = value->value.string;

	while (value_string[0] == ' ')
		++value_string;

	if (property_name == OP_ATOM_href)
		if (value_string[0] == '#')
			property_name = OP_ATOM_hash;
		else if (value_string[0] == '?')
			property_name = OP_ATOM_search;

	URL url;
	DocumentReferrer ref_url(GetStandardRefURL(frames_doc, origining_runtime));
	TempBuffer buffer;

	URL current_url = ref_url.url;
#ifdef SELFTEST
	if (!do_navigation)
		current_url = this->current_url;
#endif // SELFTEST

	switch (property_name)
	{
	case OP_ATOM_href:
	case OP_ATOM_protocol:
	case OP_ATOM_host:
	case OP_ATOM_hostname:
	case OP_ATOM_port:
	case OP_ATOM_pathname:
		BOOL allowed;
		if (OpStatus::IsError(OpSecurityManager::CheckSecurity(OpSecurityManager::DOM_ALLOWED_TO_NAVIGATE, static_cast<DOM_Runtime *>(origining_runtime), GetRuntime(), allowed)) ||
			!allowed)
			return PUT_SECURITY_VIOLATION;
	}

	switch (property_name)
	{
	case OP_ATOM_protocol:
	{
		unsigned length = uni_strlen(value_string);
		while (length > 0 && value_string[length - 1] == ':')
			length--;
		if (length > 0)
		{
			const uni_char *current_url_string = current_url.GetAttribute(URL::KUniName_Username_Password_NOT_FOR_UI).CStr();
			const uni_char *current_scheme_end = uni_strchr(current_url_string, ':');
			if (!current_scheme_end)
				return PUT_SUCCESS;

			PUT_FAILED_IF_ERROR(buffer.Append(value_string, length));
			PUT_FAILED_IF_ERROR(buffer.Append(current_scheme_end));

			url = GetEncodedURL(origining_runtime->GetFramesDocument(), buffer.GetStorage());

			BOOL allowed;
			if (url.Type() == URL_JAVASCRIPT)
				if (OpStatus::IsError(OpSecurityManager::CheckSecurity(OpSecurityManager::DOM_STANDARD, static_cast<DOM_Runtime *>(origining_runtime), GetRuntime(), allowed)) ||
				    !allowed)
					return PUT_SUCCESS;
		}
		break;
	}
	case OP_ATOM_host:
	{
		const uni_char *current_url_string = current_url.GetAttribute(URL::KUniName_Username_Password_NOT_FOR_UI).CStr();
		const uni_char *current_scheme_end = uni_strchr(current_url_string, ':');

		// URL must be an "authority-based URL"
		if (current_scheme_end && current_scheme_end[1] == '/' && current_scheme_end[2] == '/')
		{
			OpString hostname;
			PUT_FAILED_IF_ERROR(current_url.GetAttribute(URL::KUniHostName, hostname));
			/* Just bail if the URL doesn't have a hostname after all. */
			if (!hostname.CStr())
				return PUT_SUCCESS;

			uni_char *hostname_start = uni_strstr(current_url_string, hostname.CStr());
			OP_ASSERT(hostname_start);
			uni_char *hostname_end = hostname_start + hostname.Length();

			unsigned short port = current_url.GetAttribute(URL::KServerPort);
			if (port > 0 && *hostname_end == ':')
			{
				hostname_end++;
				while (uni_isdigit(*hostname_end))
					hostname_end++;
			}
//.........这里部分代码省略.........

/* static */ OP_STATUS
JS_Console::FormatString(ES_Value* argv, int argc, OpString &str)
{
	if (argc == 0)
		return OpStatus::OK;

	// Holds the formatted string.
	TempBuffer buf;

	// The argument which will be stringified next.
	int argument = 0;

	// If the first argument is a string, check if it contains placeholders.
	if (argv[0].type == VALUE_STRING)
	{
		// The first argument is the format string. It may or may not contain
		// formatting placeholders (%).
		const uni_char *placeholder = argv[0].value.string;
		const uni_char *stored = placeholder;

		// Skip the formatting string.
		++argument;

		while ((placeholder = uni_strchr(placeholder, '%')) != NULL)
		{
			// Calculate the length until the '%'.
			int length = (placeholder - stored);

			// Skip the '%', and check that 'placeholder' now points to
			// a supported character.
			if (!JS_Console::IsSupportedPlaceholder(++placeholder))
				continue;

			// Append everything up until the '%'.
			if (length > 0)
				RETURN_IF_ERROR(buf.Append(stored, length));

			// If the character after the first '%' is another '%', then output
			// a single '%'.
			if (*placeholder == '%')
				RETURN_IF_ERROR(buf.Append("%"));
			// Otherwise, append the string representation of the ES_Value.
			else if (argument < argc)
				RETURN_IF_ERROR(JS_Console::AppendValue(argv[argument++], buf));
			// Or, if we don't have more arguments, output the original placeholder.
			else
				RETURN_IF_ERROR(buf.Append(placeholder - 1, 2));

			// Skip the character following the %, but only if not at the
			// end of string.
			if (*placeholder != '\0')
				++placeholder;

			stored = placeholder;
		}

		// Append the rest of the formatting string, if any.
		if (*stored != '\0')
			RETURN_IF_ERROR(buf.Append(stored));
	}

	// If we have more arguments, append them in a space delimited list.
	while (argument < argc)
	{
		// Never start a string with a space.
		if (argument > 0)
			RETURN_IF_ERROR(buf.Append(" "));

		RETURN_IF_ERROR(AppendValue(argv[argument++], buf));
	}

	return str.Set(buf.GetStorage());
}

ES_GetState
DOM_BrowserTab::GetTabInfo(OpAtom property_name, ES_Value* value, ES_Runtime* origining_runtime, ES_Object* restart_object)
{
	if (!value)
		return GET_SUCCESS;

	// Private mode can be obtained synchronously if we have window.
	if (property_name == OP_ATOM_private)
	{
		Window* window = GetTabWindow();
		if (window)
		{
			DOMSetBoolean(value, window->GetPrivacyMode());
			return GET_SUCCESS;
		}
	}

	OP_ASSERT(GetTabId());

	DOM_TabsApiHelper* call_helper;
	if (!restart_object)
	{
		GET_FAILED_IF_ERROR(DOM_TabsApiHelper::Make(call_helper, static_cast<DOM_Runtime*>(origining_runtime)));
		call_helper->QueryTab(GetTabId());
	}
	else
		call_helper = DOM_HOSTOBJECT(restart_object, DOM_TabsApiHelper);

	if (call_helper->IsFinished())
	{
		if (property_name == OP_ATOM_closed)
		{
			DOMSetBoolean(value, OpStatus::IsError(call_helper->GetStatus()));
			return GET_SUCCESS;
		}
		else
			GET_FAILED_IF_ERROR(call_helper->GetStatus());

		switch (property_name)
		{
		case OP_ATOM_browserWindow:
			DOM_BrowserWindow* new_win;
			GET_FAILED_IF_ERROR(DOM_TabApiCache::GetOrCreateWindow(new_win, m_extension_support, call_helper->GetResult().value.query_tab.browser_window_id, GetRuntime()));
			DOMSetObject(value, new_win);
			break;
		case OP_ATOM_locked:
			DOMSetBoolean(value, call_helper->GetResult().value.query_tab.is_locked);
			break;
		case OP_ATOM_position:
			DOMSetNumber(value, call_helper->GetResult().value.query_tab.position);
			break;
		case OP_ATOM_tabGroup:
			if (call_helper->GetResult().value.query_tab.tab_group_id == 0)
				DOMSetNull(value);
			else
			{
				DOM_BrowserTabGroup* tab_group;
				GET_FAILED_IF_ERROR(DOM_TabApiCache::GetOrCreateTabGroup(tab_group, m_extension_support, call_helper->GetResult().value.query_tab.tab_group_id, GetRuntime()));
				DOMSetObject(value, tab_group);
			}
			break;
		case OP_ATOM_focused:
		case OP_ATOM_selected:
			DOMSetBoolean(value, call_helper->GetResult().value.query_tab.is_selected);
			break;

		case OP_ATOM_title:
			if (!call_helper->GetResult().value.query_tab.is_private || IsPrivateDataAllowed())
			{
				TempBuffer* tmp = GetEmptyTempBuf();
				GET_FAILED_IF_ERROR(tmp->Append(call_helper->GetResult().value.query_tab.title));
				DOMSetString(value, tmp);
			}
			return GET_SUCCESS;

		case OP_ATOM_private:
			DOMSetBoolean(value, call_helper->GetResult().value.query_tab.is_private);
			return GET_SUCCESS;

		default:
			OP_ASSERT(!"Unexpected property");
		}
		return GET_SUCCESS;
	}
	else
		return call_helper->BlockGet(value, origining_runtime);
}

/* static */ BOOL
ES_DebugBuiltins::getObjectDemographics(ES_Execution_Context *context, unsigned argc, ES_Value_Internal *argv, ES_Value_Internal *return_value)
{
    return_value->SetNull();

	if (argc == 1)
	{
        if (!argv[0].ToNumber(context) || !argv[0].IsUInt32())
            return FALSE;

		if (ES_Heap *heap = g_ecmaManager->GetHeapById(argv[0].GetNumAsUInt32()))
		{
			TempBuffer *buffer = g_ecmaManager->GetHeapDebuggerBuffer();

			buffer->Clear();
			buffer->Append("{ ");

			unsigned *live_objects = heap->live_objects;

			for (unsigned index = 0; index < GCTAG_UNINITIALIZED; ++index)
			{
				if (index != 0)
					buffer->Append(", ");

				buffer->Append("\"");
				buffer->Append(g_ecmaClassName[index]);
				buffer->Append("\": ");
				buffer->AppendUnsignedLong(live_objects[index]);
			}

			buffer->Append(" }");

            return_value->SetString(JString::Make(context, buffer->GetStorage(), buffer->Length()));
		}
	}

	return TRUE;
}

//.........这里部分代码省略.........
    case OP_ATOM_pixelHeight:
    case OP_ATOM_pixelLeft:
    case OP_ATOM_pixelTop:
    case OP_ATOM_pixelWidth:
    case OP_ATOM_pixelBottom:
    case OP_ATOM_pixelRight:
		is_pixel = TRUE;
		break;

	case OP_ATOM_length:
		return PUT_READ_ONLY;

	case OP_ATOM_cssText:
		if (value->type == VALUE_NULL)
			DOMSetString(value);
		else if (value->type != VALUE_STRING)
			return PUT_NEEDS_STRING;

		if (type == DOM_ST_INLINE)
			PUT_FAILED_IF_ERROR(element->SetAttribute(ATTR_XML, UNI_L("style"), NS_IDX_DEFAULT, value->value.string, value->GetStringLength(), TRUE, origining_runtime));
		else if (type == DOM_ST_RULE)
		{
			OP_STATUS stat = style->SetText(value->value.string, exception);
			if (stat == OpStatus::ERR_NO_MEMORY)
				return PUT_NO_MEMORY;
			else if (stat == OpStatus::ERR)
			{
				if (exception == CSS_DOMEXCEPTION_NO_MODIFICATION_ALLOWED_ERR)
					return PUT_READ_ONLY;
				else if (exception == CSS_DOMEXCEPTION_SYNTAX_ERR)
					return DOM_PUTNAME_DOMEXCEPTION(SYNTAX_ERR);
			}
		}
		return PUT_SUCCESS;

	default:
		if (css_property != -1)
		{
			if (value->type == VALUE_NULL)
				DOMSetString(value);
			else if (value->type != VALUE_STRING)
				return PUT_NEEDS_STRING;

#ifdef DOM2_MUTATION_EVENTS
			MutationState mutationstate(element, (DOM_Runtime *) origining_runtime);
			if (element)
			{
				PUT_FAILED_IF_ERROR(mutationstate.BeforeChange());
			}
#endif // DOM2_MUTATION_EVENTS

			status = style->SetProperty(css_property, value->value.string, exception);

#ifdef DOM2_MUTATION_EVENTS
			if (OpStatus::IsSuccess(status) && element)
				PUT_FAILED_IF_ERROR(mutationstate.AfterChange());
#endif // DOM2_MUTATION_EVENTS

			goto handle_status;
		}
		else
			return PUT_FAILED;
	}

	if (is_pos || is_pixel)
	{
		OP_ASSERT(css_property != -1);

		if (value->type != VALUE_NUMBER)
			return PUT_NEEDS_NUMBER;

		if (is_pixel)
			value->value.number = op_floor(value->value.number);

		TempBuffer *buffer = GetEmptyTempBuf();
		PUT_FAILED_IF_ERROR(buffer->Expand(33));

		char *number8 = reinterpret_cast<char *>(buffer->GetStorage());
		char *result = OpDoubleFormat::ToString(number8, value->value.number);
		if (!result)
			return PUT_NO_MEMORY;
		make_doublebyte_in_place(buffer->GetStorage(), op_strlen(number8));

		if (is_pos)
			status = style->SetPosValue(css_property, buffer->GetStorage(), exception);
		else
			status = style->SetPixelValue(css_property, buffer->GetStorage(), exception);
	}

handle_status:
	if (OpStatus::IsMemoryError(status))
		return PUT_NO_MEMORY;
	else if (OpStatus::IsError(status))
		if (exception == CSS_DOMEXCEPTION_NO_MODIFICATION_ALLOWED_ERR)
			return PUT_READ_ONLY;
		else if (exception == CSS_DOMEXCEPTION_SYNTAX_ERR)
			return DOM_PUTNAME_DOMEXCEPTION(SYNTAX_ERR);

	return PUT_SUCCESS;
}

/* static */ const uni_char *
XPath_Value::AsStringL (double number, TempBuffer &buffer)
{
  char *storage8;

  buffer.ExpandL (33);
  buffer.SetCachedLengthPolicy (TempBuffer::UNTRUSTED);
  storage8 = reinterpret_cast<char *> (buffer.GetStorage ());

  if (op_isnan (number))
    return UNI_L ("NaN");
  else if (number == 0)
    return UNI_L ("0");
  else
    {
      if (!OpDoubleFormat::ToString (storage8, number))
        LEAVE (OpStatus::ERR_NO_MEMORY);

      char *e = 0, *p = 0;
      for (unsigned index = 0; storage8[index]; ++index)
        if (storage8[index] == '.')
          p = &storage8[index];
        else if (storage8[index] == 'e' || storage8[index] == 'E')
          e = &storage8[index];

      if (e)
        {
          TempBuffer b; ANCHOR (TempBuffer, b);

          if (number < 0)
            b.AppendL ("-");

          int exp = op_atoi (e + 1), index;
          *e = 0;
          if (exp > 0)
            {
              if (storage8[0] != '0')
                b.AppendL (storage8[0]);
              if (p)
                {
                  b.AppendL (p + 1, MIN (e - (p + 1), exp));
                  if (exp < e - (p + 1))
                    {
                      b.AppendL (".");
                      b.AppendL (p + 1 + exp, e - (p + 1 + exp));
                    }
                  else if (e - (p + 1) < exp)
                    for (index = exp; index < e - (p + 1); ++index)
                      b.AppendL ("0");
                }
              else
                for (index = 0; index < exp; ++index)
                  b.AppendL ("0");
            }
          else if (exp < 0)
            {
              b.AppendL ("0.");
              for (index = 1; index < -exp; ++index)
                b.AppendL ("0");
              for (index = 0; storage8[index]; ++index)
                if (op_isdigit (storage8[index]) && storage8[index] != '0')
                  break;
              for (; storage8[index]; ++index)
                if (op_isdigit (storage8[index]))
                  b.AppendL (storage8[index]);
            }

          buffer.Clear ();
          buffer.AppendL (b.GetStorage ());
        }
      else
        make_doublebyte_in_place (buffer.GetStorage (), op_strlen (storage8));
    }

  return buffer.GetStorage ();
}