[apple/javascriptcore.git] / bindings / objc / objc_utility.mm

/*
 * Copyright (C) 2004 Apple Computer, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "objc_utility.h"

#include "objc_instance.h"
#include "JSGlobalObject.h"
#include "runtime_array.h"
#include "runtime_object.h"
#include "WebScriptObject.h"
#include <wtf/Assertions.h>

#if !defined(_C_LNG_LNG)
#define _C_LNG_LNG 'q'
#endif

#if !defined(_C_ULNG_LNG)
#define _C_ULNG_LNG 'Q'
#endif

#if !defined(_C_CONST)
#define _C_CONST 'r'
#endif

#if !defined(_C_BYCOPY)
#define _C_BYCOPY 'O'
#endif

#if !defined(_C_BYREF)
#define _C_BYREF 'R'
#endif

#if !defined(_C_ONEWAY)
#define _C_ONEWAY 'V'
#endif

#if !defined(_C_GCINVISIBLE)
#define _C_GCINVISIBLE '!'
#endif

namespace KJS {
namespace Bindings {

/*
    By default, a JavaScript method name is produced by concatenating the 
    components of an ObjectiveC method name, replacing ':' with '_', and 
    escaping '_' and '$' with a leading '$', such that '_' becomes "$_" and 
    '$' becomes "$$". For example:

    ObjectiveC name         Default JavaScript name
        moveTo::                moveTo__
        moveTo_                 moveTo$_
        moveTo$_                moveTo$$$_

    This function performs the inverse of that operation.
 
    @result Fills 'buffer' with the ObjectiveC method name that corresponds to 'JSName'. 
            Returns true for success, false for failure. (Failure occurs when 'buffer' 
            is not big enough to hold the result.)
*/
bool convertJSMethodNameToObjc(const char *JSName, char *buffer, size_t bufferSize)
{
    ASSERT(JSName && buffer);
    
    const char *sp = JSName; // source pointer
    char *dp = buffer; // destination pointer
        
    char *end = buffer + bufferSize;
    while (dp < end) {
        if (*sp == '$') {
            ++sp;
            *dp = *sp;
        } else if (*sp == '_')
            *dp = ':';
        else
            *dp = *sp;

        // If a future coder puts funny ++ operators above, we might write off the end 
        // of the buffer in the middle of this loop. Let's make sure to check for that.
        ASSERT(dp < end);
        
        if (*sp == 0) { // We finished converting JSName
            ASSERT(strlen(JSName) < bufferSize);
            return true;
        }
        
        ++sp; 
        ++dp;
    }

    return false; // We ran out of buffer before converting JSName
}

/*

    JavaScript to   ObjC
    Number          coerced to char, short, int, long, float, double, or NSNumber, as appropriate
    String          NSString
    wrapper         id
    Object          WebScriptObject
    null            NSNull
    [], other       exception

*/
ObjcValue convertValueToObjcValue(ExecState *exec, JSValue *value, ObjcValueType type)
{
    ObjcValue result;
    double d = 0;

    if (value->isNumber() || value->isString() || value->isBoolean())
        d = value->toNumber(exec);

    switch (type) {
        case ObjcObjectType: {
            JSLock lock;
            
            JSGlobalObject *originGlobalObject = exec->dynamicGlobalObject();
            RootObject* originRootObject = findRootObject(originGlobalObject);

            JSGlobalObject* globalObject = 0;
            if (value->isObject() && static_cast<JSObject*>(value)->isGlobalObject())
                globalObject = static_cast<JSGlobalObject*>(value);

            if (!globalObject)
                globalObject = originGlobalObject;
                
            RootObject* rootObject = findRootObject(globalObject);
            result.objectValue =  rootObject
                ? [webScriptObjectClass() _convertValueToObjcValue:value originRootObject:originRootObject rootObject:rootObject]
                : nil;
        }
        break;

        case ObjcCharType:
        case ObjcUnsignedCharType:
            result.charValue = (char)d;
            break;
        case ObjcShortType:
        case ObjcUnsignedShortType:
            result.shortValue = (short)d;
            break;
        case ObjcIntType:
        case ObjcUnsignedIntType:
            result.intValue = (int)d;
            break;
        case ObjcLongType:
        case ObjcUnsignedLongType:
            result.longValue = (long)d;
            break;
        case ObjcLongLongType:
        case ObjcUnsignedLongLongType:
            result.longLongValue = (long long)d;
            break;
        case ObjcFloatType:
            result.floatValue = (float)d;
            break;
        case ObjcDoubleType:
            result.doubleValue = (double)d;
            break;
        case ObjcVoidType:
            bzero(&result, sizeof(ObjcValue));
            break;

        case ObjcInvalidType:
        default:
            // FIXME: throw an exception?
            break;
    }

    return result;
}

