mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-23 00:47:31 +09:00
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
This commit is contained in:
Roy Tam
commit
dcd9973243
150858 changed files with 23884658 additions and 0 deletions
617
dom/xslt/xpath/txXPCOMExtensionFunction.cpp
Normal file
617
dom/xslt/xpath/txXPCOMExtensionFunction.cpp
Normal file
|
|
@ -0,0 +1,617 @@
|
|||
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
||||
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
|
||||
#include "nsAutoPtr.h"
|
||||
#include "nsComponentManagerUtils.h"
|
||||
#include "nsDependentString.h"
|
||||
#include "nsIAtom.h"
|
||||
#include "nsIInterfaceInfoManager.h"
|
||||
#include "nsServiceManagerUtils.h"
|
||||
#include "txExpr.h"
|
||||
#include "txIFunctionEvaluationContext.h"
|
||||
#include "txIXPathContext.h"
|
||||
#include "txNodeSetAdaptor.h"
|
||||
#include "txXPathTreeWalker.h"
|
||||
#include "xptcall.h"
|
||||
#include "txXPathObjectAdaptor.h"
|
||||
#include "mozilla/Attributes.h"
|
||||
#include "mozilla/UniquePtr.h"
|
||||
#include "mozilla/dom/ScriptSettings.h"
|
||||
#include "nsIClassInfo.h"
|
||||
#include "nsIInterfaceInfo.h"
|
||||
#include "js/RootingAPI.h"
|
||||
|
||||
NS_IMPL_ISUPPORTS(txXPathObjectAdaptor, txIXPathObject)
|
||||
|
||||
class txFunctionEvaluationContext final : public txIFunctionEvaluationContext
|
||||
{
|
||||
public:
|
||||
txFunctionEvaluationContext(txIEvalContext *aContext, nsISupports *aState);
|
||||
|
||||
NS_DECL_ISUPPORTS
|
||||
NS_DECL_TXIFUNCTIONEVALUATIONCONTEXT
|
||||
|
||||
void ClearContext()
|
||||
{
|
||||
mContext = nullptr;
|
||||
}
|
||||
|
||||
private:
|
||||
~txFunctionEvaluationContext() {}
|
||||
|
||||
txIEvalContext *mContext;
|
||||
nsCOMPtr<nsISupports> mState;
|
||||
};
|
||||
|
||||
txFunctionEvaluationContext::txFunctionEvaluationContext(txIEvalContext *aContext,
|
||||
nsISupports *aState)
|
||||
: mContext(aContext),
|
||||
mState(aState)
|
||||
{
|
||||
}
|
||||
|
||||
NS_IMPL_ISUPPORTS(txFunctionEvaluationContext, txIFunctionEvaluationContext)
|
||||
|
||||
NS_IMETHODIMP
|
||||
txFunctionEvaluationContext::GetPosition(uint32_t *aPosition)
|
||||
{
|
||||
NS_ENSURE_TRUE(mContext, NS_ERROR_FAILURE);
|
||||
|
||||
*aPosition = mContext->position();
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
txFunctionEvaluationContext::GetSize(uint32_t *aSize)
|
||||
{
|
||||
NS_ENSURE_TRUE(mContext, NS_ERROR_FAILURE);
|
||||
|
||||
*aSize = mContext->size();
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
txFunctionEvaluationContext::GetContextNode(nsIDOMNode **aNode)
|
||||
{
|
||||
NS_ENSURE_TRUE(mContext, NS_ERROR_FAILURE);
|
||||
|
||||
return txXPathNativeNode::getNode(mContext->getContextNode(), aNode);
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
txFunctionEvaluationContext::GetState(nsISupports **aState)
|
||||
{
|
||||
NS_IF_ADDREF(*aState = mState);
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
enum txArgumentType {
|
||||
eBOOLEAN = nsXPTType::T_BOOL,
|
||||
eNUMBER = nsXPTType::T_DOUBLE,
|
||||
eSTRING = nsXPTType::T_DOMSTRING,
|
||||
eNODESET,
|
||||
eCONTEXT,
|
||||
eOBJECT,
|
||||
eUNKNOWN
|
||||
};
|
||||
|
||||
class txXPCOMExtensionFunctionCall : public FunctionCall
|
||||
{
|
||||
public:
|
||||
txXPCOMExtensionFunctionCall(nsISupports *aHelper, const nsIID &aIID,
|
||||
uint16_t aMethodIndex,
|
||||
#ifdef TX_TO_STRING
|
||||
nsIAtom *aName,
|
||||
#endif
|
||||
nsISupports *aState);
|
||||
|
||||
TX_DECL_FUNCTION
|
||||
|
||||
private:
|
||||
txArgumentType GetParamType(const nsXPTParamInfo &aParam,
|
||||
nsIInterfaceInfo *aInfo);
|
||||
|
||||
nsCOMPtr<nsISupports> mHelper;
|
||||
nsIID mIID;
|
||||
uint16_t mMethodIndex;
|
||||
#ifdef TX_TO_STRING
|
||||
nsCOMPtr<nsIAtom> mName;
|
||||
#endif
|
||||
nsCOMPtr<nsISupports> mState;
|
||||
};
|
||||
|
||||
txXPCOMExtensionFunctionCall::txXPCOMExtensionFunctionCall(nsISupports *aHelper,
|
||||
const nsIID &aIID,
|
||||
uint16_t aMethodIndex,
|
||||
#ifdef TX_TO_STRING
|
||||
nsIAtom *aName,
|
||||
#endif
|
||||
nsISupports *aState)
|
||||
: mHelper(aHelper),
|
||||
mIID(aIID),
|
||||
mMethodIndex(aMethodIndex),
|
||||
#ifdef TX_TO_STRING
|
||||
mName(aName),
|
||||
#endif
|
||||
mState(aState)
|
||||
{
|
||||
}
|
||||
|
||||
class txInterfacesArrayHolder
|
||||
{
|
||||
public:
|
||||
txInterfacesArrayHolder(nsIID **aArray, uint32_t aCount) : mArray(aArray),
|
||||
mCount(aCount)
|
||||
{
|
||||
}
|
||||
~txInterfacesArrayHolder()
|
||||
{
|
||||
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mCount, mArray);
|
||||
}
|
||||
|
||||
private:
|
||||
nsIID **mArray;
|
||||
uint32_t mCount;
|
||||
};
|
||||
|
||||
static nsresult
|
||||
LookupFunction(const char *aContractID, nsIAtom* aName, nsIID &aIID,
|
||||
uint16_t &aMethodIndex, nsISupports **aHelper)
|
||||
{
|
||||
nsresult rv;
|
||||
nsCOMPtr<nsISupports> helper = do_GetService(aContractID, &rv);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
nsCOMPtr<nsIClassInfo> classInfo = do_QueryInterface(helper, &rv);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
nsCOMPtr<nsIInterfaceInfoManager> iim =
|
||||
do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID);
|
||||
NS_ENSURE_TRUE(iim, NS_ERROR_FAILURE);
|
||||
|
||||
nsIID** iidArray = nullptr;
|
||||
uint32_t iidCount = 0;
|
||||
rv = classInfo->GetInterfaces(&iidCount, &iidArray);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
txInterfacesArrayHolder holder(iidArray, iidCount);
|
||||
|
||||
// Remove any minus signs and uppercase the following letter (so
|
||||
// foo-bar becomes fooBar). Note that if there are any names that already
|
||||
// have uppercase letters they might cause false matches (both fooBar and
|
||||
// foo-bar matching fooBar).
|
||||
const char16_t *name = aName->GetUTF16String();
|
||||
nsAutoCString methodName;
|
||||
char16_t letter;
|
||||
bool upperNext = false;
|
||||
while ((letter = *name)) {
|
||||
if (letter == '-') {
|
||||
upperNext = true;
|
||||
}
|
||||
else {
|
||||
MOZ_ASSERT(nsCRT::IsAscii(letter),
|
||||
"invalid static_cast coming up");
|
||||
methodName.Append(upperNext ?
|
||||
nsCRT::ToUpper(static_cast<char>(letter)) :
|
||||
letter);
|
||||
upperNext = false;
|
||||
}
|
||||
++name;
|
||||
}
|
||||
|
||||
uint32_t i;
|
||||
for (i = 0; i < iidCount; ++i) {
|
||||
nsIID *iid = iidArray[i];
|
||||
|
||||
nsCOMPtr<nsIInterfaceInfo> info;
|
||||
rv = iim->GetInfoForIID(iid, getter_AddRefs(info));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
uint16_t methodIndex;
|
||||
const nsXPTMethodInfo *methodInfo;
|
||||
rv = info->GetMethodInfoForName(methodName.get(), &methodIndex,
|
||||
&methodInfo);
|
||||
if (NS_SUCCEEDED(rv)) {
|
||||
// Exclude notxpcom and hidden. Also check that we have at least a
|
||||
// return value (the xpidl compiler ensures that that return value
|
||||
// is the last argument).
|
||||
uint8_t paramCount = methodInfo->GetParamCount();
|
||||
if (methodInfo->IsNotXPCOM() || methodInfo->IsHidden() ||
|
||||
paramCount == 0 ||
|
||||
!methodInfo->GetParam(paramCount - 1).IsRetval()) {
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
|
||||
aIID = *iid;
|
||||
aMethodIndex = methodIndex;
|
||||
return helper->QueryInterface(aIID, (void**)aHelper);
|
||||
}
|
||||
}
|
||||
|
||||
return NS_ERROR_XPATH_UNKNOWN_FUNCTION;
|
||||
}
|
||||
|
||||
/* static */
|
||||
nsresult
|
||||
TX_ResolveFunctionCallXPCOM(const nsCString &aContractID, int32_t aNamespaceID,
|
||||
nsIAtom* aName, nsISupports *aState,
|
||||
FunctionCall **aFunction)
|
||||
{
|
||||
nsIID iid;
|
||||
uint16_t methodIndex = 0;
|
||||
nsCOMPtr<nsISupports> helper;
|
||||
|
||||
nsresult rv = LookupFunction(aContractID.get(), aName, iid, methodIndex,
|
||||
getter_AddRefs(helper));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
if (!aFunction) {
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
*aFunction = new txXPCOMExtensionFunctionCall(helper, iid, methodIndex,
|
||||
#ifdef TX_TO_STRING
|
||||
aName,
|
||||
#endif
|
||||
aState);
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
txArgumentType
|
||||
txXPCOMExtensionFunctionCall::GetParamType(const nsXPTParamInfo &aParam,
|
||||
nsIInterfaceInfo *aInfo)
|
||||
{
|
||||
uint8_t tag = aParam.GetType().TagPart();
|
||||
switch (tag) {
|
||||
case nsXPTType::T_BOOL:
|
||||
case nsXPTType::T_DOUBLE:
|
||||
case nsXPTType::T_DOMSTRING:
|
||||
{
|
||||
return txArgumentType(tag);
|
||||
}
|
||||
case nsXPTType::T_INTERFACE:
|
||||
case nsXPTType::T_INTERFACE_IS:
|
||||
{
|
||||
nsIID iid;
|
||||
aInfo->GetIIDForParamNoAlloc(mMethodIndex, &aParam, &iid);
|
||||
if (iid.Equals(NS_GET_IID(txINodeSet))) {
|
||||
return eNODESET;
|
||||
}
|
||||
if (iid.Equals(NS_GET_IID(txIFunctionEvaluationContext))) {
|
||||
return eCONTEXT;
|
||||
}
|
||||
if (iid.Equals(NS_GET_IID(txIXPathObject))) {
|
||||
return eOBJECT;
|
||||
}
|
||||
return eUNKNOWN;
|
||||
}
|
||||
default:
|
||||
{
|
||||
// XXX Error!
|
||||
return eUNKNOWN;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class txParamArrayHolder
|
||||
{
|
||||
public:
|
||||
txParamArrayHolder()
|
||||
: mCount(0)
|
||||
{
|
||||
}
|
||||
txParamArrayHolder(txParamArrayHolder&& rhs)
|
||||
: mArray(mozilla::Move(rhs.mArray))
|
||||
, mCount(rhs.mCount)
|
||||
{
|
||||
rhs.mCount = 0;
|
||||
}
|
||||
~txParamArrayHolder();
|
||||
|
||||
bool Init(uint8_t aCount);
|
||||
operator nsXPTCVariant*() const
|
||||
{
|
||||
return mArray.get();
|
||||
}
|
||||
|
||||
void trace(JSTracer* trc) {
|
||||
for (uint8_t i = 0; i < mCount; ++i) {
|
||||
if (mArray[i].type == nsXPTType::T_JSVAL) {
|
||||
JS::UnsafeTraceRoot(trc, &mArray[i].val.j, "txParam value");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
mozilla::UniquePtr<nsXPTCVariant[]> mArray;
|
||||
uint8_t mCount;
|
||||
};
|
||||
|
||||
txParamArrayHolder::~txParamArrayHolder()
|
||||
{
|
||||
uint8_t i;
|
||||
for (i = 0; i < mCount; ++i) {
|
||||
nsXPTCVariant &variant = mArray[i];
|
||||
if (variant.DoesValNeedCleanup()) {
|
||||
if (variant.type.TagPart() == nsXPTType::T_DOMSTRING)
|
||||
delete (nsAString*)variant.val.p;
|
||||
else {
|
||||
MOZ_ASSERT(variant.type.TagPart() == nsXPTType::T_INTERFACE ||
|
||||
variant.type.TagPart() == nsXPTType::T_INTERFACE_IS,
|
||||
"We only support cleanup of strings and interfaces "
|
||||
"here, and this looks like neither!");
|
||||
static_cast<nsISupports*>(variant.val.p)->Release();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
txParamArrayHolder::Init(uint8_t aCount)
|
||||
{
|
||||
mCount = aCount;
|
||||
mArray = mozilla::MakeUnique<nsXPTCVariant[]>(mCount);
|
||||
if (!mArray) {
|
||||
return false;
|
||||
}
|
||||
|
||||
memset(mArray.get(), 0, mCount * sizeof(nsXPTCVariant));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
nsresult
|
||||
txXPCOMExtensionFunctionCall::evaluate(txIEvalContext* aContext,
|
||||
txAExprResult** aResult)
|
||||
{
|
||||
nsCOMPtr<nsIInterfaceInfoManager> iim =
|
||||
do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID);
|
||||
NS_ENSURE_TRUE(iim, NS_ERROR_FAILURE);
|
||||
|
||||
nsCOMPtr<nsIInterfaceInfo> info;
|
||||
nsresult rv = iim->GetInfoForIID(&mIID, getter_AddRefs(info));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
const nsXPTMethodInfo *methodInfo;
|
||||
rv = info->GetMethodInfo(mMethodIndex, &methodInfo);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
uint8_t paramCount = methodInfo->GetParamCount();
|
||||
uint8_t inArgs = paramCount - 1;
|
||||
|
||||
JS::Rooted<txParamArrayHolder> invokeParams(mozilla::dom::RootingCx());
|
||||
if (!invokeParams.get().Init(paramCount)) {
|
||||
return NS_ERROR_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
const nsXPTParamInfo ¶mInfo = methodInfo->GetParam(0);
|
||||
txArgumentType type = GetParamType(paramInfo, info);
|
||||
if (type == eUNKNOWN) {
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
|
||||
txFunctionEvaluationContext *context;
|
||||
uint32_t paramStart = 0;
|
||||
if (type == eCONTEXT) {
|
||||
if (paramInfo.IsOut()) {
|
||||
// We don't support out values.
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
|
||||
// Create context wrapper.
|
||||
context = new txFunctionEvaluationContext(aContext, mState);
|
||||
|
||||
nsXPTCVariant &invokeParam = invokeParams.get()[0];
|
||||
invokeParam.type = paramInfo.GetType();
|
||||
invokeParam.SetValNeedsCleanup();
|
||||
NS_ADDREF((txIFunctionEvaluationContext*&)invokeParam.val.p = context);
|
||||
|
||||
// Skip first argument, since it's the context.
|
||||
paramStart = 1;
|
||||
}
|
||||
else {
|
||||
context = nullptr;
|
||||
}
|
||||
|
||||
// XXX varargs
|
||||
if (!requireParams(inArgs - paramStart, inArgs - paramStart, aContext)) {
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
|
||||
uint32_t i;
|
||||
for (i = paramStart; i < inArgs; ++i) {
|
||||
Expr* expr = mParams[i - paramStart];
|
||||
|
||||
const nsXPTParamInfo ¶mInfo = methodInfo->GetParam(i);
|
||||
txArgumentType type = GetParamType(paramInfo, info);
|
||||
if (type == eUNKNOWN) {
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
|
||||
nsXPTCVariant &invokeParam = invokeParams.get()[i];
|
||||
if (paramInfo.IsOut()) {
|
||||
// We don't support out values.
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
|
||||
invokeParam.type = paramInfo.GetType();
|
||||
switch (type) {
|
||||
case eNODESET:
|
||||
{
|
||||
RefPtr<txNodeSet> nodes;
|
||||
rv = evaluateToNodeSet(expr, aContext, getter_AddRefs(nodes));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
txNodeSetAdaptor *adaptor = new txNodeSetAdaptor(nodes);
|
||||
if (!adaptor) {
|
||||
return NS_ERROR_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
nsCOMPtr<txINodeSet> nodeSet = adaptor;
|
||||
rv = adaptor->Init();
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
invokeParam.SetValNeedsCleanup();
|
||||
nodeSet.swap((txINodeSet*&)invokeParam.val.p);
|
||||
break;
|
||||
}
|
||||
case eBOOLEAN:
|
||||
{
|
||||
rv = expr->evaluateToBool(aContext, invokeParam.val.b);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
break;
|
||||
}
|
||||
case eNUMBER:
|
||||
{
|
||||
double dbl;
|
||||
rv = evaluateToNumber(mParams[0], aContext, &dbl);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
invokeParam.val.d = dbl;
|
||||
break;
|
||||
}
|
||||
case eSTRING:
|
||||
{
|
||||
nsString *value = new nsString();
|
||||
if (!value) {
|
||||
return NS_ERROR_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
rv = expr->evaluateToString(aContext, *value);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
invokeParam.SetValNeedsCleanup();
|
||||
invokeParam.val.p = value;
|
||||
break;
|
||||
}
|
||||
case eOBJECT:
|
||||
{
|
||||
RefPtr<txAExprResult> exprRes;
|
||||
rv = expr->evaluate(aContext, getter_AddRefs(exprRes));
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
nsCOMPtr<txIXPathObject> adaptor =
|
||||
new txXPathObjectAdaptor(exprRes);
|
||||
if (!adaptor) {
|
||||
return NS_ERROR_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
invokeParam.SetValNeedsCleanup();
|
||||
adaptor.swap((txIXPathObject*&)invokeParam.val.p);
|
||||
break;
|
||||
}
|
||||
case eCONTEXT:
|
||||
case eUNKNOWN:
|
||||
{
|
||||
// We only support passing the context as the *first* argument.
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const nsXPTParamInfo &returnInfo = methodInfo->GetParam(inArgs);
|
||||
txArgumentType returnType = GetParamType(returnInfo, info);
|
||||
if (returnType == eUNKNOWN) {
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
|
||||
nsXPTCVariant &returnParam = invokeParams.get()[inArgs];
|
||||
returnParam.type = returnInfo.GetType();
|
||||
if (returnType == eSTRING) {
|
||||
nsString *value = new nsString();
|
||||
returnParam.SetValNeedsCleanup();
|
||||
returnParam.val.p = value;
|
||||
}
|
||||
else {
|
||||
returnParam.SetIndirect();
|
||||
if (returnType == eNODESET || returnType == eOBJECT) {
|
||||
returnParam.SetValNeedsCleanup();
|
||||
}
|
||||
}
|
||||
|
||||
rv = NS_InvokeByIndex(mHelper, mMethodIndex, paramCount, invokeParams.get());
|
||||
|
||||
// In case someone is holding on to the txFunctionEvaluationContext which
|
||||
// could thus stay alive longer than this function.
|
||||
if (context) {
|
||||
context->ClearContext();
|
||||
}
|
||||
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
switch (returnType) {
|
||||
case eNODESET:
|
||||
{
|
||||
txINodeSet* nodeSet = static_cast<txINodeSet*>(returnParam.val.p);
|
||||
nsCOMPtr<txIXPathObject> object = do_QueryInterface(nodeSet, &rv);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
NS_ADDREF(*aResult = object->GetResult());
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
case eBOOLEAN:
|
||||
{
|
||||
aContext->recycler()->getBoolResult(returnParam.val.b, aResult);
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
case eNUMBER:
|
||||
{
|
||||
return aContext->recycler()->getNumberResult(returnParam.val.d,
|
||||
aResult);
|
||||
}
|
||||
case eSTRING:
|
||||
{
|
||||
nsString *returned = static_cast<nsString*>
|
||||
(returnParam.val.p);
|
||||
return aContext->recycler()->getStringResult(*returned, aResult);
|
||||
}
|
||||
case eOBJECT:
|
||||
{
|
||||
txIXPathObject *object =
|
||||
static_cast<txIXPathObject*>(returnParam.val.p);
|
||||
|
||||
NS_ADDREF(*aResult = object->GetResult());
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
default:
|
||||
{
|
||||
// Huh?
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Expr::ResultType
|
||||
txXPCOMExtensionFunctionCall::getReturnType()
|
||||
{
|
||||
// It doesn't really matter what we return here, but it might
|
||||
// be a good idea to try to keep this as unoptimizable as possible
|
||||
return ANY_RESULT;
|
||||
}
|
||||
|
||||
bool
|
||||
txXPCOMExtensionFunctionCall::isSensitiveTo(ContextSensitivity aContext)
|
||||
{
|
||||
// It doesn't really matter what we return here, but it might
|
||||
// be a good idea to try to keep this as unoptimizable as possible
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef TX_TO_STRING
|
||||
nsresult
|
||||
txXPCOMExtensionFunctionCall::getNameAtom(nsIAtom** aAtom)
|
||||
{
|
||||
NS_ADDREF(*aAtom = mName);
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue