The source code to the JavaScript Interpreter supplied herewith has been changed as follows on or prior to August 8, 2005:

Comparing file \macbuild\JavaSession\Javasession.cpp

\macbuild\JavaSession\Javasession.cpp
Code changed at line: 13,14d13

< #include "DW_decls.h"
<

Comparing file \macbuild\JavaSession\prmacos.cpp

\macbuild\JavaSession\Javasession.cpp
Code changed at line: 44,45d44

< #include "DW_decls.h"
<

Comparing file \jsapi.c

\jsapi.c
Code changed at line: 96a96,101

> // DREAMWEAVER - add these macros so on windows we get line numbers on memory leaks
> #if defined(XP_WIN) && defined (_DEBUG) //for debug builds only
> #define _CRTDBG_MAP_ALLOC
> #include <crtdbg.h>
> #endif
>

\jsapi.c
Code changed at line: 126a132,138

> // DREAMWEAVER added this function
> JS_PUBLIC_API(JSBool)
> JS_DoubleIsNaN(jsdouble n)
> {
> return JSDOUBLE_IS_NaN(n);
> }
>

\jsapi.c
Code changed at line: 1721a1734,1751

> // DREAMWEAVER added this function. Note, if the JS engine was
> // compiled without TOO_MUCH_GC defined, then this function does
> // nothing.
> JS_PUBLIC_API(void)
> JS_EnableTooMuchGC(JSContext *cx)
> {
> js_EnableTooMuchGC(cx);
> }
>
> // DREAMWEAVER added this function. Note, if the JS engine was
> // compiled without TOO_MUCH_GC defined, then this function does
> // nothing.
> JS_PUBLIC_API(void)
> JS_DisableTooMuchGC(JSContext *cx)
> {
> js_DisableTooMuchGC(cx);
> }
>

\jsapi.c
Code changed at line: 2371a2402,2543

> /* DREAMWEAVER jschang, Macromedia - (formerly JS_AliasElement)
> * JS_AliasElementToProperty assigns the array element so that it is an
> * alias to the named property. I changed the name so that it is more
> * descriptive and because I needed to add the function
> * JS_AliasPropertyToElement.
> *
> * HACK snewman 3/22/01: this seems to be a function we added back in the JS
> * 1.2 days based on JS_AliasProperty -- I haven't checked with Jeff, but
> * the code looks similar to JS_AliasProperty. It had been copied without
> * modification into the JS1.5rc2 code. While updating to JS1.5rc3, I
> * looked to see if JS_AliasProperty had changed since JS1.2, and indeed
> * it has -- this code:
> *
> * JS_ReportError(cx, "can't alias %s to %s in class %s",
> * alias, name, OBJ_GET_CLASS(cx, obj2)->name);
> *
> * was changed to this:
> *
> * JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CANT_ALIAS,
> * alias, name, OBJ_GET_CLASS(cx, obj2)->name);
> *
> * and this:
> *
> * scope = (JSScope *) obj->map;
> *
> * was changed to this:
> *
> * scope = OBJ_SCOPE(obj);
> *
> * I've applied the scope change here, and in JS_AliasPropertyToElement
> * (below). Probably the ReportError change should be made as well, but
> * this would require some research, and I doubt that it's important.
> * (Famous last words...)
> *
> * cbank - 9/9/04 same story, this time JS1.5rc2 to JS1.5rc6a
> *
> * changes mirrored:
> *
> * JSScope *scope;
> *
> * was changed to this:
> *
> * JSScopeProperty *sprop;
> *
> *
> *
> * if (obj2 != obj || !OBJ_IS_NATIVE(obj2)) {
> *
> * was changed to this:
> *
> * if (obj2 != obj || !OBJ_IS_NATIVE(obj)) {
> *
> *
> *
> * scope = OBJ_SCOPE(obj);
> * ok = (scope->ops->add(cx, scope, INT_TO_JSVAL(alias), (JSScopeProperty *)prop)
> *
> * was changed to this:
> *
> * sprop = (JSScopeProperty *)prop;
> * ok = (js_AddNativeProperty(cx, obj, INT_TO_JSVAL(alias),
> * sprop->getter, sprop->setter, sprop->slot,
> * sprop->attrs, sprop->flags | SPROP_IS_ALIAS,
> * sprop->shortid)
> *
> */
> JS_PUBLIC_API(JSBool)
> JS_AliasElementToProperty(JSContext *cx, JSObject *obj, const char *name, jsint alias)
> {
> JSObject *obj2;
> JSProperty *prop;
> JSBool ok;
> JSScopeProperty *sprop;
>
> CHECK_REQUEST(cx);
> if (!LookupProperty(cx, obj, name, &obj2, &prop))
> return JS_FALSE;
> if (!prop) {
> js_ReportIsNotDefined(cx, name);
> return JS_FALSE;
> }
> if (obj2 != obj || !OBJ_IS_NATIVE(obj)) {
> OBJ_DROP_PROPERTY(cx, obj2, prop);
> JS_ReportError(cx, "can't alias array element %ld to %s in class %s",
> (long)alias, name, OBJ_GET_CLASS(cx, obj2)->name);
> return JS_FALSE;
> }
> sprop = (JSScopeProperty *)prop;
> ok = (js_AddNativeProperty(cx, obj, INT_TO_JSVAL(alias),
> sprop->getter, sprop->setter, sprop->slot,
> sprop->attrs, sprop->flags | SPROP_IS_ALIAS,
> sprop->shortid)
> != NULL);
> OBJ_DROP_PROPERTY(cx, obj, prop);
> return ok;
> }
>
> /* DREAMWEAVER
> * jschang, Macromedia - (new function added 11/12/99 for OptionsArray setter function)
> * JS_AliasPropertyToElement assigns the named property so that it is an
> * alias to the specified array element.
> *
> * snewman 3/22/01: see comments for JS_AliasElementToProperty (above).
> */
> JS_PUBLIC_API(JSBool)
> JS_AliasPropertyToElement(JSContext *cx, JSObject *obj, jsint index, const char *alias)
> {
> JSObject *obj2;
> JSProperty *prop;
> JSBool ok;
> JSAtom *atom;
> JSScopeProperty *sprop;
>
> CHECK_REQUEST(cx);
> if (!OBJ_LOOKUP_PROPERTY(cx, obj, INT_TO_JSVAL(index), &obj2, &prop))
> return JS_FALSE;
> if (!prop) {
> JS_ReportError(cx, "array element %ld is not defined", (long)index);
> return JS_FALSE;
> }
> if (obj2 != obj || !OBJ_IS_NATIVE(obj)) {
> OBJ_DROP_PROPERTY(cx, obj2, prop);
> JS_ReportError(cx, "can't alias %s to array element %ld in class %s",
> alias, (long)index, OBJ_GET_CLASS(cx, obj2)->name);
> return JS_FALSE;
> }
>
> atom = js_Atomize(cx, alias, strlen(alias), 0);
> if (!atom) {
> ok = JS_FALSE;
> } else {
> sprop = (JSScopeProperty *)prop;
> ok = (js_AddNativeProperty(cx, obj, (jsid)atom,
> sprop->getter, sprop->setter, sprop->slot,
> sprop->attrs, sprop->flags | SPROP_IS_ALIAS,
> sprop->shortid)
> != NULL);
> }
> OBJ_DROP_PROPERTY(cx, obj, prop);
> return ok;
> }
>