JSValue *convertNSStringToString(NSString *nsstring)
{
    JSLock lock;
    
    unichar *chars;
    unsigned int length = [nsstring length];
    chars = (unichar *)malloc(sizeof(unichar)*length);
    [nsstring getCharacters:chars];
    UString u((const UChar*)chars, length);
    JSValue *aValue = jsString(u);
    free((void *)chars);
    return aValue;
}

/*
    ObjC      to    JavaScript
    ----            ----------
    char            number
    short           number
    int             number
    long            number
    float           number
    double          number
    NSNumber        boolean or number
    NSString        string
    NSArray         array
    NSNull          null
    WebScriptObject underlying JavaScript object
    WebUndefined    undefined
    id              object wrapper
    other           should not happen
*/
JSValue* convertObjcValueToValue(ExecState* exec, void* buffer, ObjcValueType type, RootObject* rootObject)
{
    JSLock lock;
    
    switch (type) {
        case ObjcObjectType: {
            id obj = *(id*)buffer;
            if ([obj isKindOfClass:[NSString class]])
                return convertNSStringToString((NSString *)obj);
            if ([obj isKindOfClass:webUndefinedClass()])
                return jsUndefined();
            if ((CFBooleanRef)obj == kCFBooleanTrue)
                return jsBoolean(true);
            if ((CFBooleanRef)obj == kCFBooleanFalse)
                return jsBoolean(false);
            if ([obj isKindOfClass:[NSNumber class]])
                return jsNumber([obj doubleValue]);
            if ([obj isKindOfClass:[NSArray class]])
                return new RuntimeArray(exec, new ObjcArray(obj, rootObject));
            if ([obj isKindOfClass:webScriptObjectClass()]) {
                JSObject* imp = [obj _imp];
                return imp ? imp : jsUndefined();
            }
            if ([obj isKindOfClass:[NSNull class]])
                return jsNull();
            if (obj == 0)
                return jsUndefined();
            return Instance::createRuntimeObject(Instance::ObjectiveCLanguage, obj, rootObject);
        }
        case ObjcCharType:
            return jsNumber(*(char *)buffer);
        case ObjcUnsignedCharType:
            return jsNumber(*(unsigned char *)buffer);
        case ObjcShortType:
            return jsNumber(*(short *)buffer);
        case ObjcUnsignedShortType:
            return jsNumber(*(unsigned short *)buffer);
        case ObjcIntType:
            return jsNumber(*(int *)buffer);
        case ObjcUnsignedIntType:
            return jsNumber(*(unsigned int *)buffer);
        case ObjcLongType:
            return jsNumber(*(long *)buffer);
        case ObjcUnsignedLongType:
            return jsNumber(*(unsigned long *)buffer);
        case ObjcLongLongType:
            return jsNumber(*(long long *)buffer);
        case ObjcUnsignedLongLongType:
            return jsNumber(*(unsigned long long *)buffer);
        case ObjcFloatType:
            return jsNumber(*(float *)buffer);
        case ObjcDoubleType:
            return jsNumber(*(double *)buffer);
        default:
            // Should never get here. Argument types are filtered.
            fprintf(stderr, "%s: invalid type (%d)\n", __PRETTY_FUNCTION__, (int)type);
            ASSERT(false);
    }
    
    return 0;
}

