src/dom/js/jsxdrapi.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Mozilla Communicator client code, released
  17  * March 31, 1998.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Netscape Communications Corporation.
  21  * Portions created by the Initial Developer are Copyright (C) 1998
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39 #include "jsstddef.h"
  40 #include "jsconfig.h"
  41
  42 #if JS_HAS_XDR
  43
  44 #include <string.h>
  45 #include "jstypes.h"
  46 #include "jsutil.h" /* Added by JSIFY */
  47 #include "jsdhash.h"
  48 #include "jsprf.h"
  49 #include "jsapi.h"
  50 #include "jscntxt.h"
  51 #include "jsobj.h"              /* js_XDRObject */
  52 #include "jsscript.h"           /* js_XDRScript */
  53 #include "jsstr.h"
  54 #include "jsxdrapi.h"
  55
  56 #ifdef DEBUG
  57 #define DBG(x) x
  58 #else
  59 #define DBG(x) ((void)0)
  60 #endif
  61
  62 typedef struct JSXDRMemState {
  63     JSXDRState  state;
  64     char        *base;
  65     uint32      count;
  66     uint32      limit;
  67 } JSXDRMemState;
  68
  69 #define MEM_BLOCK       8192
  70 #define MEM_PRIV(xdr)   ((JSXDRMemState *)(xdr))
  71
  72 #define MEM_BASE(xdr)   (MEM_PRIV(xdr)->base)
  73 #define MEM_COUNT(xdr)  (MEM_PRIV(xdr)->count)
  74 #define MEM_LIMIT(xdr)  (MEM_PRIV(xdr)->limit)
  75
  76 #define MEM_LEFT(xdr, bytes)                                                  \
  77     JS_BEGIN_MACRO                                                            \
  78         if ((xdr)->mode == JSXDR_DECODE &&                                    \
  79             MEM_COUNT(xdr) + bytes > MEM_LIMIT(xdr)) {                        \
  80             JS_ReportErrorNumber((xdr)->cx, js_GetErrorMessage, NULL,         \
  81                                  JSMSG_END_OF_DATA);                          \
  82             return 0;                                                         \
  83         }                                                                     \
  84     JS_END_MACRO
  85
  86 #define MEM_NEED(xdr, bytes)                                                  \
  87     JS_BEGIN_MACRO                                                            \
  88         if ((xdr)->mode == JSXDR_ENCODE) {                                    \
  89             if (MEM_LIMIT(xdr) &&                                             \
  90                 MEM_COUNT(xdr) + bytes > MEM_LIMIT(xdr)) {                    \
  91                 uint32 limit_ = JS_ROUNDUP(MEM_COUNT(xdr) + bytes, MEM_BLOCK);\
  92                 void *data_ = JS_realloc((xdr)->cx, MEM_BASE(xdr), limit_);   \
  93                 if (!data_)                                                   \
  94                     return 0;                                                 \
  95                 MEM_BASE(xdr) = data_;                                        \
  96                 MEM_LIMIT(xdr) = limit_;                                      \
  97             }                                                                 \
  98         } else {                                                              \
  99             MEM_LEFT(xdr, bytes);                                             \
 100         }                                                                     \
 101     JS_END_MACRO
 102
 103 #define MEM_DATA(xdr)        ((void *)(MEM_BASE(xdr) + MEM_COUNT(xdr)))
 104 #define MEM_INCR(xdr,bytes)  (MEM_COUNT(xdr) += (bytes))
 105
 106 static JSBool
 107 mem_get32(JSXDRState *xdr, uint32 *lp)
 108 {
 109     MEM_LEFT(xdr, 4);
 110     *lp = *(uint32 *)MEM_DATA(xdr);
 111     MEM_INCR(xdr, 4);
 112     return JS_TRUE;
 113 }
 114
 115 static JSBool
 116 mem_set32(JSXDRState *xdr, uint32 *lp)
 117 {
 118     MEM_NEED(xdr, 4);
 119     *(uint32 *)MEM_DATA(xdr) = *lp;
 120     MEM_INCR(xdr, 4);
 121     return JS_TRUE;
 122 }
 123
 124 static JSBool
 125 mem_getbytes(JSXDRState *xdr, char *bytes, uint32 len)
 126 {
 127     MEM_LEFT(xdr, len);
 128     memcpy(bytes, MEM_DATA(xdr), len);
 129     MEM_INCR(xdr, len);
 130     return JS_TRUE;
 131 }
 132
 133 static JSBool
 134 mem_setbytes(JSXDRState *xdr, char *bytes, uint32 len)
 135 {
 136     MEM_NEED(xdr, len);
 137     memcpy(MEM_DATA(xdr), bytes, len);
 138     MEM_INCR(xdr, len);
 139     return JS_TRUE;
 140 }
 141
 142 static void *
 143 mem_raw(JSXDRState *xdr, uint32 len)
 144 {
 145     void *data;
 146     if (xdr->mode == JSXDR_ENCODE) {
 147         MEM_NEED(xdr, len);
 148     } else if (xdr->mode == JSXDR_DECODE) {
 149         MEM_LEFT(xdr, len);
 150     }
 151     data = MEM_DATA(xdr);
 152     MEM_INCR(xdr, len);
 153     return data;
 154 }
 155
 156 static JSBool
 157 mem_seek(JSXDRState *xdr, int32 offset, JSXDRWhence whence)
 158 {
 159     switch (whence) {
 160       case JSXDR_SEEK_CUR:
 161         if ((int32)MEM_COUNT(xdr) + offset < 0) {
 162             JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 163                                  JSMSG_SEEK_BEYOND_START);
 164             return JS_FALSE;
 165         }
 166         if (offset > 0)
 167             MEM_NEED(xdr, offset);
 168         MEM_COUNT(xdr) += offset;
 169         return JS_TRUE;
 170       case JSXDR_SEEK_SET:
 171         if (offset < 0) {
 172             JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 173                                  JSMSG_SEEK_BEYOND_START);
 174             return JS_FALSE;
 175         }
 176         if (xdr->mode == JSXDR_ENCODE) {
 177             if ((uint32)offset > MEM_COUNT(xdr))
 178                 MEM_NEED(xdr, offset - MEM_COUNT(xdr));
 179             MEM_COUNT(xdr) = offset;
 180         } else {
 181             if ((uint32)offset > MEM_LIMIT(xdr)) {
 182                 JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 183                                      JSMSG_SEEK_BEYOND_END);
 184                 return JS_FALSE;
 185             }
 186             MEM_COUNT(xdr) = offset;
 187         }
 188         return JS_TRUE;
 189       case JSXDR_SEEK_END:
 190         if (offset >= 0 ||
 191             xdr->mode == JSXDR_ENCODE ||
 192             (int32)MEM_LIMIT(xdr) + offset < 0) {
 193             JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 194                                  JSMSG_END_SEEK);
 195             return JS_FALSE;
 196         }
 197         MEM_COUNT(xdr) = MEM_LIMIT(xdr) + offset;
 198         return JS_TRUE;
 199       default: {
 200         char numBuf[12];
 201         JS_snprintf(numBuf, sizeof numBuf, "%d", whence);
 202         JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 203                              JSMSG_WHITHER_WHENCE, numBuf);
 204         return JS_FALSE;
 205       }
 206     }
 207 }
 208
 209 static uint32
 210 mem_tell(JSXDRState *xdr)
 211 {
 212     return MEM_COUNT(xdr);
 213 }
 214
 215 static void
 216 mem_finalize(JSXDRState *xdr)
 217 {
 218     JS_free(xdr->cx, MEM_BASE(xdr));
 219 }
 220
 221 static JSXDROps xdrmem_ops = {
 222     mem_get32,      mem_set32,      mem_getbytes,   mem_setbytes,
 223     mem_raw,        mem_seek,       mem_tell,       mem_finalize
 224 };
 225
 226 JS_PUBLIC_API(void)
 227 JS_XDRInitBase(JSXDRState *xdr, JSXDRMode mode, JSContext *cx)
 228 {
 229     xdr->mode = mode;
 230     xdr->cx = cx;
 231     xdr->registry = NULL;
 232     xdr->numclasses = xdr->maxclasses = 0;
 233     xdr->reghash = NULL;
 234     xdr->userdata = NULL;
 235 }
 236
 237 JS_PUBLIC_API(JSXDRState *)
 238 JS_XDRNewMem(JSContext *cx, JSXDRMode mode)
 239 {
 240     JSXDRState *xdr = (JSXDRState *) JS_malloc(cx, sizeof(JSXDRMemState));
 241     if (!xdr)
 242         return NULL;
 243     JS_XDRInitBase(xdr, mode, cx);
 244     if (mode == JSXDR_ENCODE) {
 245         if (!(MEM_BASE(xdr) = JS_malloc(cx, MEM_BLOCK))) {
 246             JS_free(cx, xdr);
 247             return NULL;
 248         }
 249     } else {
 250         /* XXXbe ok, so better not deref MEM_BASE(xdr) if not ENCODE */
 251         MEM_BASE(xdr) = NULL;
 252     }
 253     xdr->ops = &xdrmem_ops;
 254     MEM_COUNT(xdr) = 0;
 255     MEM_LIMIT(xdr) = MEM_BLOCK;
 256     return xdr;
 257 }
 258
 259 JS_PUBLIC_API(void *)
 260 JS_XDRMemGetData(JSXDRState *xdr, uint32 *lp)
 261 {
 262     if (xdr->ops != &xdrmem_ops)
 263         return NULL;
 264     *lp = MEM_COUNT(xdr);
 265     return MEM_BASE(xdr);
 266 }
 267
 268 JS_PUBLIC_API(void)
 269 JS_XDRMemSetData(JSXDRState *xdr, void *data, uint32 len)
 270 {
 271     if (xdr->ops != &xdrmem_ops)
 272         return;
 273     MEM_LIMIT(xdr) = len;
 274     MEM_BASE(xdr) = data;
 275     MEM_COUNT(xdr) = 0;
 276 }
 277
 278 JS_PUBLIC_API(uint32)
 279 JS_XDRMemDataLeft(JSXDRState *xdr)
 280 {
 281     if (xdr->ops != &xdrmem_ops)
 282         return 0;
 283     return MEM_LIMIT(xdr) - MEM_COUNT(xdr);
 284 }
 285
 286 JS_PUBLIC_API(void)
 287 JS_XDRMemResetData(JSXDRState *xdr)
 288 {
 289     if (xdr->ops != &xdrmem_ops)
 290         return;
 291     MEM_COUNT(xdr) = 0;
 292 }
 293
 294 JS_PUBLIC_API(void)
 295 JS_XDRDestroy(JSXDRState *xdr)
 296 {
 297     JSContext *cx = xdr->cx;
 298     xdr->ops->finalize(xdr);
 299     if (xdr->registry) {
 300         JS_free(cx, xdr->registry);
 301         if (xdr->reghash)
 302             JS_DHashTableDestroy(xdr->reghash);
 303     }
 304     JS_free(cx, xdr);
 305 }
 306
 307 JS_PUBLIC_API(JSBool)
 308 JS_XDRUint8(JSXDRState *xdr, uint8 *b)
 309 {
 310     uint32 l = *b;
 311     if (!JS_XDRUint32(xdr, &l))
 312         return JS_FALSE;
 313     *b = (uint8) l;
 314     return JS_TRUE;
 315 }
 316
 317 JS_PUBLIC_API(JSBool)
 318 JS_XDRUint16(JSXDRState *xdr, uint16 *s)
 319 {
 320     uint32 l = *s;
 321     if (!JS_XDRUint32(xdr, &l))
 322         return JS_FALSE;
 323     *s = (uint16) l;
 324     return JS_TRUE;
 325 }
 326
 327 JS_PUBLIC_API(JSBool)
 328 JS_XDRUint32(JSXDRState *xdr, uint32 *lp)
 329 {
 330     JSBool ok = JS_TRUE;
 331     if (xdr->mode == JSXDR_ENCODE) {
 332         uint32 xl = JSXDR_SWAB32(*lp);
 333         ok = xdr->ops->set32(xdr, &xl);
 334     } else if (xdr->mode == JSXDR_DECODE) {
 335         ok = xdr->ops->get32(xdr, lp);
 336         *lp = JSXDR_SWAB32(*lp);
 337     }
 338     return ok;
 339 }
 340
 341 JS_PUBLIC_API(JSBool)
 342 JS_XDRBytes(JSXDRState *xdr, char *bytes, uint32 len)
 343 {
 344     uint32 padlen;
 345     static char padbuf[JSXDR_ALIGN-1];
 346
 347     if (xdr->mode == JSXDR_ENCODE) {
 348         if (!xdr->ops->setbytes(xdr, bytes, len))
 349             return JS_FALSE;
 350     } else {
 351         if (!xdr->ops->getbytes(xdr, bytes, len))
 352             return JS_FALSE;
 353     }
 354     len = xdr->ops->tell(xdr);
 355     if (len % JSXDR_ALIGN) {
 356         padlen = JSXDR_ALIGN - (len % JSXDR_ALIGN);
 357         if (xdr->mode == JSXDR_ENCODE) {
 358             if (!xdr->ops->setbytes(xdr, padbuf, padlen))
 359                 return JS_FALSE;
 360         } else {
 361             if (!xdr->ops->seek(xdr, padlen, JSXDR_SEEK_CUR))
 362                 return JS_FALSE;
 363         }
 364     }
 365     return JS_TRUE;
 366 }
 367
 368 /**
 369  * Convert between a C string and the XDR representation:
 370  * leading 32-bit count, then counted vector of chars,
 371  * then possibly \0 padding to multiple of 4.
 372  */
 373 JS_PUBLIC_API(JSBool)
 374 JS_XDRCString(JSXDRState *xdr, char **sp)
 375 {
 376     uint32 len;
 377
 378     if (xdr->mode == JSXDR_ENCODE)
 379         len = strlen(*sp);
 380     JS_XDRUint32(xdr, &len);
 381     if (xdr->mode == JSXDR_DECODE) {
 382         if (!(*sp = (char *) JS_malloc(xdr->cx, len + 1)))
 383             return JS_FALSE;
 384     }
 385     if (!JS_XDRBytes(xdr, *sp, len)) {
 386         if (xdr->mode == JSXDR_DECODE)
 387             JS_free(xdr->cx, *sp);
 388         return JS_FALSE;
 389     }
 390     if (xdr->mode == JSXDR_DECODE) {
 391         (*sp)[len] = '\0';
 392     } else if (xdr->mode == JSXDR_FREE) {
 393         JS_free(xdr->cx, *sp);
 394         *sp = NULL;
 395     }
 396     return JS_TRUE;
 397 }
 398
 399 JS_PUBLIC_API(JSBool)
 400 JS_XDRCStringOrNull(JSXDRState *xdr, char **sp)
 401 {
 402     uint32 null = (*sp == NULL);
 403     if (!JS_XDRUint32(xdr, &null))
 404         return JS_FALSE;
 405     if (null) {
 406         *sp = NULL;
 407         return JS_TRUE;
 408     }
 409     return JS_XDRCString(xdr, sp);
 410 }
 411
 412 /*
 413  * Convert between a JS (Unicode) string and the XDR representation.
 414  */
 415 JS_PUBLIC_API(JSBool)
 416 JS_XDRString(JSXDRState *xdr, JSString **strp)
 417 {
 418     uint32 i, len, padlen, nbytes;
 419     jschar *chars = NULL, *raw;
 420
 421     if (xdr->mode == JSXDR_ENCODE)
 422         len = JSSTRING_LENGTH(*strp);
 423     if (!JS_XDRUint32(xdr, &len))
 424         return JS_FALSE;
 425     nbytes = len * sizeof(jschar);
 426
 427     if (xdr->mode == JSXDR_DECODE) {
 428         if (!(chars = (jschar *) JS_malloc(xdr->cx, nbytes + sizeof(jschar))))
 429             return JS_FALSE;
 430     } else {
 431         chars = JSSTRING_CHARS(*strp);
 432     }
 433
 434     padlen = nbytes % JSXDR_ALIGN;
 435     if (padlen) {
 436         padlen = JSXDR_ALIGN - padlen;
 437         nbytes += padlen;
 438     }
 439     if (!(raw = (jschar *) xdr->ops->raw(xdr, nbytes)))
 440         goto bad;
 441     if (xdr->mode == JSXDR_ENCODE) {
 442         for (i = 0; i < len; i++)
 443             raw[i] = JSXDR_SWAB16(chars[i]);
 444         if (padlen)
 445             memset((char *)raw + nbytes - padlen, 0, padlen);
 446     } else if (xdr->mode == JSXDR_DECODE) {
 447         for (i = 0; i < len; i++)
 448             chars[i] = JSXDR_SWAB16(raw[i]);
 449         chars[len] = 0;
 450
 451         if (!(*strp = JS_NewUCString(xdr->cx, chars, len)))
 452             goto bad;
 453     }
 454     return JS_TRUE;
 455
 456 bad:
 457     if (xdr->mode == JSXDR_DECODE)
 458         JS_free(xdr->cx, chars);
 459     return JS_FALSE;
 460 }
 461
 462 JS_PUBLIC_API(JSBool)
 463 JS_XDRStringOrNull(JSXDRState *xdr, JSString **strp)
 464 {
 465     uint32 null = (*strp == NULL);
 466     if (!JS_XDRUint32(xdr, &null))
 467         return JS_FALSE;
 468     if (null) {
 469         *strp = NULL;
 470         return JS_TRUE;
 471     }
 472     return JS_XDRString(xdr, strp);
 473 }
 474
 475 JS_PUBLIC_API(JSBool)
 476 JS_XDRDouble(JSXDRState *xdr, jsdouble **dp)
 477 {
 478     jsdouble d;
 479     if (xdr->mode == JSXDR_ENCODE)
 480         d = **dp;
 481 #if IS_BIG_ENDIAN
 482     if (!JS_XDRUint32(xdr, (uint32 *)&d + 1) ||
 483         !JS_XDRUint32(xdr, (uint32 *)&d))
 484 #else
 485     if (!JS_XDRUint32(xdr, (uint32 *)&d) ||
 486         !JS_XDRUint32(xdr, (uint32 *)&d + 1))
 487 #endif
 488         return JS_FALSE;
 489     if (xdr->mode == JSXDR_DECODE) {
 490         *dp = JS_NewDouble(xdr->cx, d);
 491         if (!*dp)
 492             return JS_FALSE;
 493     }
 494     return JS_TRUE;
 495 }
 496
 497 /* These are magic pseudo-tags: see jsapi.h, near the top, for real tags. */
 498 #define JSVAL_XDRNULL   0x8
 499 #define JSVAL_XDRVOID   0xA
 500
 501 JS_PUBLIC_API(JSBool)
 502 JS_XDRValue(JSXDRState *xdr, jsval *vp)
 503 {
 504     uint32 type;
 505
 506     if (xdr->mode == JSXDR_ENCODE) {
 507         if (JSVAL_IS_NULL(*vp))
 508             type = JSVAL_XDRNULL;
 509         else if (JSVAL_IS_VOID(*vp))
 510             type = JSVAL_XDRVOID;
 511         else
 512             type = JSVAL_TAG(*vp);
 513     }
 514     if (!JS_XDRUint32(xdr, &type))
 515         return JS_FALSE;
 516
 517     switch (type) {
 518       case JSVAL_XDRNULL:
 519         *vp = JSVAL_NULL;
 520         break;
 521       case JSVAL_XDRVOID:
 522         *vp = JSVAL_VOID;
 523         break;
 524       case JSVAL_STRING: {
 525         JSString *str;
 526         if (xdr->mode == JSXDR_ENCODE)
 527             str = JSVAL_TO_STRING(*vp);
 528         if (!JS_XDRString(xdr, &str))
 529             return JS_FALSE;
 530         if (xdr->mode == JSXDR_DECODE)
 531             *vp = STRING_TO_JSVAL(str);
 532         break;
 533       }
 534       case JSVAL_DOUBLE: {
 535         jsdouble *dp;
 536         if (xdr->mode == JSXDR_ENCODE)
 537             dp = JSVAL_TO_DOUBLE(*vp);
 538         if (!JS_XDRDouble(xdr, &dp))
 539             return JS_FALSE;
 540         if (xdr->mode == JSXDR_DECODE)
 541             *vp = DOUBLE_TO_JSVAL(dp);
 542         break;
 543       }
 544       case JSVAL_OBJECT: {
 545         JSObject *obj;
 546         if (xdr->mode == JSXDR_ENCODE)
 547             obj = JSVAL_TO_OBJECT(*vp);
 548         if (!js_XDRObject(xdr, &obj))
 549             return JS_FALSE;
 550         if (xdr->mode == JSXDR_DECODE)
 551             *vp = OBJECT_TO_JSVAL(obj);
 552         break;
 553       }
 554       case JSVAL_BOOLEAN: {
 555         uint32 b;
 556         if (xdr->mode == JSXDR_ENCODE)
 557             b = (uint32) JSVAL_TO_BOOLEAN(*vp);
 558         if (!JS_XDRUint32(xdr, &b))
 559             return JS_FALSE;
 560         if (xdr->mode == JSXDR_DECODE)
 561             *vp = BOOLEAN_TO_JSVAL((JSBool) b);
 562         break;
 563       }
 564       default: {
 565         uint32 i;
 566
 567         JS_ASSERT(type & JSVAL_INT);
 568         if (xdr->mode == JSXDR_ENCODE)
 569             i = (uint32) JSVAL_TO_INT(*vp);
 570         if (!JS_XDRUint32(xdr, &i))
 571             return JS_FALSE;
 572         if (xdr->mode == JSXDR_DECODE)
 573             *vp = INT_TO_JSVAL((int32) i);
 574         break;
 575       }
 576     }
 577     return JS_TRUE;
 578 }
 579
 580 JS_PUBLIC_API(JSBool)
 581 JS_XDRScript(JSXDRState *xdr, JSScript **scriptp)
 582 {
 583     if (!js_XDRScript(xdr, scriptp, NULL))
 584         return JS_FALSE;
 585     if (xdr->mode == JSXDR_DECODE)
 586         js_CallNewScriptHook(xdr->cx, *scriptp, NULL);
 587     return JS_TRUE;
 588 }
 589
 590 #define CLASS_REGISTRY_MIN      8
 591 #define CLASS_INDEX_TO_ID(i)    ((i)+1)
 592 #define CLASS_ID_TO_INDEX(id)   ((id)-1)
 593
 594 typedef struct JSRegHashEntry {
 595     JSDHashEntryHdr hdr;
 596     const char      *name;
 597     uint32          index;
 598 } JSRegHashEntry;
 599
 600 JS_PUBLIC_API(JSBool)
 601 JS_XDRRegisterClass(JSXDRState *xdr, JSClass *clasp, uint32 *idp)
 602 {
 603     uintN numclasses, maxclasses;
 604     JSClass **registry;
 605
 606     numclasses = xdr->numclasses;
 607     maxclasses = xdr->maxclasses;
 608     if (numclasses == maxclasses) {
 609         maxclasses = (maxclasses == 0) ? CLASS_REGISTRY_MIN : maxclasses << 1;
 610         registry = (JSClass **)
 611             JS_realloc(xdr->cx, xdr->registry, maxclasses * sizeof(JSClass *));
 612         if (!registry)
 613             return JS_FALSE;
 614         xdr->registry = registry;
 615         xdr->maxclasses = maxclasses;
 616     } else {
 617         JS_ASSERT(numclasses && numclasses < maxclasses);
 618         registry = xdr->registry;
 619     }
 620
 621     registry[numclasses] = clasp;
 622     if (xdr->reghash) {
 623         JSRegHashEntry *entry = (JSRegHashEntry *)
 624             JS_DHashTableOperate(xdr->reghash, clasp->name, JS_DHASH_ADD);
 625         if (!entry) {
 626             JS_ReportOutOfMemory(xdr->cx);
 627             return JS_FALSE;
 628         }
 629         entry->name = clasp->name;
 630         entry->index = numclasses;
 631     }
 632     *idp = CLASS_INDEX_TO_ID(numclasses);
 633     xdr->numclasses = ++numclasses;
 634     return JS_TRUE;
 635 }
 636
 637 JS_PUBLIC_API(uint32)
 638 JS_XDRFindClassIdByName(JSXDRState *xdr, const char *name)
 639 {
 640     uintN i, numclasses;
 641
 642     numclasses = xdr->numclasses;
 643     if (numclasses >= 10) {
 644         JSRegHashEntry *entry;
 645
 646         /* Bootstrap reghash from registry on first overpopulated Find. */
 647         if (!xdr->reghash) {
 648             xdr->reghash = JS_NewDHashTable(JS_DHashGetStubOps(), NULL,
 649                                             sizeof(JSRegHashEntry),
 650                                             numclasses);
 651             if (xdr->reghash) {
 652                 for (i = 0; i < numclasses; i++) {
 653                     JSClass *clasp = xdr->registry[i];
 654                     entry = (JSRegHashEntry *)
 655                         JS_DHashTableOperate(xdr->reghash, clasp->name,
 656                                              JS_DHASH_ADD);
 657                     entry->name = clasp->name;
 658                     entry->index = i;
 659                 }
 660             }
 661         }
 662
 663         /* If we managed to create reghash, use it for O(1) Find. */
 664         if (xdr->reghash) {
 665             entry = (JSRegHashEntry *)
 666                 JS_DHashTableOperate(xdr->reghash, name, JS_DHASH_LOOKUP);
 667             if (JS_DHASH_ENTRY_IS_BUSY(&entry->hdr))
 668                 return CLASS_INDEX_TO_ID(entry->index);
 669         }
 670     }
 671
 672     /* Only a few classes, or we couldn't malloc reghash: use linear search. */
 673     for (i = 0; i < numclasses; i++) {
 674         if (!strcmp(name, xdr->registry[i]->name))
 675             return CLASS_INDEX_TO_ID(i);
 676     }
 677     return 0;
 678 }
 679
 680 JS_PUBLIC_API(JSClass *)
 681 JS_XDRFindClassById(JSXDRState *xdr, uint32 id)
 682 {
 683     uintN i = CLASS_ID_TO_INDEX(id);
 684
 685     if (i >= xdr->numclasses)
 686         return NULL;
 687     return xdr->registry[i];
 688 }
 689
 690 #endif /* JS_HAS_XDR */