Comparing file \jsapi.h

\jsapi.h
Code changed at line: 168a168,171

> // DREAMWEAVER added this function
> extern JS_PUBLIC_API(JSBool)
> JS_DoubleIsNaN(jsdouble n);
>

\jsapi.h
Code changed at line: 641a645,656

> // DREAMWEAVER added this function. Note, if the JS engine was
> // compiled without TOO_MUCH_GC defined, then this function does
> // nothing.
> extern JS_PUBLIC_API(void)
> JS_EnableTooMuchGC(JSContext *cx);
>
> // DREAMWEAVER added this function. Note, if the JS engine was
> // compiled without TOO_MUCH_GC defined, then this function does
> // nothing.
> extern JS_PUBLIC_API(void)
> JS_DisableTooMuchGC(JSContext *cx);
>

\jsapi.h
Code changed at line: 1052a1068,1071

>
> // DREAMWEAVER: renamed parameter "vector" to "vector_arg" to avoid
> // a build error in files that include jsapi.h and also have "using
> // namespace std" (or include a header file that does this).

\jsapi.h
Code changed at line: 1053c1073

< JS_NewArrayObject(JSContext *cx, jsint length, jsval *vector);
---
> JS_NewArrayObject(JSContext *cx, jsint length, jsval *vector_arg);

\jsapi.h
Code changed at line: 1074a1094,1101

> // DREAMWEAVER added this function
> extern JS_PUBLIC_API(JSBool)
> JS_AliasElementToProperty(JSContext *cx, JSObject *obj, const char *name, jsint alias);
>
> // DREAMWEAVER added this function
> extern JS_PUBLIC_API(JSBool)
> JS_AliasPropertyToElement(JSContext *cx, JSObject *obj, jsint index, const char *alias);
>

Comparing file \jsarena.c

\jsarena.c
Code changed at line: 54a54,59

> // DREAMWEAVER - add these macros so on windows we get line numbers on memory leaks
> #if defined(XP_WIN) && defined (_DEBUG) //for debug builds only
> #define _CRTDBG_MAP_ALLOC
> #include <crtdbg.h>
> #endif
>

Comparing file \jsarray.c

\jsarray.c
Code changed at line: 538c538,571

< if (!OBJ_SET_PROPERTY(cx, obj, id, &vector[index]))
---
>
> // DREAMWEAVER CHANGE
> // original code was JS_PropertyStub, JS_PropertyStub instead of
> // NULL, NULL
> //
> // An explanation from DaveG:
> //
> // > Let's suppose the user's document contains a [select] tag:
> // >
> // > [select name="mySelectTag"]
> // > [option]one[/option]
> // > [option]two[/option]
> // > [/select]
> // >
> // > That tag can be accessed through the DOM as follows:
> // >
> // > theSelect = document.forms[0].mySelectTag
> // > alert("first option = " + theSelect.options[0]);
> // > theSelect.options[0] = "new first option";
> // >
> // > In order to implement that functionality, I found that I needed to override
> // > the default implementation of the Array type. I implemented the options
> // > property on the select object so that it returns an OptionsArray object
> // > instead of an Array object. The OptionsArray type is a subclass of Array,
> // > but it has its own implementation for getting the value of options[0] (the
> // > value is sucked out of the corresponding TTAG_OPTION Run in the Run tree)
> // > and setting the value of options[0] (the value is the Run tree is updated).
> // >
> // > I found that I needed to change the base implementation of Array, so that I
> // > could create a sub-class of it (OptionsArray).
> if (!OBJ_DEFINE_PROPERTY(cx, obj, id, vector[index],
> NULL, NULL, // DaveG: use getter/setter defined for class
> JSPROP_ENUMERATE,
> NULL))

\jsarray.c
Code changed at line: 540a573,575

> // ORIGINAL CODE:
> // if (!OBJ_SET_PROPERTY(cx, obj, id, &vector[index]))
> // return JS_FALSE;

\jsarray.c
Code changed at line: 1429a1465,1471

>
> // DREAMWEAVER: Added by DaveG so Dreamweaver can access this InitArrayObject
> JSBool
> JS_InitArrayObject(JSContext *cx, JSObject *obj, jsuint length, jsval *vector)
> {
> return InitArrayObject(cx, obj, length, vector);
> }

Comparing file \jsarray.h

\jsarray.h
Code changed at line: 75a75,78

> // DREAMWEAVER: Added this function
> extern JSBool
> JS_InitArrayObject(JSContext *cx, JSObject *obj, jsuint length, jsval *vector);
>

Comparing file \jsatom.c

\jsatom.c
Code changed at line: 59a59,64

> // DREAMWEAVER - add these macros so on windows we get line numbers on memory leaks
> #if defined(XP_WIN) && defined (_DEBUG) //for debug builds only
> #define _CRTDBG_MAP_ALLOC
> #include <crtdbg.h>
> #endif
>

\jsatom.c
Code changed at line: 196a202,205

> /* DREAMWEAVER added following two prototypes to eliminate compiler warnings */
> void * JS_DLL_CALLBACK js_alloc_table_space(void *priv, size_t size);
> void JS_DLL_CALLBACK js_free_table_space(void *priv, void *item);
>

\jsatom.c
Code changed at line: 545a555,574

> // DREAMWEAVER: Due to a Visual C++ compiler bug, the above ALIGNMENT and ALIGN
> // macros sometimes cause incorrect code generation when optimizations are
> // turned on. Specifically, if /O2 (optimize for speed) is on, the code for
> // js_AtomizeChars (farther down in this file) is bad: the generated code will
> // attempt to write to memory addresses a few bytes above the ESP stack pointer.
> // Usually this is harmless, which is why we haven't noticed the problem before;
> // but when using the Quantify profiler, this always causes corruption (because
> // the profiler injects code, which causes the problem to show up).
> //
> // Turning off the "frame pointer omission" optimization (/Oy) works around the
> // problem. NOTE: From this point on in the file (now that ALIGNMENT and ALIGN
> // have been defined), we should ALWAYS disable frame pointer omission, whether
> // or not the Quantify profiler is in use. The generated code is just plain
> // wrong, regardless of the fact that it hasn't bitten us in the past.
> // [mmorearty]
>
> #ifdef _WINDOWS
> #pragma optimize("y", off) // DREAMWEAVER
> #endif
>