ObjcValueType objcValueTypeForType(const char *type)
{
    int typeLength = strlen(type);
    ObjcValueType objcValueType = ObjcInvalidType;

    for (int i = 0; i < typeLength; ++i) {
        char typeChar = type[i];
        switch (typeChar) {
            case _C_CONST:
            case _C_BYCOPY:
            case _C_BYREF:
            case _C_ONEWAY:
            case _C_GCINVISIBLE:
                // skip these type modifiers
                break;
            case _C_ID:
                objcValueType = ObjcObjectType;
                break;
            case _C_CHR:
                objcValueType = ObjcCharType;
                break;
            case _C_UCHR:
                objcValueType = ObjcUnsignedCharType;
                break;
            case _C_SHT:
                objcValueType = ObjcShortType;
                break;
            case _C_USHT:
                objcValueType = ObjcUnsignedShortType;
                break;
            case _C_INT:
                objcValueType = ObjcIntType;
                break;
            case _C_UINT:
                objcValueType = ObjcUnsignedIntType;
                break;
            case _C_LNG:
                objcValueType = ObjcLongType;
                break;
            case _C_ULNG:
                objcValueType = ObjcUnsignedLongType;
                break;
            case _C_LNG_LNG:
                objcValueType = ObjcLongLongType;
                break;
            case _C_ULNG_LNG:
                objcValueType = ObjcUnsignedLongLongType;
                break;
            case _C_FLT:
                objcValueType = ObjcFloatType;
                break;
            case _C_DBL:
                objcValueType = ObjcDoubleType;
                break;
            case _C_VOID:
                objcValueType = ObjcVoidType;
                break;
            default:
                // Unhandled type. We don't handle C structs, unions, etc.
                // FIXME: throw an exception?
                ASSERT(false);
        }

        if (objcValueType != ObjcInvalidType)
            break;
    }

    return objcValueType;
}

