js/src/liveconnect/jsj_JavaMember.c

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is Mozilla Communicator client code, released
  15  * March 31, 1998.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998-1999
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38  /* -*- Mode: C; tab-width: 8 -*-
  39  * Copyright (C) 1998-1999 Netscape Communications Corporation, All Rights Reserved.
  40  */
  41
  42 /*
  43  * This file is part of the Java-vendor-neutral implementation of LiveConnect
  44  *
  45  * It contains the native code implementation of JS's JavaMember class.
  46  * JavaMember's are a strange beast required only to handle the special case
  47  * of a public field and a public method that appear in the same class and
  48  * have the same name.  When such a field/method is used in Java, the compiler
  49  * can statically determine from context whether the field or the method is
  50  * being referenced, but that is not possible with JavaScript.  For example:
  51  *
  52  * ambiguousVal = javaObj.fieldOrMethod; // ambiguousVal is a JavaMember object
  53  * a = ambiguousVal();                   // ambiguousVal used as a method value
  54  * b = ambiguousVal + 4;                 // ambiguousVal used as a field value
  55  *
  56  * A JavaMember instance carries both the captured value of the Java field and
  57  * the method value until the context that the value is to be used in is known,
  58  * at which point conversion forces the use of one or the other.
  59  */
  60
  61 #include <stdlib.h>
  62 #include <string.h>
  63
  64 #include "jsj_private.h"      /* LiveConnect internals */
  65
  66 /* Private, native portion of a JavaMember */
  67 typedef struct JavaMethodOrFieldValue {
  68     jsval method_val;
  69     jsval field_val;
  70 } JavaMethodOrFieldValue;
  71
  72 JSObject *
  73 jsj_CreateJavaMember(JSContext *cx, jsval method_val, jsval field_val)
  74 {
  75     JavaMethodOrFieldValue *member_val;
  76     JSObject *JavaMember_obj;
  77
  78     member_val = (JavaMethodOrFieldValue *)JS_malloc(cx, sizeof(*member_val));
  79     if (!member_val)
  80         return NULL;
  81
  82     JavaMember_obj = JS_NewObject(cx, &JavaMember_class, 0, 0);
  83     if (!JavaMember_obj) {
  84         JS_free(cx, member_val);
  85         return NULL;
  86     }
  87
  88     member_val->method_val = method_val;
  89     member_val->field_val = field_val;
  90     JS_SetPrivate(cx, JavaMember_obj, (void *)member_val);
  91
  92     return JavaMember_obj;
  93 }
  94
  95 static void
  96 JavaMember_finalize(JSContext *cx, JSObject *obj)
  97 {
  98     JavaMethodOrFieldValue *member_val;
  99
 100     member_val = JS_GetPrivate(cx, obj);
 101     if (!member_val)
 102         return;
 103     JS_free(cx, member_val);
 104 }
 105
 106 static JSBool
 107 JavaMember_convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
 108 {
 109     JavaMethodOrFieldValue *member_val;
 110
 111     member_val = JS_GetPrivate(cx, obj);
 112     if (!member_val) {
 113         if (type == JSTYPE_OBJECT) {
 114             *vp = OBJECT_TO_JSVAL(obj);
 115             return JS_TRUE;
 116         }
 117
 118         JS_ReportError(cx, "illegal operation on JavaObject prototype object");
 119         return JS_FALSE;
 120     }
 121
 122     switch (type) {
 123     case JSTYPE_VOID:
 124     case JSTYPE_STRING:
 125     case JSTYPE_NUMBER:
 126     case JSTYPE_BOOLEAN:
 127     case JSTYPE_OBJECT:
 128         *vp = member_val->field_val;
 129         return JS_TRUE;
 130
 131     case JSTYPE_FUNCTION:
 132         *vp = member_val->method_val;
 133         return JS_TRUE;
 134
 135     default:
 136         JS_ASSERT(0);
 137         return JS_FALSE;
 138     }
 139 }
 140
 141 /*
 142  * This function exists only to make JavaMember's Call'able.  The way the JS
 143  * engine is written now, it's never actually called because when a JavaMember
 144  * is invoked, it's converted to a JS function via JavaMember_convert().
 145  */
 146 static JSBool
 147 JavaMember_Call(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
 148 {
 149     JS_ASSERT(0);
 150     return JS_TRUE;
 151 }
 152
 153 static void
 154 JavaMember_trace(JSTracer *trc, JSObject *obj)
 155 {
 156     JavaMethodOrFieldValue *member_val;
 157
 158     member_val = (JavaMethodOrFieldValue *)JS_GetPrivate(trc->context, obj);
 159     if (member_val) {
 160         JS_CALL_VALUE_TRACER(trc, member_val->method_val, "method_val");
 161         JS_CALL_VALUE_TRACER(trc, member_val->field_val, "field_val");
 162     }
 163 }
 164
 165 JSClass JavaMember_class = {
 166     "JavaMember", JSCLASS_HAS_PRIVATE | JSCLASS_MARK_IS_TRACE,
 167     JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
 168     JS_EnumerateStub, JS_ResolveStub,
 169     JavaMember_convert, JavaMember_finalize,
 170
 171     NULL, /* getObjectOps */
 172     NULL, /* checkAccess */
 173     JavaMember_Call,
 174     NULL, /* construct */
 175     NULL, /* xdrObject */
 176     NULL, /* hasInstance */
 177     JS_CLASS_TRACE(JavaMember_trace), /* mark/trace */
 178     0,    /* spare */
 179 };
 180
 181 JSBool
 182 jsj_init_JavaMember(JSContext *cx, JSObject *global_obj)
 183 {
 184     if (!JS_InitClass(cx, global_obj,
 185         0, &JavaMember_class, 0, 0,
 186         0, 0,
 187         0, 0))
 188         return JS_FALSE;
 189
 190     return JS_TRUE;
 191 }