~centralelyon2010/inkscape/imagelinks2

« back to all changes in this revision

Viewing changes to src/dom/js/jsxdrapi.c

Committer: ishmal
Date: 2006-04-12 13:25:21 UTC
Revision ID: ishmal@users.sourceforge.net-20060412132521-5ynoezpwbzq4d1c3

Add new rearranged /dom directory

files added:
src/dom

src/dom/Makefile.mingw

src/dom/Makefile_insert

src/dom/charclass.cpp

src/dom/charclass.h

src/dom/css.h

src/dom/cssparser.cpp

src/dom/cssparser.h

src/dom/dom.h

src/dom/domimpl.cpp

src/dom/domimpl.h

src/dom/domstring.cpp

src/dom/domstring.h

src/dom/domstringimpl.h

src/dom/events.h

src/dom/io

src/dom/io/base64stream.cpp

src/dom/io/base64stream.h

src/dom/io/bufferstream.cpp

src/dom/io/bufferstream.h

src/dom/io/domstream.cpp

src/dom/io/domstream.h

src/dom/io/gzipstream.cpp

src/dom/io/gzipstream.h

src/dom/io/httpclient.cpp

src/dom/io/httpclient.h

src/dom/io/socket.cpp

src/dom/io/socket.h

src/dom/io/stringstream.cpp

src/dom/io/stringstream.h

src/dom/io/uristream.cpp

src/dom/io/uristream.h

src/dom/js

src/dom/js/fdlibm

src/dom/js/fdlibm/.cvsignore

src/dom/js/fdlibm/CVS

src/dom/js/fdlibm/CVS/Entries

src/dom/js/fdlibm/CVS/Repository

src/dom/js/fdlibm/CVS/Root

src/dom/js/fdlibm/CVS/Tag

src/dom/js/fdlibm/Makefile.in

src/dom/js/fdlibm/Makefile.ref

src/dom/js/fdlibm/e_acos.c

src/dom/js/fdlibm/e_acosh.c

src/dom/js/fdlibm/e_asin.c

src/dom/js/fdlibm/e_atan2.c

src/dom/js/fdlibm/e_atanh.c

src/dom/js/fdlibm/e_cosh.c

src/dom/js/fdlibm/e_exp.c

src/dom/js/fdlibm/e_fmod.c

src/dom/js/fdlibm/e_gamma.c

src/dom/js/fdlibm/e_gamma_r.c

src/dom/js/fdlibm/e_hypot.c

src/dom/js/fdlibm/e_j0.c

src/dom/js/fdlibm/e_j1.c

src/dom/js/fdlibm/e_jn.c

src/dom/js/fdlibm/e_lgamma.c

src/dom/js/fdlibm/e_lgamma_r.c

src/dom/js/fdlibm/e_log.c

src/dom/js/fdlibm/e_log10.c

src/dom/js/fdlibm/e_pow.c

src/dom/js/fdlibm/e_rem_pio2.c

src/dom/js/fdlibm/e_remainder.c

src/dom/js/fdlibm/e_scalb.c

src/dom/js/fdlibm/e_sinh.c

src/dom/js/fdlibm/e_sqrt.c

src/dom/js/fdlibm/fdlibm.h

src/dom/js/fdlibm/fdlibm.mak

src/dom/js/fdlibm/fdlibm.mdp

src/dom/js/fdlibm/k_cos.c

src/dom/js/fdlibm/k_rem_pio2.c

src/dom/js/fdlibm/k_sin.c

src/dom/js/fdlibm/k_standard.c

src/dom/js/fdlibm/k_tan.c

src/dom/js/fdlibm/s_asinh.c

src/dom/js/fdlibm/s_atan.c

src/dom/js/fdlibm/s_cbrt.c

src/dom/js/fdlibm/s_ceil.c

src/dom/js/fdlibm/s_copysign.c

src/dom/js/fdlibm/s_cos.c

src/dom/js/fdlibm/s_erf.c

src/dom/js/fdlibm/s_expm1.c

src/dom/js/fdlibm/s_fabs.c

src/dom/js/fdlibm/s_finite.c

src/dom/js/fdlibm/s_floor.c

src/dom/js/fdlibm/s_frexp.c

src/dom/js/fdlibm/s_ilogb.c

src/dom/js/fdlibm/s_isnan.c

src/dom/js/fdlibm/s_ldexp.c

src/dom/js/fdlibm/s_lib_version.c

src/dom/js/fdlibm/s_log1p.c

src/dom/js/fdlibm/s_logb.c

src/dom/js/fdlibm/s_matherr.c

src/dom/js/fdlibm/s_modf.c

src/dom/js/fdlibm/s_nextafter.c

src/dom/js/fdlibm/s_rint.c