JSObject *throwError(ExecState *exec, ErrorType type, NSString *message)
{
    ASSERT(message);
    size_t length = [message length];
    unichar *buffer = new unichar[length];
    [message getCharacters:buffer];
    JSObject *error = throwError(exec, type, UString(reinterpret_cast<UChar *>(buffer), length));
    delete [] buffer;
    return error;
}

}
}
Commit	Line	Data
b37bf2e1 A	1	/*
	2	* Copyright (C) 2004 Apple Computer, Inc. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	#include "config.h"
	27	#include "objc_utility.h"
	28
	29	#include "objc_instance.h"
	30	#include "JSGlobalObject.h"
	31	#include "runtime_array.h"
	32	#include "runtime_object.h"
	33	#include "WebScriptObject.h"
	34	#include <wtf/Assertions.h>
	35
	36	#if !defined(_C_LNG_LNG)
	37	#define _C_LNG_LNG 'q'
	38	#endif
	39
	40	#if !defined(_C_ULNG_LNG)
	41	#define _C_ULNG_LNG 'Q'
	42	#endif
	43
	44	#if !defined(_C_CONST)
	45	#define _C_CONST 'r'
	46	#endif
	47
	48	#if !defined(_C_BYCOPY)
	49	#define _C_BYCOPY 'O'
	50	#endif
	51
	52	#if !defined(_C_BYREF)
	53	#define _C_BYREF 'R'
	54	#endif
	55
	56	#if !defined(_C_ONEWAY)
	57	#define _C_ONEWAY 'V'
	58	#endif
	59
	60	#if !defined(_C_GCINVISIBLE)
	61	#define _C_GCINVISIBLE '!'
	62	#endif
	63
	64	namespace KJS {
65	namespace Bindings {
66
67	/*
68	By default, a JavaScript method name is produced by concatenating the
69	components of an ObjectiveC method name, replacing ':' with '_', and
70	escaping '_' and '$' with a leading '$', such that '_' becomes "$_" and
71	'$' becomes "$$". For example:
72
73	ObjectiveC name Default JavaScript name
74	moveTo:: moveTo__
75	moveTo_ moveTo$_
76	moveTo$_ moveTo$$$_
77
78	This function performs the inverse of that operation.
79
80	@result Fills 'buffer' with the ObjectiveC method name that corresponds to 'JSName'.
81	Returns true for success, false for failure. (Failure occurs when 'buffer'
82	is not big enough to hold the result.)
83	*/
84	bool convertJSMethodNameToObjc(const char JSName, char buffer, size_t bufferSize)
85	{
86	ASSERT(JSName && buffer);
87
88	const char *sp = JSName; // source pointer
89	char *dp = buffer; // destination pointer
90
91	char *end = buffer + bufferSize;
92	while (dp < end) {
93	if (*sp == '$') {
94	++sp;
95	dp = sp;
96	} else if (*sp == '_')
97	*dp = ':';
98	else
99	dp = sp;
100
101	// If a future coder puts funny ++ operators above, we might write off the end
102	// of the buffer in the middle of this loop. Let's make sure to check for that.
103	ASSERT(dp < end);
104
105	if (*sp == 0) { // We finished converting JSName
106	ASSERT(strlen(JSName) < bufferSize);
107	return true;
108	}
109
110	++sp;
111	++dp;
112	}
113
114	return false; // We ran out of buffer before converting JSName
115	}
116
117	/*
118
119	JavaScript to ObjC
120	Number coerced to char, short, int, long, float, double, or NSNumber, as appropriate
121	String NSString
122	wrapper id
123	Object WebScriptObject
124	null NSNull
125	[], other exception
126
127	*/
128	ObjcValue convertValueToObjcValue(ExecState exec, JSValue value, ObjcValueType type)
129	{
130	ObjcValue result;
131	double d = 0;
132
133	if (value->isNumber() \|\| value->isString() \|\| value->isBoolean())
134	d = value->toNumber(exec);
135
136	switch (type) {
137	case ObjcObjectType: {
138	JSLock lock;
139
140	JSGlobalObject *originGlobalObject = exec->dynamicGlobalObject();
141	RootObject* originRootObject = findRootObject(originGlobalObject);
142
143	JSGlobalObject* globalObject = 0;
144	if (value->isObject() && static_cast<JSObject*>(value)->isGlobalObject())
145	globalObject = static_cast<JSGlobalObject*>(value);
146
147	if (!globalObject)
148	globalObject = originGlobalObject;
149
150	RootObject* rootObject = findRootObject(globalObject);
151	result.objectValue = rootObject
152	? [webScriptObjectClass() _convertValueToObjcValue:value originRootObject:originRootObject rootObject:rootObject]
153	: nil;
154	}
155	break;
156
157	case ObjcCharType:
158	case ObjcUnsignedCharType:
159	result.charValue = (char)d;
160	break;
161	case ObjcShortType:
162	case ObjcUnsignedShortType:
163	result.shortValue = (short)d;
164	break;
165	case ObjcIntType:
166	case ObjcUnsignedIntType:
167	result.intValue = (int)d;
168	break;
169	case ObjcLongType:
170	case ObjcUnsignedLongType:
171	result.longValue = (long)d;
172	break;
173	case ObjcLongLongType:
174	case ObjcUnsignedLongLongType:
175	result.longLongValue = (long long)d;
176	break;
177	case ObjcFloatType:
178	result.floatValue = (float)d;
179	break;
180	case ObjcDoubleType:
181	result.doubleValue = (double)d;
182	break;
183	case ObjcVoidType:
184	bzero(&result, sizeof(ObjcValue));
185	break;
186
187	case ObjcInvalidType:
188	default:
189	// FIXME: throw an exception?
190	break;
191	}
192
193	return result;
194	}
195
196	JSValue convertNSStringToString(NSString nsstring)
197	{
198	JSLock lock;
199
200	unichar *chars;
201	unsigned int length = [nsstring length];
202	chars = (unichar )malloc(sizeof(unichar)length);
203	[nsstring getCharacters:chars];
204	UString u((const UChar*)chars, length);
205	JSValue *aValue = jsString(u);
206	free((void *)chars);
207	return aValue;
208	}
209
210	/*
211	ObjC to JavaScript
212	---- ----------
213	char number
214	short number
215	int number
216	long number
217	float number
218	double number
219	NSNumber boolean or number
220	NSString string
221	NSArray array
222	NSNull null
223	WebScriptObject underlying JavaScript object
224	WebUndefined undefined
225	id object wrapper
226	other should not happen
227	*/
228	JSValue* convertObjcValueToValue(ExecState* exec, void* buffer, ObjcValueType type, RootObject* rootObject)
229	{
230	JSLock lock;
231
232	switch (type) {
233	case ObjcObjectType: {
234	id obj = (id)buffer;
235	if ([obj isKindOfClass:[NSString class]])
236	return convertNSStringToString((NSString *)obj);
237	if ([obj isKindOfClass:webUndefinedClass()])
238	return jsUndefined();
239	if ((CFBooleanRef)obj == kCFBooleanTrue)
240	return jsBoolean(true);
241	if ((CFBooleanRef)obj == kCFBooleanFalse)
242	return jsBoolean(false);
243	if ([obj isKindOfClass:[NSNumber class]])
244	return jsNumber([obj doubleValue]);
245	if ([obj isKindOfClass:[NSArray class]])
246	return new RuntimeArray(exec, new ObjcArray(obj, rootObject));
247	if ([obj isKindOfClass:webScriptObjectClass()]) {
248	JSObject* imp = [obj _imp];
249	return imp ? imp : jsUndefined();
250	}
251	if ([obj isKindOfClass:[NSNull class]])
252	return jsNull();
253	if (obj == 0)
254	return jsUndefined();
255	return Instance::createRuntimeObject(Instance::ObjectiveCLanguage, obj, rootObject);
256	}
257	case ObjcCharType:
258	return jsNumber((char )buffer);
259	case ObjcUnsignedCharType:
260	return jsNumber((unsigned char )buffer);
261	case ObjcShortType:
262	return jsNumber((short )buffer);
263	case ObjcUnsignedShortType:
264	return jsNumber((unsigned short )buffer);
265	case ObjcIntType:
266	return jsNumber((int )buffer);
267	case ObjcUnsignedIntType:
268	return jsNumber((unsigned int )buffer);
269	case ObjcLongType:
270	return jsNumber((long )buffer);
271	case ObjcUnsignedLongType:
272	return jsNumber((unsigned long )buffer);
273	case ObjcLongLongType:
274	return jsNumber((long long )buffer);
275	case ObjcUnsignedLongLongType:
276	return jsNumber((unsigned long long )buffer);
277	case ObjcFloatType:
278	return jsNumber((float )buffer);
279	case ObjcDoubleType:
280	return jsNumber((double )buffer);
281	default:
282	// Should never get here. Argument types are filtered.
283	fprintf(stderr, "%s: invalid type (%d)\n", __PRETTY_FUNCTION__, (int)type);
284	ASSERT(false);
285	}
286
287	return 0;
288	}
289
290	ObjcValueType objcValueTypeForType(const char *type)
291	{
292	int typeLength = strlen(type);
293	ObjcValueType objcValueType = ObjcInvalidType;
294
295	for (int i = 0; i < typeLength; ++i) {
296	char typeChar = type[i];
297	switch (typeChar) {
298	case _C_CONST:
299	case _C_BYCOPY:
300	case _C_BYREF:
301	case _C_ONEWAY:
302	case _C_GCINVISIBLE:
303	// skip these type modifiers
304	break;
305	case _C_ID:
306	objcValueType = ObjcObjectType;
307	break;
308	case _C_CHR:
309	objcValueType = ObjcCharType;
310	break;
311	case _C_UCHR:
312	objcValueType = ObjcUnsignedCharType;
313	break;
314	case _C_SHT:
315	objcValueType = ObjcShortType;
316	break;
317	case _C_USHT:
318	objcValueType = ObjcUnsignedShortType;
319	break;
320	case _C_INT:
321	objcValueType = ObjcIntType;
322	break;
323	case _C_UINT:
324	objcValueType = ObjcUnsignedIntType;
325	break;
326	case _C_LNG:
327	objcValueType = ObjcLongType;
328	break;
329	case _C_ULNG:
330	objcValueType = ObjcUnsignedLongType;
331	break;
332	case _C_LNG_LNG:
333	objcValueType = ObjcLongLongType;
334	break;
335	case _C_ULNG_LNG:
336	objcValueType = ObjcUnsignedLongLongType;
337	break;
338	case _C_FLT:
339	objcValueType = ObjcFloatType;
340	break;
341	case _C_DBL:
342	objcValueType = ObjcDoubleType;
343	break;
344	case _C_VOID:
345	objcValueType = ObjcVoidType;
346	break;
347	default:
348	// Unhandled type. We don't handle C structs, unions, etc.
349	// FIXME: throw an exception?
350	ASSERT(false);
351	}
352
353	if (objcValueType != ObjcInvalidType)
354	break;
355	}
356
357	return objcValueType;
358	}
359
360	JSObject throwError(ExecState exec, ErrorType type, NSString *message)
361	{
362	ASSERT(message);
363	size_t length = [message length];
364	unichar *buffer = new unichar[length];
365	[message getCharacters:buffer];
366	JSObject error = throwError(exec, type, UString(reinterpret_cast<UChar >(buffer), length));
367	delete [] buffer;
368	return error;
369	}
370
371	}
372	}