Comparing file \jsconfig.h

\jsconfig.h
Code changed at line: 457c457,458

< #define JS_HAS_EXPORT_IMPORT 0 /* has export fun; import obj.fun */
---
> /* DREAMWEAVER - enable JS_HAS_EXPORT_IMPORT */
> #define JS_HAS_EXPORT_IMPORT 1 /* has export fun; import obj.fun */

\jsconfig.h
Code changed at line: 464c465,466

< #define JS_HAS_XDR_FREEZE_THAW 0 /* has XDR freeze/thaw script methods */
---
> /* DREAMWEAVER - enable JS_HAS_XDR_FREEZE_THAW */
> #define JS_HAS_XDR_FREEZE_THAW 1 /* has XDR freeze/thaw script methods */

Comparing file \jsdhash.c

\jsdhash.c
Code changed at line: 50a50,55

> // DREAMWEAVER - add these macros so on windows we get line numbers on memory leaks
> #if defined(XP_WIN) && defined (_DEBUG) //for debug builds only
> #define _CRTDBG_MAP_ALLOC
> #include <crtdbg.h>
> #endif
>

Comparing file \jsdtoa.c

\jsdtoa.c
Code changed at line: 197a197,202

> // DREAMWEAVER - add these macros so on windows we get line numbers on memory leaks
> #if defined(XP_WIN) && defined (_DEBUG) //for debug builds only
> #define _CRTDBG_MAP_ALLOC
> #include <crtdbg.h>
> #endif
>

 

Comparing file \jsfun.c

\jsfun.c
Code changed at line: 1939a1939,1944

> // DREAMWEAVER: see jsprofiler.h
> #ifdef DREAMWEAVER_JAVASCRIPT_PROFILING
> fun->dummyFunction = -1;
> #endif
>
>

Comparing file \jsfun.h

\jsfun.h
Code changed at line: 48a48,50

> // DREAMWEAVER: see jsprofiler.h
> #include "project/jsprofiler.h"
>

\jsfun.h
Code changed at line: 62a65,68

> // DREAMWEAVER: see jsprofiler.h
> #ifdef DREAMWEAVER_JAVASCRIPT_PROFILING
> int dummyFunction; /* see jsprofiler.h */
> #endif

Comparing file \isqc.c

\isqc.c
Code changed at line: 292a292,329

> /************************* BEGIN DREAMWEAVER CHANGE **************************/
> /**************************** mmorearty 12/31/03 *****************************/
>
> /* Added the tooMuchGC variable, and the js_EnableTooMuchGC and
> * js_DisableTooMuchGC functions.
> *
> * We did not add the TOO_MUCH_GC flag -- that is something that the JS engine
> * already had. However, we added the ability to turn it on and off at
> * run-time, by calling JS_EnableTooMuchGC and JS_DisableTooMuchGC.
> */
> #ifdef TOO_MUCH_GC
> static JSBool tooMuchGC = JS_TRUE;
> #endif
>
> /* DREAMWEAVER added this function. Note, if the JS engine was compiled
> * without TOO_MUCH_GC defined, then this function does nothing.
> */
> JS_PUBLIC_API(void)
> js_EnableTooMuchGC(JSContext *cx)
> {
> #ifdef TOO_MUCH_GC
> tooMuchGC = JS_TRUE;
> #endif
> }
>
> /* DREAMWEAVER added this function. Note, if the JS engine was compiled
> * without TOO_MUCH_GC defined, then this function does nothing.
> */
> JS_PUBLIC_API(void)
> js_DisableTooMuchGC(JSContext *cx)
> {
> #ifdef TOO_MUCH_GC
> tooMuchGC = JS_FALSE;
> #endif
> }
>
> /************************* END DREAMWEAVER CHANGE **************************/
>

\isqc.c
Code changed at line: 463a501,514

> /* DREAMWEAVER CHANGE [mmorearty 12/31/03]
> *
> * In the original, the entire contents of this #ifdef were:
> *
> * #ifdef TOO_MUCH_GC
> * js_GC(cx, GC_KEEP_ATOMS);
> * tried_gc = JS_TRUE;
> * #else
> * tried_gc = JS_FALSE;
> * #endif
> *
> * We have added the check of the 'tooMuchGC' variable.
> */
> if (tooMuchGC) {

\isqc.c
Code changed at line: 465a517,519

> } else {
> tried_gc = JS_FALSE;
> }

\isqc.c
Code changed at line: 1061a1116,1177

> /* DREAMWEAVER CHANGE
> *
> * Set rt->gcPoke if TOO_MUCH_GC is defined.
> *
> * If TOO_MUCH_GC is defined, that tells the JavaScript engine to do
> * way more garbage collections than is actually necessary -- it will
> * cause a GC every single time anyone tries to create an object on
> * the GC heap. This is useful for debugging.
> *
> * But ironically, there is one class of GC-related bugs which could
> * crash under normal execution, but will never crash if TOO_MUCH_GC
> * is defined. That happens if you have code like this:
> *
> * someObj = JS_NewObject(...); // this can cause a GC
> * anotherObj = JS_NewObject(...); // this can cause a GC
> *
> * In this case, if TOO_MUCH_GC is defined, the second call to
> * JS_NewObject will *not* cause a GC. That is because the GC engine
> * keeps track of whether, since the last GC, anything happened that
> * might have caused any objects to become potential candidates for
> * collection. For example, every time you call JS_RemoveRoot, the
> * GC engine knows that there is now probably at least one object that
> * could be freed by the next GC.
> *
> * If TOO_MUCH_GC is defined, then here is what the above code would
> * cause to happen:
> *
> * (1) The first call to JS_NewObject causes a GC to happen. As part
> * of the process of doing a GC, rt->gcPoke is set to JS_FALSE.
> * (2) When the second call to JS_NewObject is made, js_GC() will get
> * called, but since rt->gcPoke is still JS_FALSE, js_GC() knows
> * that no objects have been freed up since the last garbage
> * collection. So, js_GC() just exits without actually attempting
> * a GC.
> *
> * However, if TOO_MUCH_GC is *not* defined, here is what the above
> * code might cause to happen:
> *
> * (1) Some earlier code caused rt->gcPoke to be set to JS_TRUE.
> * (2) The first JS_NewObject call does not cause a GC to happen,
> * since none is necessary (there is enough available memory
> * to create the object without performing a GC).
> * (3) When the second call to JS_NewObject is made, there is not
> * enough memory, so a GC is performed.
> * (4) The first object might get freed, leading to a crash later.
> *
> * Notice that in the first scenario, with TOO_MUCH_GC defined, the
> * second call to JS_NewObject did *not* cause a GC; but in the second
> * scenario, with TOO_MUCH_GC undefined, the second call to
> * JS_NewObject *did* cause a GC!
> *
> * What I want is for the first scenario to cause a GC. So, that is
> * why I have added the following 'rt->gcPoke = JS_TRUE' statement.
> *
> * [mmorearty 12/30/03]
> */
> #ifdef TOO_MUCH_GC
> if (tooMuchGC)
> rt->gcPoke = JS_TRUE;
> #endif
> /* END DREAMWEAVER CHANGE */
>

 