src/dom/js/fdlibm/s_scalbn.c

src/dom/js/fdlibm/s_signgam.c

src/dom/js/fdlibm/s_significand.c

src/dom/js/fdlibm/s_sin.c

src/dom/js/fdlibm/s_tan.c

src/dom/js/fdlibm/s_tanh.c

src/dom/js/fdlibm/w_acos.c

src/dom/js/fdlibm/w_acosh.c

src/dom/js/fdlibm/w_asin.c

src/dom/js/fdlibm/w_atan2.c

src/dom/js/fdlibm/w_atanh.c

src/dom/js/fdlibm/w_cosh.c

src/dom/js/fdlibm/w_exp.c

src/dom/js/fdlibm/w_fmod.c

src/dom/js/fdlibm/w_gamma.c

src/dom/js/fdlibm/w_gamma_r.c

src/dom/js/fdlibm/w_hypot.c

src/dom/js/fdlibm/w_j0.c

src/dom/js/fdlibm/w_j1.c

src/dom/js/fdlibm/w_jn.c

src/dom/js/fdlibm/w_lgamma.c

src/dom/js/fdlibm/w_lgamma_r.c

src/dom/js/fdlibm/w_log.c

src/dom/js/fdlibm/w_log10.c

src/dom/js/fdlibm/w_pow.c

src/dom/js/fdlibm/w_remainder.c

src/dom/js/fdlibm/w_scalb.c

src/dom/js/fdlibm/w_sinh.c

src/dom/js/fdlibm/w_sqrt.c

src/dom/js/js.c

src/dom/js/js.mak

src/dom/js/js.msg

src/dom/js/jsapi.c

src/dom/js/jsapi.h

src/dom/js/jsarena.c

src/dom/js/jsarena.h

src/dom/js/jsarray.c

src/dom/js/jsarray.h

src/dom/js/jsatom.c

src/dom/js/jsatom.h

src/dom/js/jsbit.h

src/dom/js/jsbool.c

src/dom/js/jsbool.h

src/dom/js/jsclist.h

src/dom/js/jscntxt.c

src/dom/js/jscntxt.h

src/dom/js/jscompat.h

src/dom/js/jsconfig.h

src/dom/js/jsconfig.mk

src/dom/js/jscpucfg.c

src/dom/js/jscpucfg.h

src/dom/js/jsdate.c

src/dom/js/jsdate.h

src/dom/js/jsdbgapi.c

src/dom/js/jsdbgapi.h

src/dom/js/jsdhash.c

src/dom/js/jsdhash.h

src/dom/js/jsdtoa.c

src/dom/js/jsdtoa.h

src/dom/js/jsemit.c

src/dom/js/jsemit.h

src/dom/js/jsexn.c

src/dom/js/jsexn.h

src/dom/js/jsfile.c

src/dom/js/jsfile.h

src/dom/js/jsfile.msg

src/dom/js/jsfun.c

src/dom/js/jsfun.h

src/dom/js/jsgc.c

src/dom/js/jsgc.h

src/dom/js/jshash.c

src/dom/js/jshash.h

src/dom/js/jsinterp.c

src/dom/js/jsinterp.h

src/dom/js/jslibmath.h

src/dom/js/jslock.c

src/dom/js/jslock.h

src/dom/js/jslocko.asm

src/dom/js/jslog2.c

src/dom/js/jslong.c

src/dom/js/jslong.h

src/dom/js/jsmath.c

src/dom/js/jsmath.h

src/dom/js/jsnum.c

src/dom/js/jsnum.h

src/dom/js/jsobj.c

src/dom/js/jsobj.h

src/dom/js/jsopcode.c

src/dom/js/jsopcode.h

src/dom/js/jsopcode.tbl

src/dom/js/jsosdep.h

src/dom/js/jsotypes.h

src/dom/js/jsparse.c

src/dom/js/jsparse.h

src/dom/js/jsprf.c

src/dom/js/jsprf.h

src/dom/js/jsprvtd.h

src/dom/js/jspubtd.h

src/dom/js/jsregexp.c

src/dom/js/jsregexp.h

src/dom/js/jsscan.c

src/dom/js/jsscan.h

src/dom/js/jsscope.c

src/dom/js/jsscope.h

src/dom/js/jsscript.c

src/dom/js/jsscript.h

src/dom/js/jsshell.msg

src/dom/js/jsstddef.h

src/dom/js/jsstr.c

src/dom/js/jsstr.h

src/dom/js/jstypes.h

src/dom/js/jsutil.c

src/dom/js/jsutil.h

src/dom/js/jsxdrapi.c

src/dom/js/jsxdrapi.h

src/dom/js/prmjtime.c

src/dom/js/prmjtime.h

src/dom/js/resource.h

src/dom/ls.h

src/dom/lsimpl.cpp

src/dom/lsimpl.h

src/dom/mingwenv.bat

src/dom/minidom.cpp

src/dom/minidom.h

src/dom/odf

src/dom/odf/SvgOdg.cpp

src/dom/odf/odfdocument.cpp

src/dom/odf/odfdocument.h

src/dom/phoebedom.h

src/dom/prop-css.cpp

src/dom/prop-css2.cpp

src/dom/prop-svg.cpp

src/dom/smil.h

src/dom/smilimpl.cpp

src/dom/smilimpl.h

src/dom/stylesheets.h

src/dom/svg

src/dom/svg/svg.h

src/dom/svg/svg.idl

src/dom/svg/svgimpl.cpp

src/dom/svg/svgimpl.h

src/dom/svg/svglsimpl.cpp

src/dom/svg/svglsimpl.h

src/dom/svg/svgparser.cpp

src/dom/svg/svgparser.h

src/dom/svg/svgtypes.h

src/dom/traversal.h

src/dom/uri.cpp

src/dom/uri.h

src/dom/util

src/dom/util/thread.cpp

src/dom/util/thread.h

src/dom/util/ziptool.cpp

src/dom/util/ziptool.h

src/dom/views.h

src/dom/work

src/dom/work/001.css

src/dom/work/acid.css

src/dom/work/base.css

src/dom/work/css.idl

src/dom/work/cssprop.txt

src/dom/work/dom.idl

src/dom/work/events.idl

src/dom/work/inkscape.css

src/dom/work/ls.idl

src/dom/work/meyerweb.css

src/dom/work/prop-css.txt

src/dom/work/prop-svg.txt

src/dom/work/ranges.idl

src/dom/work/sandb1.css

src/dom/work/smil.idl

src/dom/work/stylesheets.idl

src/dom/work/testdom.cpp

src/dom/work/testhttp.cpp

src/dom/work/testodf.cpp

src/dom/work/testsvg.cpp

src/dom/work/testuri.cpp

src/dom/work/testxpath.cpp

src/dom/work/testzip.cpp

src/dom/work/traversal.idl

src/dom/work/views.idl

src/dom/work/xpath.idl

src/dom/work/xpathtests.cpp

src/dom/xmlreader.cpp

src/dom/xmlreader.h

src/dom/xmlwriter.cpp

src/dom/xmlwriter.h

src/dom/xpath.h

src/dom/xpathimpl.cpp

src/dom/xpathimpl.h

src/dom/xpathparser.cpp

src/dom/xpathparser.h

src/dom/xpathtoken.cpp

src/dom/xpathtoken.h

Show diffs side-by-side

added added

removed removed

src/dom/js/jsxdrapi.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-

* ***** BEGIN LICENSE BLOCK *****

* Version: MPL 1.1/GPL 2.0/LGPL 2.1

* The contents of this file are subject to the Mozilla Public License Version

* 1.1 (the "License"); you may not use this file except in compliance with

* the License. You may obtain a copy of the License at

* http://www.mozilla.org/MPL/

* Software distributed under the License is distributed on an "AS IS" basis,

* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

* for the specific language governing rights and limitations under the

* License.

* The Original Code is Mozilla Communicator client code, released

* March 31, 1998.

* The Initial Developer of the Original Code is

* Netscape Communications Corporation.

* Contributor(s):

* Alternatively, the contents of this file may be used under the terms of

* either of the GNU General Public License Version 2 or later (the "GPL"),

* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

* in which case the provisions of the GPL or the LGPL are applicable instead

* of those above. If you wish to allow use of your version of this file only

* under the terms of either the GPL or the LGPL, and not to allow others to

* use your version of this file under the terms of the MPL, indicate your

* decision by deleting the provisions above and replace them with the notice

* and other provisions required by the GPL or the LGPL. If you do not delete

* the provisions above, a recipient may use your version of this file under

* the terms of any one of the MPL, the GPL or the LGPL.

* ***** END LICENSE BLOCK ***** */

#include "jsstddef.h"

#include "jsconfig.h"

#if JS_HAS_XDR

#include <string.h>

#include "jstypes.h"

#include "jsutil.h" /* Added by JSIFY */

#include "jsdhash.h"

#include "jsprf.h"

#include "jsapi.h"

#include "jscntxt.h"

#include "jsnum.h"

#include "jsobj.h" /* js_XDRObject */

#include "jsscript.h" /* js_XDRScript */

#include "jsstr.h"

#include "jsxdrapi.h"

#ifdef DEBUG

#define DBG(x) x

#else

#define DBG(x) ((void)0)

#endif

typedef struct JSXDRMemState {

JSXDRState state;

char *base;

uint32 count;

uint32 limit;

} JSXDRMemState;

