1 files changed, 233 insertions, 0 deletions
diff --git a/trunk/infrastructure/rhino1_7R1/src/org/mozilla/javascript/CompilerEnvirons.java b/trunk/infrastructure/rhino1_7R1/src/org/mozilla/javascript/CompilerEnvirons.java
new file mode 100644
index 0000000..645d098
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/src/org/mozilla/javascript/CompilerEnvirons.java
@@ -0,0 +1,233 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * 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 Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov, igor@fastmail.fm
+ *   Bob Jervis
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (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
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * 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 MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript;
+
+import java.util.Hashtable;
+
+public class CompilerEnvirons
+{
+    public CompilerEnvirons()
+    {
+        errorReporter = DefaultErrorReporter.instance;
+        languageVersion = Context.VERSION_DEFAULT;
+        generateDebugInfo = true;
+        useDynamicScope = false;
+        reservedKeywordAsIdentifier = false;
+        allowMemberExprAsFunctionName = false;
+        xmlAvailable = true;
+        optimizationLevel = 0;
+        generatingSource = true;
+        strictMode = false;
+        warningAsError = false;
+        generateObserverCount = false;
+    }
+
+    public void initFromContext(Context cx)
+    {
+        setErrorReporter(cx.getErrorReporter());
+        this.languageVersion = cx.getLanguageVersion();
+        useDynamicScope = cx.compileFunctionsWithDynamicScopeFlag;
+        generateDebugInfo = (!cx.isGeneratingDebugChanged()
+                             || cx.isGeneratingDebug());
+        reservedKeywordAsIdentifier
+            = cx.hasFeature(Context.FEATURE_RESERVED_KEYWORD_AS_IDENTIFIER);
+        allowMemberExprAsFunctionName
+            = cx.hasFeature(Context.FEATURE_MEMBER_EXPR_AS_FUNCTION_NAME);
+        strictMode
+            = cx.hasFeature(Context.FEATURE_STRICT_MODE);
+        warningAsError = cx.hasFeature(Context.FEATURE_WARNING_AS_ERROR);
+        xmlAvailable
+            = cx.hasFeature(Context.FEATURE_E4X);
+
+        optimizationLevel = cx.getOptimizationLevel();
+
+        generatingSource = cx.isGeneratingSource();
+        activationNames = cx.activationNames;
+        
+        // Observer code generation in compiled code :
+        generateObserverCount = cx.generateObserverCount;
+    }
+
+    public final ErrorReporter getErrorReporter()
+    {
+        return errorReporter;
+    }
+
+    public void setErrorReporter(ErrorReporter errorReporter)
+    {
+        if (errorReporter == null) throw new IllegalArgumentException();
+        this.errorReporter = errorReporter;
+    }
+
+    public final int getLanguageVersion()
+    {
+        return languageVersion;
+    }
+
+    public void setLanguageVersion(int languageVersion)
+    {
+        Context.checkLanguageVersion(languageVersion);
+        this.languageVersion = languageVersion;
+    }
+
+    public final boolean isGenerateDebugInfo()
+    {
+        return generateDebugInfo;
+    }
+
+    public void setGenerateDebugInfo(boolean flag)
+    {
+        this.generateDebugInfo = flag;
+    }
+
+    public final boolean isUseDynamicScope()
+    {
+        return useDynamicScope;
+    }
+
+    public final boolean isReservedKeywordAsIdentifier()
+    {
+        return reservedKeywordAsIdentifier;
+    }
+
+    public void setReservedKeywordAsIdentifier(boolean flag)
+    {
+        reservedKeywordAsIdentifier = flag;
+    }
+
+    public final boolean isAllowMemberExprAsFunctionName()
+    {
+        return allowMemberExprAsFunctionName;
+    }
+
+    public void setAllowMemberExprAsFunctionName(boolean flag)
+    {
+        allowMemberExprAsFunctionName = flag;
+    }
+
+    public final boolean isXmlAvailable()
+    {
+        return xmlAvailable;
+    }
+
+    public void setXmlAvailable(boolean flag)
+    {
+        xmlAvailable = flag;
+    }
+
+    public final int getOptimizationLevel()
+    {
+        return optimizationLevel;
+    }
+
+    public void setOptimizationLevel(int level)
+    {
+        Context.checkOptimizationLevel(level);
+        this.optimizationLevel = level;
+    }
+
+    public final boolean isGeneratingSource()
+    {
+        return generatingSource;
+    }
+
+    public final boolean isStrictMode()
+    {
+        return strictMode;
+    }
+
+    public final boolean reportWarningAsError()
+    {
+        return warningAsError;
+    }
+
+    /**
+     * Specify whether or not source information should be generated.
+     * <p>
+     * Without source information, evaluating the "toString" method
+     * on JavaScript functions produces only "[native code]" for
+     * the body of the function.
+     * Note that code generated without source is not fully ECMA
+     * conformant.
+     */
+    public void setGeneratingSource(boolean generatingSource)
+    {
+        this.generatingSource = generatingSource;
+    }
+
+    /**
+     * @return true iff code will be generated with callbacks to enable
+     * instruction thresholds
+     */
+    public boolean isGenerateObserverCount() {
+    	return generateObserverCount;
+    }
+
+   /**
+     * Turn on or off generation of code with callbacks to
+     * track the count of executed instructions.
+     * Currently only affects JVM byte code generation: this slows down the
+     * generated code, but code generated without the callbacks will not
+     * be counted toward instruction thresholds. Rhino's interpretive
+     * mode does instruction counting without inserting callbacks, so
+     * there is no requirement to compile code differently.
+     * @param generateObserverCount if true, generated code will contain
+     * calls to accumulate an estimate of the instructions executed.
+     */
+    public void setGenerateObserverCount(boolean generateObserverCount) {
+        this.generateObserverCount = generateObserverCount;
+    }
+
+    private ErrorReporter errorReporter;
+
+    private int languageVersion;
+    private boolean generateDebugInfo;
+    private boolean useDynamicScope;
+    private boolean reservedKeywordAsIdentifier;
+    private boolean allowMemberExprAsFunctionName;
+    private boolean xmlAvailable;
+    private int optimizationLevel;
+    private boolean generatingSource;
+    private boolean strictMode;
+    private boolean warningAsError;
+    private boolean generateObserverCount;
+    Hashtable activationNames;
+}
+