Comparing file \isqc.h

\isqc.h
Code changed at line: 200a200,211

> // DREAMWEAVER added this function. Note, if the JS engine was
> // compiled without TOO_MUCH_GC defined, then this function does
> // nothing.
> extern void
> js_EnableTooMuchGC(JSContext *cx);
>
> // DREAMWEAVER added this function. Note, if the JS engine was
> // compiled without TOO_MUCH_GC defined, then this function does
> // nothing.
> extern void
> js_DisableTooMuchGC(JSContext *cx);
>

 

Comparing file \jsinterp.c

\jsinterp.c
Code changed at line: 78a78,84

> // DREAMWEAVER: added JavaScript profiling - see jsprofiler.h
> #include "project/jsprofiler.h"
>
> // DREAMWEAVER: inserted this declaration (see usage below).
> extern JSBool JSCallNativeSafe (JSNative native, JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
> jsval *rval);
>

\jsinterp.c
Code changed at line: 323a330,334

> // DREAMWEAVER snewman 3/28/01: added prototype to eliminate compiler
> // warning.
> JS_FRIEND_API(jsval *)
> js_AllocRawStack(JSContext *cx, uintN nslots, void **markp);
>

\jsinterp.c
Code changed at line: 340a352,356

> // DREAMWEAVER snewman 3/28/01: added prototype to eliminate compiler
> // warning.
> JS_FRIEND_API(void)
> js_FreeRawStack(JSContext *cx, void *mark);
>

\jsinterp.c
Code changed at line: 941c958,961

< ok = native(cx, frame.thisp, argc, frame.argv, &frame.rval);
---
> // DREAMWEAVER: patched to call JSCallNativeSafe instead of calling
> // the native function directly. JSCallNativeSafe catches C++
> // exceptions and turns them into an error result.
> ok = JSCallNativeSafe(native, cx, frame.thisp, argc, frame.argv, &frame.rval);

\jsinterp.c
Code changed at line: 1367a1387,1397

> // DREAMWEAVER: added JavaScript profiling - see jsprofiler.h
> #ifdef DREAMWEAVER_JAVASCRIPT_PROFILING
> JSBool
> js_Interpret(JSContext *cx, jsval *result)
> {
> return jsprofiler_Interpret(cx, result);
> }
>
> JSBool
> js_InterpretInternal(JSContext *cx, jsval *result)
> #else

\jsinterp.c
Code changed at line: 1369a1400

> #endif

\jsinterp.c
Code changed at line: 2869a2901,2904

> // Dreamweaver: if we're profiling, inline functions are invisible
> // to the profiler, so disable them.
> #ifndef DREAMWEAVER_JAVASCRIPT_PROFILING
>

\jsinterp.c
Code changed at line: 2972a3008,3009

> #endif /* DREAMWEAVER_JAVASCRIPT_PROFILING */
>

Comparing file \jsinterp2.h

\jsinterp2.h
Code changed at line: 3,6c3,4

< * The contents of this file are subject to the Netscape 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/NPL/
---
> * ***** BEGIN LICENSE BLOCK *****
> * Version: MPL 1.1/GPL 2.0/LGPL 2.1

\jsinterp2.h
Code changed at line: 8,11c6,14

< * Software distributed under the License is distributed on an "AS
< * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
< * implied. See the License for the specific language governing
< * rights and limitations under the License.
---
> * 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.

\jsinterp2.h
Code changed at line: 16,19c19,22

< * The Initial Developer of the Original Code is Netscape
< * Communications Corporation. Portions created by Netscape are
< * Copyright (C) 1998 Netscape Communications Corporation. All
< * Rights Reserved.
---
> * The Initial Developer of the Original Code is
> * Netscape Communications Corporation.
> * Portions created by the Initial Developer are Copyright (C) 1998
> * the Initial Developer. All Rights Reserved.

\jsinterp2.h
Code changed at line: 23,33c26,38

< * Alternatively, the contents of this file may be used under the
< * terms of the GNU Public License (the "GPL"), in which case the
< * provisions of the GPL are applicable instead of those above.
< * If you wish to allow use of your version of this file only
< * under the terms of the GPL and not to allow others to use your
< * version of this file under the NPL, indicate your decision by
< * deleting the provisions above and replace them with the notice
< * and other provisions required by the GPL. If you do not delete
< * the provisions above, a recipient may use your version of this
< * file under either the NPL or the GPL.
< */
---
> * 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 ***** */

\jsinterp2.h
Code changed at line: 68,71c73

< JSPackedBool constructing; /* true if called via new operator */
< uint8 overrides; /* bit-set of overridden Call properties */
< uint8 special; /* special frame type flags, see below */
< JSPackedBool reserved; /* reserved for future use */
---
> uint32 flags; /* frame flags -- see below */

\jsinterp2.h
Code changed at line: 73a75,76

> JSAtomMap *objAtomMap; /* object atom map, non-null only if we
> hit a regexp object literal */

\jsinterp2.h
Code changed at line: 79a83

> JSVersion callerVersion; /* dynamic version of calling script */

\jsinterp2.h
Code changed at line: 81,83c86,101

< /* JS special stack frame flags. */
< #define JSFRAME_DEBUGGER 0x1 /* frame for JS_EvaluateInStackFrame */
< #define JSFRAME_EVAL 0x2 /* frame for obj_eval */
---
> /* JS stack frame flags. */
> #define JSFRAME_CONSTRUCTING 0x01 /* frame is for a constructor invocation */
> #define JSFRAME_INTERNAL 0x02 /* internal call, not invoked by a script */
> #define JSFRAME_SKIP_CALLER 0x04 /* skip one link when evaluating f.caller
> for this invocation of f */
> #define JSFRAME_ASSIGNING 0x08 /* a complex (not simplex JOF_ASSIGNING) op
> is currently assigning to a property */
> #define JSFRAME_DEBUGGER 0x10 /* frame for JS_EvaluateInStackFrame */
> #define JSFRAME_EVAL 0x20 /* frame for obj_eval */
> #define JSFRAME_SPECIAL 0x30 /* special evaluation frame flags */
> #define JSFRAME_COMPILING 0x40 /* frame is being used by compiler */
> #define JSFRAME_COMPILE_N_GO 0x80 /* compiler-and-go mode, can optimize name
> references based on scope chain */
>
> #define JSFRAME_OVERRIDE_SHIFT 24 /* override bit-set params; see jsfun.c */
> #define JSFRAME_OVERRIDE_BITS 8