#define MEM_BLOCK 8192

#define MEM_PRIV(xdr) ((JSXDRMemState *)(xdr))

#define MEM_BASE(xdr) (MEM_PRIV(xdr)->base)

#define MEM_COUNT(xdr) (MEM_PRIV(xdr)->count)

#define MEM_LIMIT(xdr) (MEM_PRIV(xdr)->limit)

#define MEM_LEFT(xdr, bytes) \

JS_BEGIN_MACRO \

if ((xdr)->mode == JSXDR_DECODE && \

MEM_COUNT(xdr) + bytes > MEM_LIMIT(xdr)) { \

JS_ReportErrorNumber((xdr)->cx, js_GetErrorMessage, NULL, \

JSMSG_END_OF_DATA); \

return 0; \

} \

JS_END_MACRO

#define MEM_NEED(xdr, bytes) \

JS_BEGIN_MACRO \

if ((xdr)->mode == JSXDR_ENCODE) { \

if (MEM_LIMIT(xdr) && \

MEM_COUNT(xdr) + bytes > MEM_LIMIT(xdr)) { \

uint32 limit_ = JS_ROUNDUP(MEM_COUNT(xdr) + bytes, MEM_BLOCK);\

void *data_ = JS_realloc((xdr)->cx, MEM_BASE(xdr), limit_); \

if (!data_) \

return 0; \

MEM_BASE(xdr) = data_; \

MEM_LIMIT(xdr) = limit_; \

} \

} else { \

100

MEM_LEFT(xdr, bytes); \

101

} \

102

JS_END_MACRO

103

104

#define MEM_DATA(xdr) ((void *)(MEM_BASE(xdr) + MEM_COUNT(xdr)))

105

#define MEM_INCR(xdr,bytes) (MEM_COUNT(xdr) += (bytes))

106

107

static JSBool

108

mem_get32(JSXDRState *xdr, uint32 *lp)

109

{

110

MEM_LEFT(xdr, 4);

111

*lp = *(uint32 *)MEM_DATA(xdr);

112

MEM_INCR(xdr, 4);

113

return JS_TRUE;

114

}

115

116

static JSBool

117

mem_set32(JSXDRState *xdr, uint32 *lp)

118

{

119

MEM_NEED(xdr, 4);

120

*(uint32 *)MEM_DATA(xdr) = *lp;

121

MEM_INCR(xdr, 4);

122

return JS_TRUE;

123

}

124

125

static JSBool

126

mem_getbytes(JSXDRState *xdr, char *bytes, uint32 len)

127

{

128

MEM_LEFT(xdr, len);

129

memcpy(bytes, MEM_DATA(xdr), len);

130

MEM_INCR(xdr, len);

131

return JS_TRUE;

132

}

133

134

static JSBool

135

mem_setbytes(JSXDRState *xdr, char *bytes, uint32 len)

136

{

137

MEM_NEED(xdr, len);

138

memcpy(MEM_DATA(xdr), bytes, len);

139

MEM_INCR(xdr, len);

140

return JS_TRUE;

141

}

142

143

static void *

144

mem_raw(JSXDRState *xdr, uint32 len)

145

{

146

void *data;

147

if (xdr->mode == JSXDR_ENCODE) {

148

MEM_NEED(xdr, len);

149

} else if (xdr->mode == JSXDR_DECODE) {

150

MEM_LEFT(xdr, len);

151

}

152

data = MEM_DATA(xdr);

153

MEM_INCR(xdr, len);

154

return data;

155

}

156

157

static JSBool

158

mem_seek(JSXDRState *xdr, int32 offset, JSXDRWhence whence)

159

{

160

switch (whence) {

161

case JSXDR_SEEK_CUR:

162

if ((int32)MEM_COUNT(xdr) + offset < 0) {

163

JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,

164

JSMSG_SEEK_BEYOND_START);

165

return JS_FALSE;

166

}

167

if (offset > 0)

168

MEM_NEED(xdr, offset);

169

MEM_COUNT(xdr) += offset;

170

return JS_TRUE;

171

case JSXDR_SEEK_SET:

172

if (offset < 0) {

173

JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,

174

JSMSG_SEEK_BEYOND_START);

175

return JS_FALSE;

176

}

177

if (xdr->mode == JSXDR_ENCODE) {

178

if ((uint32)offset > MEM_COUNT(xdr))

179

MEM_NEED(xdr, offset - MEM_COUNT(xdr));

180

MEM_COUNT(xdr) = offset;

181

} else {

182

if ((uint32)offset > MEM_LIMIT(xdr)) {

183

JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,

184

JSMSG_SEEK_BEYOND_END);

185

return JS_FALSE;

186

}

187

MEM_COUNT(xdr) = offset;

