diff options
author | Steve Block <steveblock@google.com> | 2011-05-06 11:45:16 +0100 |
---|---|---|
committer | Steve Block <steveblock@google.com> | 2011-05-12 13:44:10 +0100 |
commit | cad810f21b803229eb11403f9209855525a25d57 (patch) | |
tree | 29a6fd0279be608e0fe9ffe9841f722f0f4e4269 /Source/WebCore/bridge/testbindings.cpp | |
parent | 121b0cf4517156d0ac5111caf9830c51b69bae8f (diff) | |
download | external_webkit-cad810f21b803229eb11403f9209855525a25d57.zip external_webkit-cad810f21b803229eb11403f9209855525a25d57.tar.gz external_webkit-cad810f21b803229eb11403f9209855525a25d57.tar.bz2 |
Merge WebKit at r75315: Initial merge by git.
Change-Id: I570314b346ce101c935ed22a626b48c2af266b84
Diffstat (limited to 'Source/WebCore/bridge/testbindings.cpp')
-rw-r--r-- | Source/WebCore/bridge/testbindings.cpp | 419 |
1 files changed, 419 insertions, 0 deletions
diff --git a/Source/WebCore/bridge/testbindings.cpp b/Source/WebCore/bridge/testbindings.cpp new file mode 100644 index 0000000..bcba115 --- /dev/null +++ b/Source/WebCore/bridge/testbindings.cpp @@ -0,0 +1,419 @@ +/* + * Copyright (C) 1999-2000 Harri Porten (porten@kde.org) + * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ +#include "config.h" + +#include "Bridge.h" +#include "JSObject.h" +#include "JSValue.h" +#include "interpreter.h" +#include "npruntime_internal.h" +#include "runtime_object.h" +#include "types.h" +#include <assert.h> +#include <stdio.h> +#include <string.h> + + +#define LOG(formatAndArgs...) { \ + fprintf (stderr, "%s: ", __PRETTY_FUNCTION__); \ + fprintf(stderr, formatAndArgs); \ +} + + +// ------------------ NP Interface definition -------------------- +typedef struct +{ + NPObject object; + double doubleValue; + int intValue; + NPVariant stringValue; + bool boolValue; +} MyObject; + + +static bool identifiersInitialized = false; + +#define ID_DOUBLE_VALUE 0 +#define ID_INT_VALUE 1 +#define ID_STRING_VALUE 2 +#define ID_BOOLEAN_VALUE 3 +#define ID_NULL_VALUE 4 +#define ID_UNDEFINED_VALUE 5 +#define NUM_PROPERTY_IDENTIFIERS 6 + +static NPIdentifier myPropertyIdentifiers[NUM_PROPERTY_IDENTIFIERS]; +static const NPUTF8 *myPropertyIdentifierNames[NUM_PROPERTY_IDENTIFIERS] = { + "doubleValue", + "intValue", + "stringValue", + "booleanValue", + "nullValue", + "undefinedValue" +}; + +#define ID_LOG_MESSAGE 0 +#define ID_SET_DOUBLE_VALUE 1 +#define ID_SET_INT_VALUE 2 +#define ID_SET_STRING_VALUE 3 +#define ID_SET_BOOLEAN_VALUE 4 +#define ID_GET_DOUBLE_VALUE 5 +#define ID_GET_INT_VALUE 6 +#define ID_GET_STRING_VALUE 7 +#define ID_GET_BOOLEAN_VALUE 8 +#define NUM_METHOD_IDENTIFIERS 9 + +static NPIdentifier myMethodIdentifiers[NUM_METHOD_IDENTIFIERS]; +static const NPUTF8 *myMethodIdentifierNames[NUM_METHOD_IDENTIFIERS] = { + "logMessage", + "setDoubleValue", + "setIntValue", + "setStringValue", + "setBooleanValue", + "getDoubleValue", + "getIntValue", + "getStringValue", + "getBooleanValue" +}; + +static void initializeIdentifiers() +{ + NPN_GetStringIdentifiers (myPropertyIdentifierNames, NUM_PROPERTY_IDENTIFIERS, myPropertyIdentifiers); + NPN_GetStringIdentifiers (myMethodIdentifierNames, NUM_METHOD_IDENTIFIERS, myMethodIdentifiers); +}; + +bool myHasProperty (NPClass *theClass, NPIdentifier name) +{ + int i; + for (i = 0; i < NUM_PROPERTY_IDENTIFIERS; i++) { + if (name == myPropertyIdentifiers[i]){ + return true; + } + } + return false; +} + +bool myHasMethod (NPClass *theClass, NPIdentifier name) +{ + int i; + for (i = 0; i < NUM_METHOD_IDENTIFIERS; i++) { + if (name == myMethodIdentifiers[i]){ + return true; + } + } + return false; +} + + +void logMessage (const NPVariant *message) +{ + if (message->type == NPVariantStringType) { + char msgBuf[1024]; + strncpy (msgBuf, message->value.stringValue.UTF8Characters, message->value.stringValue.UTF8Length); + msgBuf[message->value.stringValue.UTF8Length] = 0; + printf ("%s\n", msgBuf); + } + else if (message->type == NPVariantDoubleType) + printf ("%f\n", (float)message->value.doubleValue); + else if (message->type == NPVariantInt32Type) + printf ("%d\n", message->value.intValue); + else if (message->type == NPVariantObjectType) + printf ("%p\n", message->value.objectValue); +} + +void setDoubleValue (MyObject *obj, const NPVariant *variant) +{ + if (!NPN_VariantToDouble (variant, &obj->doubleValue)) { + NPUTF8 *msg = "Attempt to set double value with invalid type."; + NPString aString; + aString.UTF8Characters = msg; + aString.UTF8Length = strlen (msg); + NPN_SetException ((NPObject *)obj, &aString); + } +} + +void setIntValue (MyObject *obj, const NPVariant *variant) +{ + if (!NPN_VariantToInt32 (variant, &obj->intValue)) { + NPUTF8 *msg = "Attempt to set int value with invalid type."; + NPString aString; + aString.UTF8Characters = msg; + aString.UTF8Length = strlen (msg); + NPN_SetException ((NPObject *)obj, &aString); + } +} + +void setStringValue (MyObject *obj, const NPVariant *variant) +{ + NPN_ReleaseVariantValue (&obj->stringValue); + NPN_InitializeVariantWithVariant (&obj->stringValue, variant); +} + +void setBooleanValue (MyObject *obj, const NPVariant *variant) +{ + if (!NPN_VariantToBool (variant, (NPBool *)&obj->boolValue)) { + NPUTF8 *msg = "Attempt to set bool value with invalid type."; + NPString aString; + aString.UTF8Characters = msg; + aString.UTF8Length = strlen (msg); + NPN_SetException ((NPObject *)obj, &aString); + } +} + +void getDoubleValue (MyObject *obj, NPVariant *variant) +{ + NPN_InitializeVariantWithDouble (variant, obj->doubleValue); +} + +void getIntValue (MyObject *obj, NPVariant *variant) +{ + NPN_InitializeVariantWithInt32 (variant, obj->intValue); +} + +void getStringValue (MyObject *obj, NPVariant *variant) +{ + NPN_InitializeVariantWithVariant (variant, &obj->stringValue); +} + +void getBooleanValue (MyObject *obj, NPVariant *variant) +{ + NPN_InitializeVariantWithBool (variant, obj->boolValue); +} + +void myGetProperty (MyObject *obj, NPIdentifier name, NPVariant *variant) +{ + if (name == myPropertyIdentifiers[ID_DOUBLE_VALUE]){ + getDoubleValue (obj, variant); + } + else if (name == myPropertyIdentifiers[ID_INT_VALUE]){ + getIntValue (obj, variant); + } + else if (name == myPropertyIdentifiers[ID_STRING_VALUE]){ + getStringValue (obj, variant); + } + else if (name == myPropertyIdentifiers[ID_BOOLEAN_VALUE]){ + getBooleanValue (obj, variant); + } + else if (name == myPropertyIdentifiers[ID_NULL_VALUE]){ + return NPN_InitializeVariantAsNull (variant); + } + else if (name == myPropertyIdentifiers[ID_UNDEFINED_VALUE]){ + return NPN_InitializeVariantAsUndefined (variant); + } + else + NPN_InitializeVariantAsUndefined(variant); +} + +void mySetProperty (MyObject *obj, NPIdentifier name, const NPVariant *variant) +{ + if (name == myPropertyIdentifiers[ID_DOUBLE_VALUE]) { + setDoubleValue (obj, variant); + } + else if (name == myPropertyIdentifiers[ID_INT_VALUE]) { + setIntValue (obj, variant); + } + else if (name == myPropertyIdentifiers[ID_STRING_VALUE]) { + setStringValue (obj, variant); + } + else if (name == myPropertyIdentifiers[ID_BOOLEAN_VALUE]) { + setBooleanValue (obj, variant); + } + else if (name == myPropertyIdentifiers[ID_NULL_VALUE]) { + // Do nothing! + } + else if (name == myPropertyIdentifiers[ID_UNDEFINED_VALUE]) { + // Do nothing! + } +} + +void myInvoke (MyObject *obj, NPIdentifier name, NPVariant *args, unsigned argCount, NPVariant *result) +{ + if (name == myMethodIdentifiers[ID_LOG_MESSAGE]) { + if (argCount == 1 && NPN_VariantIsString(&args[0])) + logMessage (&args[0]); + NPN_InitializeVariantAsVoid (result); + } + else if (name == myMethodIdentifiers[ID_SET_DOUBLE_VALUE]) { + if (argCount == 1 && NPN_VariantIsDouble (&args[0])) + setDoubleValue (obj, &args[0]); + NPN_InitializeVariantAsVoid (result); + } + else if (name == myMethodIdentifiers[ID_SET_INT_VALUE]) { + if (argCount == 1 && (NPN_VariantIsDouble (&args[0]) || NPN_VariantIsInt32 (&args[0]))) + setIntValue (obj, &args[0]); + NPN_InitializeVariantAsVoid (result); + } + else if (name == myMethodIdentifiers[ID_SET_STRING_VALUE]) { + if (argCount == 1 && NPN_VariantIsString (&args[0])) + setStringValue (obj, &args[0]); + NPN_InitializeVariantAsVoid (result); + } + else if (name == myMethodIdentifiers[ID_SET_BOOLEAN_VALUE]) { + if (argCount == 1 && NPN_VariantIsBool (&args[0])) + setBooleanValue (obj, &args[0]); + NPN_InitializeVariantAsVoid (result); + } + else if (name == myMethodIdentifiers[ID_GET_DOUBLE_VALUE]) { + getDoubleValue (obj, result); + } + else if (name == myMethodIdentifiers[ID_GET_INT_VALUE]) { + getIntValue (obj, result); + } + else if (name == myMethodIdentifiers[ID_GET_STRING_VALUE]) { + getStringValue (obj, result); + } + else if (name == myMethodIdentifiers[ID_GET_BOOLEAN_VALUE]) { + getBooleanValue (obj, result); + } + else + NPN_InitializeVariantAsUndefined (result); +} + +NPObject *myAllocate () +{ + MyObject *newInstance = (MyObject *)malloc (sizeof(MyObject)); + + if (!identifiersInitialized) { + identifiersInitialized = true; + initializeIdentifiers(); + } + + + newInstance->doubleValue = 666.666; + newInstance->intValue = 1234; + newInstance->boolValue = true; + newInstance->stringValue.type = NPVariantType_String; + newInstance->stringValue.value.stringValue.UTF8Length = strlen ("Hello world"); + newInstance->stringValue.value.stringValue.UTF8Characters = strdup ("Hello world"); + + return (NPObject *)newInstance; +} + +void myInvalidate () +{ + // Make sure we've released any remaining references to JavaScript objects. +} + +void myDeallocate (MyObject *obj) +{ + free ((void *)obj); +} + +static NPClass _myFunctionPtrs = { + kNPClassStructVersionCurrent, + (NPAllocateFunctionPtr) myAllocate, + (NPDeallocateFunctionPtr) myDeallocate, + (NPInvalidateFunctionPtr) myInvalidate, + (NPHasMethodFunctionPtr) myHasMethod, + (NPInvokeFunctionPtr) myInvoke, + (NPHasPropertyFunctionPtr) myHasProperty, + (NPGetPropertyFunctionPtr) myGetProperty, + (NPSetPropertyFunctionPtr) mySetProperty, +}; +static NPClass *myFunctionPtrs = &_myFunctionPtrs; + +// -------------------------------------------------------- + +using namespace JSC; +using namespace JSC::Bindings; + +class GlobalImp : public ObjectImp { +public: + virtual UString className() const { return "global"; } +}; + +#define BufferSize 200000 +static char code[BufferSize]; + +const char *readJavaScriptFromFile (const char *file) +{ + FILE *f = fopen(file, "r"); + if (!f) { + fprintf(stderr, "Error opening %s.\n", file); + return 0; + } + + int num = fread(code, 1, BufferSize, f); + code[num] = '\0'; + if(num >= BufferSize) + fprintf(stderr, "Warning: File may have been too long.\n"); + + fclose(f); + + return code; +} + +int main(int argc, char **argv) +{ + // expecting a filename + if (argc < 2) { + fprintf(stderr, "You have to specify at least one filename\n"); + return -1; + } + + bool ret = true; + { + JSLock lock; + + // create interpreter w/ global object + Object global(new GlobalImp()); + Interpreter interp; + interp.setGlobalObject(global); + ExecState *exec = interp.globalExec(); + + MyObject *myObject = (MyObject *)NPN_CreateObject (myFunctionPtrs); + + global.put(exec, Identifier("myInterface"), Instance::createRuntimeObject(Instance::CLanguage, (void *)myObject)); + + for (int i = 1; i < argc; i++) { + const char *code = readJavaScriptFromFile(argv[i]); + + if (code) { + // run + Completion comp(interp.evaluate(code)); + + if (comp.complType() == Throw) { + Value exVal = comp.value(); + char *msg = exVal.toString(exec).ascii(); + int lineno = -1; + if (exVal.type() == ObjectType) { + Value lineVal = Object::dynamicCast(exVal).get(exec,Identifier("line")); + if (lineVal.type() == NumberType) + lineno = int(lineVal.toNumber(exec)); + } + if (lineno != -1) + fprintf(stderr,"Exception, line %d: %s\n",lineno,msg); + else + fprintf(stderr,"Exception: %s\n",msg); + ret = false; + } + else if (comp.complType() == ReturnValue) { + char *msg = comp.value().toString(interp.globalExec()).ascii(); + fprintf(stderr,"Return value: %s\n",msg); + } + } + } + + NPN_ReleaseObject ((NPObject *)myObject); + + } // end block, so that Interpreter and global get deleted + + return ret ? 0 : 3; +} |