\jsinterp2.h
Code changed at line: 104a122,123

> #define JS_PROPERTY_CACHE_METERING 1
>

\jsinterp2.h
Code changed at line: 106,107c126,127

< uint32 _prefills; \
< uint32 _fills = (cache)->fills; \
---
> uint32 prefills_; \
> uint32 fills_ = (cache)->fills; \

\jsinterp2.h
Code changed at line: 110c130

< _prefills = _fills; \
---
> prefills_ = fills_; \

\jsinterp2.h
Code changed at line: 112c132

< } while ((_fills = (cache)->fills) != _prefills); \
---
> } while ((fills_ = (cache)->fills) != prefills_); \

\jsinterp2.h
Code changed at line: 136c156

< JSProperty *property; /* weak link to property, or not-found id */
---
> JSScopeProperty *property; /* weak link to property */

\jsinterp2.h
Code changed at line: 150a170,171

> JSBool disabled;
> #ifdef JS_PROPERTY_CACHE_METERING

\jsinterp2.h
Code changed at line: 155a177,180

> # define PCMETER(x) x
> #else
> # define PCMETER(x) /* nothing */
> #endif

\jsinterp2.h
Code changed at line: 157c183

< #define PROPERTY_CACHE_FILL(cx, cache, obj, id, prop) \
---
> #define PROPERTY_CACHE_FILL(cache, obj, id, sprop) \

\jsinterp2.h
Code changed at line: 159,172c185,200

< uintN _hashIndex = (uintN)PROPERTY_CACHE_HASH(obj, id); \
< JSPropertyCache *_cache = (cache); \
< JSPropertyCacheEntry *_pce = &_cache->table[_hashIndex]; \
< JSPropertyCacheEntry _entry; \
< JSProperty *_pce_prop; \
< PCE_LOAD(_cache, _pce, _entry); \
< _pce_prop = PCE_PROPERTY(_entry); \
< if (_pce_prop && _pce_prop != prop) \
< _cache->recycles++; \
< PCE_OBJECT(_entry) = obj; \
< PCE_PROPERTY(_entry) = prop; \
< _cache->empty = JS_FALSE; \
< _cache->fills++; \
< PCE_STORE(_cache, _pce, _entry); \
---
> JSPropertyCache *cache_ = (cache); \
> if (!cache_->disabled) { \
> uintN hashIndex_ = (uintN) PROPERTY_CACHE_HASH(obj, id); \
> JSPropertyCacheEntry *pce_ = &cache_->table[hashIndex_]; \
> JSPropertyCacheEntry entry_; \
> JSScopeProperty *pce_sprop_; \
> PCE_LOAD(cache_, pce_, entry_); \
> pce_sprop_ = PCE_PROPERTY(entry_); \
> PCMETER(if (pce_sprop_ && pce_sprop_ != sprop) \
> cache_->recycles++); \
> PCE_OBJECT(entry_) = obj; \
> PCE_PROPERTY(entry_) = sprop; \
> cache_->empty = JS_FALSE; \
> PCMETER(cache_->fills++); \
> PCE_STORE(cache_, pce_, entry_); \
> } \

\jsinterp2.h
Code changed at line: 175c203

< #define PROPERTY_CACHE_TEST(cache, obj, id, prop) \
---
> #define PROPERTY_CACHE_TEST(cache, obj, id, sprop) \

\jsinterp2.h
Code changed at line: 177,188c205,216