188

}

189

return JS_TRUE;

190

case JSXDR_SEEK_END:

191

if (offset >= 0 ||

192

xdr->mode == JSXDR_ENCODE ||

193

(int32)MEM_LIMIT(xdr) + offset < 0) {

194

JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,

195

JSMSG_END_SEEK);

196

return JS_FALSE;

197

}

198

MEM_COUNT(xdr) = MEM_LIMIT(xdr) + offset;

199

return JS_TRUE;

200

default: {

201

char numBuf[12];

202

JS_snprintf(numBuf, sizeof numBuf, "%d", whence);

203

JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,

204

JSMSG_WHITHER_WHENCE, numBuf);

205

return JS_FALSE;

206

}

207

}

208

}

209

210

static uint32

211

mem_tell(JSXDRState *xdr)

212

{

213

return MEM_COUNT(xdr);

214

}

215

216

static void

217

mem_finalize(JSXDRState *xdr)

218

{

219

JS_free(xdr->cx, MEM_BASE(xdr));

220

}

221

222

static JSXDROps xdrmem_ops = {

223

mem_get32, mem_set32, mem_getbytes, mem_setbytes,

224

mem_raw, mem_seek, mem_tell, mem_finalize

225

};

226

227

JS_PUBLIC_API(void)

228

JS_XDRInitBase(JSXDRState *xdr, JSXDRMode mode, JSContext *cx)

229

{

230

xdr->mode = mode;

231

xdr->cx = cx;

232

xdr->registry = NULL;

233

xdr->numclasses = xdr->maxclasses = 0;

234

xdr->reghash = NULL;

235

xdr->userdata = NULL;

236

}

237

238

JS_PUBLIC_API(JSXDRState *)

239

JS_XDRNewMem(JSContext *cx, JSXDRMode mode)

240

{

241

JSXDRState *xdr = (JSXDRState *) JS_malloc(cx, sizeof(JSXDRMemState));

242

if (!xdr)

243

return NULL;

244

JS_XDRInitBase(xdr, mode, cx);

245

if (mode == JSXDR_ENCODE) {

246

if (!(MEM_BASE(xdr) = JS_malloc(cx, MEM_BLOCK))) {

247

JS_free(cx, xdr);

248

return NULL;

249

}

250

} else {

251

/* XXXbe ok, so better not deref MEM_BASE(xdr) if not ENCODE */

252

MEM_BASE(xdr) = NULL;

253

}

254

xdr->ops = &xdrmem_ops;

255

MEM_COUNT(xdr) = 0;

256

MEM_LIMIT(xdr) = MEM_BLOCK;

257

return xdr;

258

}

259

260

JS_PUBLIC_API(void *)

261

JS_XDRMemGetData(JSXDRState *xdr, uint32 *lp)

262

{

263

if (xdr->ops != &xdrmem_ops)

264

return NULL;

265

*lp = MEM_COUNT(xdr);

266

return MEM_BASE(xdr);

267

}

268

269

JS_PUBLIC_API(void)

270

JS_XDRMemSetData(JSXDRState *xdr, void *data, uint32 len)

271

{

272

if (xdr->ops != &xdrmem_ops)

273

return;

274

MEM_LIMIT(xdr) = len;

275

MEM_BASE(xdr) = data;

276

MEM_COUNT(xdr) = 0;

277

}

278

279

JS_PUBLIC_API(uint32)

280

JS_XDRMemDataLeft(JSXDRState *xdr)

281

{

282

if (xdr->ops != &xdrmem_ops)

283

return 0;

284

return MEM_LIMIT(xdr) - MEM_COUNT(xdr);

285

}

286

287

JS_PUBLIC_API(void)

288

JS_XDRMemResetData(JSXDRState *xdr)

289

{

290

if (xdr->ops != &xdrmem_ops)

291

return;

292

MEM_COUNT(xdr) = 0;

293

}

294

295

JS_PUBLIC_API(void)

296

JS_XDRDestroy(JSXDRState *xdr)

297

{

298

JSContext *cx = xdr->cx;

299

xdr->ops->finalize(xdr);

300

if (xdr->registry) {

301

JS_free(cx, xdr->registry);

302

if (xdr->reghash)

303

JS_DHashTableDestroy(xdr->reghash);

304

}

305

JS_free(cx, xdr);

306

}

307

308

JS_PUBLIC_API(JSBool)

309

JS_XDRUint8(JSXDRState *xdr, uint8 *b)

310

{

311

uint32 l = *b;

312

if (!JS_XDRUint32(xdr, &l))

313

return JS_FALSE;

314

*b = (uint8) l;

315

return JS_TRUE;

316

}

317

318

JS_PUBLIC_API(JSBool)

319

JS_XDRUint16(JSXDRState *xdr, uint16 *s)

320

{

321

uint32 l = *s;

322

if (!JS_XDRUint32(xdr, &l))

323

return JS_FALSE;

324

*s = (uint16) l;

325

return JS_TRUE;

326

}

327

328

JS_PUBLIC_API(JSBool)

329

JS_XDRUint32(JSXDRState *xdr, uint32 *lp)

330

{

331

JSBool ok = JS_TRUE;

332

if (xdr->mode == JSXDR_ENCODE) {

333

uint32 xl = JSXDR_SWAB32(*lp);

334

ok = xdr->ops->set32(xdr, &xl);

335

} else if (xdr->mode == JSXDR_DECODE) {

336

ok = xdr->ops->get32(xdr, lp);

337

*lp = JSXDR_SWAB32(*lp);

338

}

339

return ok;

340

}

341

342

JS_PUBLIC_API(JSBool)

343

JS_XDRBytes(JSXDRState *xdr, char *bytes, uint32 len)

344

{

345

uint32 padlen;

346

static char padbuf[JSXDR_ALIGN-1];

347

348

if (xdr->mode == JSXDR_ENCODE) {

349

if (!xdr->ops->setbytes(xdr, bytes, len))

350

return JS_FALSE;

351

} else {

352

if (!xdr->ops->getbytes(xdr, bytes, len))

353

return JS_FALSE;

354

}

355

len = xdr->ops->tell(xdr);

356

if (len % JSXDR_ALIGN) {

357

padlen = JSXDR_ALIGN - (len % JSXDR_ALIGN);

358

if (xdr->mode == JSXDR_ENCODE) {

359

if (!xdr->ops->setbytes(xdr, padbuf, padlen))

360

return JS_FALSE;

361

} else {

362

if (!xdr->ops->seek(xdr, padlen, JSXDR_SEEK_CUR))

363

return JS_FALSE;

364

}

365

}

366

return JS_TRUE;

367

}

368

369

/**

370

* Convert between a C string and the XDR representation:

371

* leading 32-bit count, then counted vector of chars,

372

* then possibly \0 padding to multiple of 4.

373

374

JS_PUBLIC_API(JSBool)

375

JS_XDRCString(JSXDRState *xdr, char **sp)

376

{

377

uint32 len;

378

379

if (xdr->mode == JSXDR_ENCODE)

380

len = strlen(*sp);

381

JS_XDRUint32(xdr, &len);

382

if (xdr->mode == JSXDR_DECODE) {

383

if (!(*sp = (char *) JS_malloc(xdr->cx, len + 1)))

384

return JS_FALSE;

385

}

386

if (!JS_XDRBytes(xdr, *sp, len)) {

387

if (xdr->mode == JSXDR_DECODE)

388

JS_free(xdr->cx, *sp);

389

return JS_FALSE;

390

}

391

if (xdr->mode == JSXDR_DECODE) {

392

(*sp)[len] = '\0';

393

} else if (xdr->mode == JSXDR_FREE) {

394

JS_free(xdr->cx, *sp);

395

*sp = NULL;

396

}

397

return JS_TRUE;

398

}

399

400

JS_PUBLIC_API(JSBool)

401

JS_XDRCStringOrNull(JSXDRState *xdr, char **sp)

402

{

403

uint32 null = (*sp == NULL);

404

if (!JS_XDRUint32(xdr, &null))

405

return JS_FALSE;

406

if (null) {

407

*sp = NULL;

408

return JS_TRUE;

409

}

410

return JS_XDRCString(xdr, sp);

411

}

412

413

414

* Convert between a JS (Unicode) string and the XDR representation.

415

416

JS_PUBLIC_API(JSBool)

417

JS_XDRString(JSXDRState *xdr, JSString **strp)

418

{

419

uint32 i, len, padlen, nbytes;

420

jschar *chars = NULL, *raw;

421

422

if (xdr->mode == JSXDR_ENCODE)

423

len = JSSTRING_LENGTH(*strp);

424

if (!JS_XDRUint32(xdr, &len))

425

return JS_FALSE;

426

nbytes = len * sizeof(jschar);

427

428

if (xdr->mode == JSXDR_DECODE) {

429

if (!(chars = (jschar *) JS_malloc(xdr->cx, nbytes + sizeof(jschar))))

430

return JS_FALSE;

431

} else {

432

chars = JSSTRING_CHARS(*strp);

433

}

434

435

padlen = nbytes % JSXDR_ALIGN;

436

if (padlen) {

437

padlen = JSXDR_ALIGN - padlen;

438

nbytes += padlen;

439

}

440

if (!(raw = (jschar *) xdr->ops->raw(xdr, nbytes)))

441

goto bad;

442

if (xdr->mode == JSXDR_ENCODE) {

443

for (i = 0; i < len; i++)

444

raw[i] = JSXDR_SWAB16(chars[i]);

445

if (padlen)

446

memset((char *)raw + nbytes - padlen, 0, padlen);

447

} else if (xdr->mode == JSXDR_DECODE) {

448

for (i = 0; i < len; i++)

449

chars[i] = JSXDR_SWAB16(raw[i]);

450

chars[len] = 0;

451

452

if (!(*strp = JS_NewUCString(xdr->cx, chars, len)))

453

goto bad;

454

}

455

return JS_TRUE;

456

457

bad:

458

if (xdr->mode == JSXDR_DECODE)

459

JS_free(xdr->cx, chars);

460

return JS_FALSE;

461

}

462

463

JS_PUBLIC_API(JSBool)

464

JS_XDRStringOrNull(JSXDRState *xdr, JSString **strp)

465

{

466

uint32 null = (*strp == NULL);

467

if (!JS_XDRUint32(xdr, &null))

468

return JS_FALSE;

469

if (null) {

470

*strp = NULL;

471

return JS_TRUE;

472

}

473

return JS_XDRString(xdr, strp);

474

}

475

476

JS_PUBLIC_API(JSBool)

477

JS_XDRDouble(JSXDRState *xdr, jsdouble **dp)

478

{

479

jsdpun u;

480

481

if (xdr->mode == JSXDR_ENCODE)

482

u.d = **dp;

483

if (!JS_XDRUint32(xdr, &u.s.lo) || !JS_XDRUint32(xdr, &u.s.hi))

484

return JS_FALSE;

485

if (xdr->mode == JSXDR_DECODE) {

486

*dp = JS_NewDouble(xdr->cx, u.d);

487

if (!*dp)

488

return JS_FALSE;

489

}

490

return JS_TRUE;

491

}

492

493

/* These are magic pseudo-tags: see jsapi.h, near the top, for real tags. */