< uintN _hashIndex = (uintN)PROPERTY_CACHE_HASH(obj, id); \
< JSPropertyCache *_cache = (cache); \
< JSPropertyCacheEntry *_pce = &_cache->table[_hashIndex]; \
< JSPropertyCacheEntry _entry; \
< JSProperty *_pce_prop; \
< PCE_LOAD(_cache, _pce, _entry); \
< _pce_prop = PCE_PROPERTY(_entry); \
< _cache->tests++; \
< if (_pce_prop && \
< sym_id(((JSScopeProperty *)_pce_prop)->symbols) == id && \
< PCE_OBJECT(_entry) == obj) { \
< prop = _pce_prop; \
---
> uintN hashIndex_ = (uintN) PROPERTY_CACHE_HASH(obj, id); \
> JSPropertyCache *cache_ = (cache); \
> JSPropertyCacheEntry *pce_ = &cache_->table[hashIndex_]; \
> JSPropertyCacheEntry entry_; \
> JSScopeProperty *pce_sprop_; \
> PCE_LOAD(cache_, pce_, entry_); \
> pce_sprop_ = PCE_PROPERTY(entry_); \
> PCMETER(cache_->tests++); \
> if (pce_sprop_ && \
> PCE_OBJECT(entry_) == obj && \
> pce_sprop_->id == id) { \
> sprop = pce_sprop_; \

\jsinterp2.h
Code changed at line: 190,191c218,219

< _cache->misses++; \
< prop = NULL; \
---
> PCMETER(cache_->misses++); \
> sprop = NULL; \

\jsinterp2.h
Code changed at line: 199c227,230

< js_FlushPropertyCacheByProp(JSContext *cx, JSProperty *prop);
---
> js_DisablePropertyCache(JSContext *cx);
>
> extern void
> js_EnablePropertyCache(JSContext *cx);

\jsinterp2.h
Code changed at line: 227,228c258

< * Consolidated js_Invoke flags. NB: JSINVOKE_CONSTRUCT must be 1 or JS_TRUE
< * (see js_Invoke's initialization of frame.constructing).
---
> * Consolidated js_Invoke flags simply rename the low JSFRAME_* flags.

\jsinterp2.h
Code changed at line: 230,231c260,262

< #define JSINVOKE_CONSTRUCT 0x1 /* construct object rather than call */
< #define JSINVOKE_INTERNAL 0x2 /* internal call, not from a script */
---
> #define JSINVOKE_CONSTRUCT JSFRAME_CONSTRUCTING
> #define JSINVOKE_INTERNAL JSFRAME_INTERNAL
> #define JSINVOKE_SKIP_CALLER JSFRAME_SKIP_CALLER

\jsinterp2.h
Code changed at line: 248a279,282

> js_InternalGetOrSet(JSContext *cx, JSObject *obj, jsid id, jsval fval,
> JSAccessMode mode, uintN argc, jsval *argv, jsval *rval);
>
> extern JSBool

 

Comparing file \jslibmath.h

\jslibmath.h
Code changed at line: 50a50,57

>
>
> // DREAMWEAVER: inserted these three lines
> #ifdef _WIN32
> #include <float.h>
> #endif
>
>

\jslibmath.h
Code changed at line: 58c66,68

< #define JS_USE_FDLIBM_MATH 1
---
>
> // DREAMWEAVER: changed this from 1 to 0
> #define JS_USE_FDLIBM_MATH 0

\jslibmath.h
Code changed at line: 97a107,113

>
> // DREAMWEAVER: tweaked definition of fd_copysign
> #ifdef XP_OS2_VACPP /* OS2TODO */
> #define fd_copysign
> #elif defined (_WIN32)
> #define fd_copysign _copysign
> #else

\jslibmath.h
Code changed at line: 98a115,116

> #endif
>

Comparing file \jsobj.c

\jsobj.c
Code changed at line: 1109a1109,1111

> /* DREAMWEAVER added following prototype to eliminate compiler warnings */
> JS_PUBLIC_API(JSBool) resolving_MatchEntry(JSDHashTable *table, const JSDHashEntryHdr *hdr, const void *ptr);
>

\jsobj.c
Code changed at line: 1556a1559,1562

> /* DREAMWEAVER add these vars, see note below */
> JSBool ret;
> jsval val;
>

\jsobj.c
Code changed at line: 1559c1566,1598

< if (!OBJ_LOOKUP_PROPERTY(cx, proto, id, objp, propp))
---
> /* DREAMWEAVER - orginal code, see note below
> * if (!OBJ_LOOKUP_PROPERTY(cx, proto, id, objp, propp))
> * return JS_FALSE;
> */
>
> /* DREAMWEAVER
> * DaveG - if the lookup didn't find the property, do a get_property to
> * see if the prop exists. If it does, define the property now.
> *
> * snewman 2/22/01: this is necessary because Dreamweaver defines
> * object classes with additional properties, but doesn't quite
> * follow the rules when doing so. See dw_js_notes.txt for details.
> *
> * The full change we've made to this routine is as follows:
> *
> * 1. Insert the declarations of ret and val, above.
> * 2. Convert the next line to assign the result of OBJ_LOOKUP_PROPERTY
> * into ret, instead of returning it directly.
> * 3. Insert the following seven lines (the "if (ret && *propp == NULL)"
> * and the code inside it).
> * 4. Add "if (!ret) {return JS_FALSE}" to match orginal logic
> */
> ret = OBJ_LOOKUP_PROPERTY(cx, proto, id, objp, propp);
>
> if (ret && *propp == NULL) {
> val = JSVAL_VOID;
> OBJ_GET_PROPERTY(cx, proto, id, &val);
> if (val != JSVAL_VOID) {
> OBJ_DEFINE_PROPERTY(cx, proto, id, val, NULL, NULL, 0, NULL);
> OBJ_LOOKUP_PROPERTY(cx, proto, id, objp, propp);
> }
> }
> if (!ret) {

\jsobj.c
Code changed at line: 1561a1600

> }

\jsobj.c
Code changed at line: 3943a3983,3990

> /* DREAMWEAVER added prototypes to get rid of compiler warnings */
> void printChar(jschar *cp);
> void printString(JSString *str);
> void printObj(JSContext *cx, JSObject *jsobj);
> void printId(JSContext *cx, jsid id);
> void printAtom(JSAtom *atom);
>
>

 

Comparing file \jsotypes.h

\jsotypes.h
Code changed at line: 70c70,73

< #ifdef XP_UNIX
---
> /* DREAMWEAVER - changes for Mach-O mac, replaced the following define with the one below it.
> * #ifdef XP_UNIX
> */
> #if defined(XP_UNIX) || defined (__MACH__)

 

Comparing file \jsparse.c

\jsparse.c
Code changed at line: 411a411,419

>
> // DREAMWEAVER snewman 3/16/01: added this flag to detect re-entrant calls
> // to the JS compiler. I'm getting a wierd illegal-access error when the
> // internal JavaScript debugger contains a compile-time error, and I think
> // it's because this causes us to invoke the compiler reentrantly and it
> // gets mixed up about tempPool.
> JSBool gInCompileTokenStream = JS_FALSE;
>
>

\jsparse.c
Code changed at line: 422a431,435

>
> // DREAMWEAVER snewman 3/16/01: see declaration of gInCompileTokenStream.
> JS_ASSERT(!gInCompileTokenStream);
> gInCompileTokenStream = JS_TRUE;
>

\jsparse.c
Code changed at line: 489a503,506

>
> // DREAMWEAVER snewman 3/16/01: see declaration of gInCompileTokenStream.
> gInCompileTokenStream = JS_FALSE;
>

\jsparse.c
Code changed at line: 922a940,1051

>
> // DREAMWEAVER macromedia change - jschang 6/1/01
> // if the containing object has the special property - MM_defineFunctionsOnCompile
> // then define the property now - this is because we need to compile scripts
> // in the document, so we can execute some of the functions selectively later on
> // - JavaScript 1.2 did this autmoatically, but the JavaScript 1.5 only defines the
> // property when you execute the script that contains the function
> // definition, but we can't just execute any old script, we only execute
> // specific behavior functions that we define and have control over.
> //
> // The following code that defines the property is copied and modified from
> // jsinterp.c, js_Interpret, case JSOP_DEFFUN:
> else
> {
> JSStackFrame *fp;
> JSObject *varobj;
> JSBool ok, cond;
> jsval specialPropVal;
> uintN flags, attrs;
>
> fp = cx->fp;
> varobj = fp->varobj;
>
> // check the special property
> if ( JS_GetProperty(cx, varobj, "MM_defineFunctionsOnCompile", &specialPropVal) &&
> JS_TRUE == JSVAL_TO_BOOLEAN(specialPropVal) )
> {
> /*
> * We must be at top-level (default "box", either function body or
> * global) scope, not inside a with or other compound statement in
> * the same compilation unit (ECMA Program).
> *
> * However, we could be in a Program being eval'd from inside a
> * with statement, so we need to distinguish variables object from
> * scope chain head. Hence the two assignments to parent below.
> * First we make sure the function object we're defining has the
> * right scope chain. Then we define its name in fp->varobj.
> *
> * If static link is not current scope, clone fun's object to link
> * to the current scope via parent. This clause exists to enable
> * sharing of compiled functions among multiple equivalent scopes,
> * splitting the cost of compilation evenly among the scopes and
> * amortizing it over a number of executions. Examples include XUL
> * scripts and event handlers shared among Mozilla chrome windows,
> * and server-side JS user-defined functions shared among requests.
> *
> * NB: The Script object exposes compile and exec in the language,
> * such that this clause introduces an incompatible change from old
> * JS versions that supported Script. Such a JS version supported
> * executing a script that defined and called functions scoped by
> * the compile-time static link, not by the exec-time scope chain.
> *
> * We sacrifice compatibility, breaking such scripts, in order to
> * promote compile-cost sharing and amortizing, and because Script
> * is not and will not be standardized.
> */
> /***** jschang - this is in js_Execute: I don't think we need it here
> parent = fp->scopeChain;
> if (OBJ_GET_PARENT(cx, obj) != parent) {
> obj = js_CloneFunctionObject(cx, obj, parent);
> if (!obj) {
> ok = JS_FALSE;
> goto out;
> }
> }
> *****/
>
> /*
> * ECMA requires functions defined when entering Global code to be
> * permanent, and functions defined when entering Eval code to be
> * impermanent.
> */
> attrs = JSPROP_ENUMERATE;
> // We don't want functions to be "permanent" in user docs, because
> // the Timeline code depends on these functions being gone after
> // they are deleted (seems reasonable!) to determine what
> // timelines are on page. redmunds 23May2005 184326
> //if (!(fp->flags & JSFRAME_EVAL))
> // attrs |= JSPROP_PERMANENT;
>
>
> /*
> * Load function flags that are also property attributes. Getters
> * and setters do not need a slot, their value is stored elsewhere
> * in the property itself, not in obj->slots.
> */
> flags = fun->flags & (JSFUN_GETTER | JSFUN_SETTER);
> if (flags)
> attrs |= flags | JSPROP_SHARED;
>
> /*
> * Check for a const property of the same name -- or any kind
> * of property if executing with the strict option. We check
> * here at runtime as well as at compile-time, to handle eval
> * as well as multiple HTML script tags.
> */
> parent = fp->varobj;
> if (js_CheckRedeclaration(cx, parent, (jsid)funAtom, attrs, &cond))
> {
> ok = OBJ_DEFINE_PROPERTY(cx, parent, (jsid)funAtom,
> OBJECT_TO_JSVAL(fun->object),
> (flags & JSFUN_GETTER)
> ? (JSPropertyOp) fun->object
> : NULL,
> (flags & JSFUN_SETTER)
> ? (JSPropertyOp) fun->object
> : NULL,
> attrs,
> NULL);
> }
> }
> }

\jsparse.c
Code changed at line: 1064a1194,1201

> // DREAMWEAVER dgeorge 4/23/02: there are lots of Dreamweaver
> // extensions, such as the "Javascript Integration Kit for
> // Macromedia Flash 5", which will break if we stop treating
> // a single equals sign as equality. Therefore, I'm forcing
> // rewrite to be true. Also see the code in CompileOrExecScript
> // (in JSInterp.cpp) to handle this case.
> rewrite = JS_TRUE;
>

 

Comparing file \jsprf.c

\jsprf.c
Code changed at line: 53a53,58

> // DREAMWEAVER - add these macros so on windows we get line numbers on memory leaks
> #if defined(XP_WIN) && defined (_DEBUG) //for debug builds only
> #define _CRTDBG_MAP_ALLOC
> #include <crtdbg.h>
> #endif
>

 

Comparing file \jsregexp.c

\jsregexp.c
Code changed at line: 65a65,69

> /* DREAMWEAVER - changes for Mach-O mac, replaced the following define with the one below it.
> * #ifdef XP_MAC
> * #include <MacMemory.h>
> * #endif
> */

\jsregexp.c
Code changed at line: 66a71,73

> #ifdef __MACH__
> #include <Carbon/Carbon.h>
> #else

\jsregexp.c
Code changed at line: 68a76

> #endif

\jsregexp.c
Code changed at line: 3045a3054,3059

> /* DREAMWEAVER - change behavior of empty submatches to be empty strings instead of undefined. This fixes the following problem
> var testString = new String("this is a test string");
> var reObj = new RegExp(/\s(foo)|(test)\s/);
> var matchedArray = testString.match(reObj);
> matchedArray[1] == RegExp.$1; //this is false if the property is undefined
> */

\jsregexp.c
Code changed at line: 3046,3048c3061,3064

< ok = js_DefineProperty(cx, obj, INT_TO_JSVAL(num + 1),
< JSVAL_VOID, NULL, NULL,
< JSPROP_ENUMERATE, NULL);
---
> // ok = js_DefineProperty(cx, obj, INT_TO_JSVAL(num + 1),
> // JSVAL_VOID, NULL, NULL,
> // JSPROP_ENUMERATE, NULL);
> parstr = JSVAL_TO_STRING(JS_GetEmptyStringValue(cx));

\jsregexp.c
Code changed at line: 3052a3068

> }

\jsregexp.c
Code changed at line: 3061c3078,3079

< }
---
> //}
> /* DREAMWEAVER - end of change */

\jsregexp.c
Code changed at line: 3266c3284,3287

< sub = REGEXP_PAREN_SUBSTRING(res, slot);
---
> /* DREAMWEAVER - Macro replaced with function, see comment in jsregexp.h
> * sub = REGEXP_PAREN_SUBSTRING(res, slot);
> */
> sub = js_RegExpParenSubString(res, slot);

\jsregexp.c
Code changed at line: 3777a3798,3829

> // DREAMWEAVER: See comment in the header file.
> JSRegExpStatics *
> js_GetRegExpStatics(JSContext *cx)
> {
> return &(cx->regExpStatics);
> }
>
> // DREAMWEAVER: See [dgeorge 23-feb-02] comment in header file
> JSSubString *
> js_RegExpParenSubString(JSRegExpStatics *res, jsuint num)
> {
> JSSubString *ret = NULL;
>
> if (num < (jsuint)(res->parenCount))
> {
> if (num < 9)
> {
> ret = &(res->parens[num]);
> }
> else
> {
> ret = &(res->moreParens[num - 9]);
> }
> }
> else
> {
> ret = &js_EmptySubString;
> }
>
> return ret;
> }
>

Comparing file \jsregexp.h

\jsregexp.h
Code changed at line: 90a90,93

> *
> * DREAMWEAVER [dgeorge 23-feb-02] I'm replacing the macro with a function because
> * it looks like the macro is being compiled incorrectly in the WinRelease
> * build

\jsregexp.h
Code changed at line: 91a95

> /*

\jsregexp.h
Code changed at line: 97a102,104

> */
> extern JSSubString *
> js_RegExpParenSubString(JSRegExpStatics *res, jsuint num);

\jsregexp.h
Code changed at line: 168a176,191

> /* DREAMWEAVER:
> *
> * Added a function to access the statics data structure.
> *
> * We should be able to access the structure by traversing the js_context
> * data structure. However, differences between the compiler flags for
> * the NscpJavaScript library and the Dreamweaver executable cause problems
> * on the Mac (I think the cause is that Enums are ints in Dreamweaver but
> * not in NscpJavaScript). Instead of switching the compiler flag and
> * introducing a lot of risk, I'm adding this function to access the
> * piece of js_context that interests me. [dgeorge 8/00]
> *
> * [snewman 2/14/00: copied this patch from NscpJavaScript to JavaScript_1_5]
> */
> extern JSRegExpStatics *
> js_GetRegExpStatics(JSContext *cx);

 

Comparing file \jsscript.c

\jsscript.c
Code changed at line: 64a64,69

> // DREAMWEAVER - add these macros so on windows we get line numbers on memory leaks
> #if defined(XP_WIN) && defined (_DEBUG) //for debug builds only
> #define _CRTDBG_MAP_ALLOC
> #include <crtdbg.h>
> #endif
>

\jsscript.c
Code changed at line: 1281c1287,1294

< lineno = (uintN) js_GetSrcNoteOffset(sn, 0);
---
> // DREAMWEAVER snewman 6/15/01: changed this to not update lineno
> // if js_GetSrcNoteOffset returns a smaller value -- otherwise we
> // were having problems debugging the JavaScript code that the
> // template engine generates. For some reason, the last srcnote
> // in that function had a line number of zero.
> uintN temp = (uintN) js_GetSrcNoteOffset(sn, 0);
> if (lineno < temp)
> lineno = temp;

Comparing file \jsstr.c

\jsstr.c
Code changed at line: 1328c1328,1330

< return REGEXP_PAREN_SUBSTRING(res, num);
---
> // DREAMWEAVER: replacing REGEXP_PAREN_SUBSTRING with js_RegExpParenSubString
> // (see comment from dgeorge in jsregexp.h
> return js_RegExpParenSubString(res, num);

\jsstr.c
Code changed at line: 1911c1913,1915

< parsub = REGEXP_PAREN_SUBSTRING(&cx->regExpStatics, num);
---
> // DREAMWEAVER: replacing REGEXP_PAREN_SUBSTRING with js_RegExpParenSubString
> // (see comment from dgeorge in jsregexp.h
> parsub = js_RegExpParenSubString(&cx->regExpStatics, num);

\jsstr.c
Code changed at line: 2502a2506,2508

> /* DREAMWEAVER add prototype to get rid of compiler warning */
> void printJSStringStats(JSRuntime *rt);
>

 

Comparing file \jstypes.h

\jstypes.h
Code changed at line: 54a54,61

>
> // DREAMWEAVER snewman 3/16/01: tweaked this file to remove all
> // references to "_declspec", to match the changes we had made in the
> // JS 1.2 interpreter. Using _declspec doesn't make sense, because we
> // aren't building a separate DLL -- the interpreter is linked directly
> // into Dreamweaver.
>
>

\jstypes.h
Code changed at line: 59a67,73

> // DREAMWEAVER
> #if WIN32
> #define XP_WIN 1
> #elif __powerc
> #define XP_MAC 1
> #endif
>

\jstypes.h
Code changed at line: 81,84c96,99

< #define JS_EXTERN_API(__type) extern __declspec(dllexport) __type
< #define JS_EXPORT_API(__type) __declspec(dllexport) __type
< #define JS_EXTERN_DATA(__type) extern __declspec(dllexport) __type
< #define JS_EXPORT_DATA(__type) __declspec(dllexport) __type
---
> #define JS_EXTERN_API(__type) extern __type
> #define JS_EXPORT_API(__type) __type
> #define JS_EXTERN_DATA(__type) extern __type
> #define JS_EXPORT_DATA(__type) __type

\jstypes.h
Code changed at line: 111,114c126,129

< #define JS_EXTERN_API(__type) extern __declspec(export) __type
< #define JS_EXPORT_API(__type) __declspec(export) __type
< #define JS_EXTERN_DATA(__type) extern __declspec(export) __type
< #define JS_EXPORT_DATA(__type) __declspec(export) __type
---
> #define JS_EXTERN_API(__type) extern __type
> #define JS_EXPORT_API(__type) __type
> #define JS_EXTERN_DATA(__type) extern __type
> #define JS_EXPORT_DATA(__type) __type

\jstypes.h
Code changed at line: 135c150

< # define JS_IMPORT_API(__x) __declspec(dllimport) __x
---
> # define JS_IMPORT_API(__x) __x

\jstypes.h
Code changed at line: 142c157

< # define JS_IMPORT_DATA(__x) __declspec(dllimport) __x
---
> # define JS_IMPORT_DATA(__x) __x

 

Comparing file \jsutil.c

\jsutil.c
Code changed at line: 54a54,60

> /* DREAMWEAVER - changes for Mach-O mac, replaced the following define with the one below it.
> * #ifdef XP_MAC
> * # include <Types.h>
> * # include <stdarg.h>
> * # include "jsprf.h"
> * #endif
> */

\jsutil.c
Code changed at line: 55a62,64

> #ifdef __MACH__
> #include <Carbon/Carbon.h>
> #else

\jsutil.c
Code changed at line: 57a67

> #endif

\jsutil.c
Code changed at line: 60a71

>

\jsutil.c
Code changed at line: 141a153,156

> // DREAMWEAVER snewman 3/28/01: wrapped JS_Assert in #ifdef DEBUG
> // to avoid compiler warning (no prototype) when DEBUG is turned off.
> #ifdef DEBUG
>

\jsutil.c
Code changed at line: 158a174,175

>
> #endif

 

Comparing file \prmjtime.c

\prmjtime.c
Code changed at line: 61,62c61,68

< #include <windef.h>
< #include <winbase.h>
---
> /* DREAMWEAVER cbank - 9/13/04 - per MSDN documentation for GetSystemTimeAsFileTime,
> * we should include windows.h instead of these two files directly. This eleminates
> * some compiler errors I was seeing.
> *
> * #include <windef.h>
> * #include <winbase.h>
> */
> #include <windows.h>

\prmjtime.c
Code changed at line: 65a71

> /* DREAMWEAVER - changes for Mach-O mac, added __MACH__ clause */

\prmjtime.c
Code changed at line: 66a73,80

> # ifdef __MACH__
> # include <Carbon/Carbon.h>
> # else
> # include <OSUtils.h>
> # include <TextUtils.h>
> # include <Resources.h>
> # include <Timer.h>
> # include <UTCUtils.h>

\prmjtime.c
Code changed at line: 77a92

> #endif