494

#define JSVAL_XDRNULL 0x8

495

#define JSVAL_XDRVOID 0xA

496

497

JS_PUBLIC_API(JSBool)

498

JS_XDRValue(JSXDRState *xdr, jsval *vp)

499

{

500

uint32 type;

501

502

if (xdr->mode == JSXDR_ENCODE) {

503

if (JSVAL_IS_NULL(*vp))

504

type = JSVAL_XDRNULL;

505

else if (JSVAL_IS_VOID(*vp))

506

type = JSVAL_XDRVOID;

507

else

508

type = JSVAL_TAG(*vp);

509

}

510

if (!JS_XDRUint32(xdr, &type))

511

return JS_FALSE;

512

513

switch (type) {

514

case JSVAL_XDRNULL:

515

*vp = JSVAL_NULL;

516

break;

517

case JSVAL_XDRVOID:

518

*vp = JSVAL_VOID;

519

break;

520

case JSVAL_STRING: {

521

JSString *str;

522

if (xdr->mode == JSXDR_ENCODE)

523

str = JSVAL_TO_STRING(*vp);

524

if (!JS_XDRString(xdr, &str))

525

return JS_FALSE;

526

if (xdr->mode == JSXDR_DECODE)

527

*vp = STRING_TO_JSVAL(str);

528

break;

529

}

530

case JSVAL_DOUBLE: {

531

jsdouble *dp;

532

if (xdr->mode == JSXDR_ENCODE)

533

dp = JSVAL_TO_DOUBLE(*vp);

534

if (!JS_XDRDouble(xdr, &dp))

535

return JS_FALSE;

536

if (xdr->mode == JSXDR_DECODE)

537

*vp = DOUBLE_TO_JSVAL(dp);

538

break;

539

}

540

case JSVAL_OBJECT: {

541

JSObject *obj;

542

if (xdr->mode == JSXDR_ENCODE)

543

obj = JSVAL_TO_OBJECT(*vp);

544

if (!js_XDRObject(xdr, &obj))

545

return JS_FALSE;

546

if (xdr->mode == JSXDR_DECODE)

547

*vp = OBJECT_TO_JSVAL(obj);

548

break;

549

}

550

case JSVAL_BOOLEAN: {

551

uint32 b;

552

if (xdr->mode == JSXDR_ENCODE)

553

b = (uint32) JSVAL_TO_BOOLEAN(*vp);

554

if (!JS_XDRUint32(xdr, &b))

555

return JS_FALSE;

556

if (xdr->mode == JSXDR_DECODE)

557

*vp = BOOLEAN_TO_JSVAL((JSBool) b);

558

break;

559

}

560

default: {

561

uint32 i;

562

563

JS_ASSERT(type & JSVAL_INT);

564

if (xdr->mode == JSXDR_ENCODE)

565

i = (uint32) JSVAL_TO_INT(*vp);

566

if (!JS_XDRUint32(xdr, &i))

567

return JS_FALSE;

568

if (xdr->mode == JSXDR_DECODE)

569

*vp = INT_TO_JSVAL((int32) i);

570

break;

571

}

572

}

573

return JS_TRUE;

574

}

575

576

JS_PUBLIC_API(JSBool)

577

JS_XDRScript(JSXDRState *xdr, JSScript **scriptp)

578

{

579

if (!js_XDRScript(xdr, scriptp, NULL))

580

return JS_FALSE;

581

if (xdr->mode == JSXDR_DECODE)

582

js_CallNewScriptHook(xdr->cx, *scriptp, NULL);

583

return JS_TRUE;

584

}

585

586

#define CLASS_REGISTRY_MIN 8

587

#define CLASS_INDEX_TO_ID(i) ((i)+1)

588

#define CLASS_ID_TO_INDEX(id) ((id)-1)

589

590

typedef struct JSRegHashEntry {

591

JSDHashEntryHdr hdr;

592

const char *name;

593

uint32 index;

594

} JSRegHashEntry;

595

596

JS_PUBLIC_API(JSBool)

597

JS_XDRRegisterClass(JSXDRState *xdr, JSClass *clasp, uint32 *idp)

598

{

599

uintN numclasses, maxclasses;

600

JSClass **registry;

601

602

numclasses = xdr->numclasses;

603

maxclasses = xdr->maxclasses;

604

if (numclasses == maxclasses) {

605

maxclasses = (maxclasses == 0) ? CLASS_REGISTRY_MIN : maxclasses << 1;

606

registry = (JSClass **)

607

JS_realloc(xdr->cx, xdr->registry, maxclasses * sizeof(JSClass *));

608

if (!registry)

609

return JS_FALSE;

610

xdr->registry = registry;

611

xdr->maxclasses = maxclasses;

612

} else {

613

JS_ASSERT(numclasses && numclasses < maxclasses);

614

registry = xdr->registry;

615

}

616

617

registry[numclasses] = clasp;

618

if (xdr->reghash) {

619

JSRegHashEntry *entry = (JSRegHashEntry *)

620

JS_DHashTableOperate(xdr->reghash, clasp->name, JS_DHASH_ADD);

621

if (!entry) {

622

JS_ReportOutOfMemory(xdr->cx);

623

return JS_FALSE;

624

}

625

entry->name = clasp->name;

626

entry->index = numclasses;

627

}

628

*idp = CLASS_INDEX_TO_ID(numclasses);

629

xdr->numclasses = ++numclasses;

630

return JS_TRUE;

631

}

632

633

JS_PUBLIC_API(uint32)

634

JS_XDRFindClassIdByName(JSXDRState *xdr, const char *name)

635

{

636

uintN i, numclasses;

637

638

numclasses = xdr->numclasses;

639

if (numclasses >= 10) {

640

JSRegHashEntry *entry;

641

642

/* Bootstrap reghash from registry on first overpopulated Find. */

643

if (!xdr->reghash) {

644

xdr->reghash = JS_NewDHashTable(JS_DHashGetStubOps(), NULL,

645

sizeof(JSRegHashEntry),

646

numclasses);

647

if (xdr->reghash) {

648

for (i = 0; i < numclasses; i++) {

649

JSClass *clasp = xdr->registry[i];

650

entry = (JSRegHashEntry *)

651

JS_DHashTableOperate(xdr->reghash, clasp->name,

652

JS_DHASH_ADD);

653

entry->name = clasp->name;

654

entry->index = i;

655

}

656

}

657

}

658

659

/* If we managed to create reghash, use it for O(1) Find. */

660

if (xdr->reghash) {

661

entry = (JSRegHashEntry *)

662

JS_DHashTableOperate(xdr->reghash, name, JS_DHASH_LOOKUP);

663

if (JS_DHASH_ENTRY_IS_BUSY(&entry->hdr))

664

return CLASS_INDEX_TO_ID(entry->index);

665

}

666

}

667

668

/* Only a few classes, or we couldn't malloc reghash: use linear search. */

669

for (i = 0; i < numclasses; i++) {

670

if (!strcmp(name, xdr->registry[i]->name))

671

return CLASS_INDEX_TO_ID(i);

672

}

673

return 0;

674

}

675

676

JS_PUBLIC_API(JSClass *)

677

JS_XDRFindClassById(JSXDRState *xdr, uint32 id)

678

{

679

uintN i = CLASS_ID_TO_INDEX(id);

680

681

if (i >= xdr->numclasses)

682

return NULL;

683

return xdr->registry[i];

684

}

685

686

#endif /* JS_HAS_XDR */

Older »