001: /* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
002: *
003: * ***** BEGIN LICENSE BLOCK *****
004: * Version: MPL 1.1/GPL 2.0
005: *
006: * The contents of this file are subject to the Mozilla Public License Version
007: * 1.1 (the "License"); you may not use this file except in compliance with
008: * the License. You may obtain a copy of the License at
009: * http://www.mozilla.org/MPL/
010: *
011: * Software distributed under the License is distributed on an "AS IS" basis,
012: * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
013: * for the specific language governing rights and limitations under the
014: * License.
015: *
016: * The Original Code is Rhino code, released
017: * May 6, 1999.
018: *
019: * The Initial Developer of the Original Code is
020: * Netscape Communications Corporation.
021: * Portions created by the Initial Developer are Copyright (C) 1997-1999
022: * the Initial Developer. All Rights Reserved.
023: *
024: * Contributor(s):
025: * Igor Bukanov, igor@fastmail.fm
026: * Bob Jervis
027: *
028: * Alternatively, the contents of this file may be used under the terms of
029: * the GNU General Public License Version 2 or later (the "GPL"), in which
030: * case the provisions of the GPL are applicable instead of those above. If
031: * you wish to allow use of your version of this file only under the terms of
032: * the GPL and not to allow others to use your version of this file under the
033: * MPL, indicate your decision by deleting the provisions above and replacing
034: * them with the notice and other provisions required by the GPL. If you do
035: * not delete the provisions above, a recipient may use your version of this
036: * file under either the MPL or the GPL.
037: *
038: * ***** END LICENSE BLOCK ***** */
039:
040: package org.mozilla.javascript;
041:
042: import java.util.Hashtable;
043:
044: public class CompilerEnvirons {
045: public CompilerEnvirons() {
046: errorReporter = DefaultErrorReporter.instance;
047: languageVersion = Context.VERSION_DEFAULT;
048: generateDebugInfo = true;
049: useDynamicScope = false;
050: reservedKeywordAsIdentifier = false;
051: allowMemberExprAsFunctionName = false;
052: xmlAvailable = true;
053: optimizationLevel = 0;
054: generatingSource = true;
055: strictMode = false;
056: warningAsError = false;
057: generateObserverCount = false;
058: }
059:
060: public void initFromContext(Context cx) {
061: setErrorReporter(cx.getErrorReporter());
062: this .languageVersion = cx.getLanguageVersion();
063: useDynamicScope = cx.compileFunctionsWithDynamicScopeFlag;
064: generateDebugInfo = (!cx.isGeneratingDebugChanged() || cx
065: .isGeneratingDebug());
066: reservedKeywordAsIdentifier = cx
067: .hasFeature(Context.FEATURE_RESERVED_KEYWORD_AS_IDENTIFIER);
068: allowMemberExprAsFunctionName = cx
069: .hasFeature(Context.FEATURE_MEMBER_EXPR_AS_FUNCTION_NAME);
070: strictMode = cx.hasFeature(Context.FEATURE_STRICT_MODE);
071: warningAsError = cx
072: .hasFeature(Context.FEATURE_WARNING_AS_ERROR);
073: xmlAvailable = cx.hasFeature(Context.FEATURE_E4X);
074:
075: optimizationLevel = cx.getOptimizationLevel();
076:
077: generatingSource = cx.isGeneratingSource();
078: activationNames = cx.activationNames;
079:
080: // Observer code generation in compiled code :
081: generateObserverCount = cx.generateObserverCount;
082: }
083:
084: public final ErrorReporter getErrorReporter() {
085: return errorReporter;
086: }
087:
088: public void setErrorReporter(ErrorReporter errorReporter) {
089: if (errorReporter == null)
090: throw new IllegalArgumentException();
091: this .errorReporter = errorReporter;
092: }
093:
094: public final int getLanguageVersion() {
095: return languageVersion;
096: }
097:
098: public void setLanguageVersion(int languageVersion) {
099: Context.checkLanguageVersion(languageVersion);
100: this .languageVersion = languageVersion;
101: }
102:
103: public final boolean isGenerateDebugInfo() {
104: return generateDebugInfo;
105: }
106:
107: public void setGenerateDebugInfo(boolean flag) {
108: this .generateDebugInfo = flag;
109: }
110:
111: public final boolean isUseDynamicScope() {
112: return useDynamicScope;
113: }
114:
115: public final boolean isReservedKeywordAsIdentifier() {
116: return reservedKeywordAsIdentifier;
117: }
118:
119: public void setReservedKeywordAsIdentifier(boolean flag) {
120: reservedKeywordAsIdentifier = flag;
121: }
122:
123: public final boolean isAllowMemberExprAsFunctionName() {
124: return allowMemberExprAsFunctionName;
125: }
126:
127: public void setAllowMemberExprAsFunctionName(boolean flag) {
128: allowMemberExprAsFunctionName = flag;
129: }
130:
131: public final boolean isXmlAvailable() {
132: return xmlAvailable;
133: }
134:
135: public void setXmlAvailable(boolean flag) {
136: xmlAvailable = flag;
137: }
138:
139: public final int getOptimizationLevel() {
140: return optimizationLevel;
141: }
142:
143: public void setOptimizationLevel(int level) {
144: Context.checkOptimizationLevel(level);
145: this .optimizationLevel = level;
146: }
147:
148: public final boolean isGeneratingSource() {
149: return generatingSource;
150: }
151:
152: public final boolean isStrictMode() {
153: return strictMode;
154: }
155:
156: public final boolean reportWarningAsError() {
157: return warningAsError;
158: }
159:
160: /**
161: * Specify whether or not source information should be generated.
162: * <p>
163: * Without source information, evaluating the "toString" method
164: * on JavaScript functions produces only "[native code]" for
165: * the body of the function.
166: * Note that code generated without source is not fully ECMA
167: * conformant.
168: */
169: public void setGeneratingSource(boolean generatingSource) {
170: this .generatingSource = generatingSource;
171: }
172:
173: /**
174: * @return true iff code will be generated with callbacks to enable
175: * instruction thresholds
176: */
177: public boolean isGenerateObserverCount() {
178: return generateObserverCount;
179: }
180:
181: /**
182: * Turn on or off generation of code with callbacks to
183: * track the count of executed instructions.
184: * Currently only affects JVM byte code generation: this slows down the
185: * generated code, but code generated without the callbacks will not
186: * be counted toward instruction thresholds. Rhino's interpretive
187: * mode does instruction counting without inserting callbacks, so
188: * there is no requirement to compile code differently.
189: * @param generateObserverCount if true, generated code will contain
190: * calls to accumulate an estimate of the instructions executed.
191: */
192: public void setGenerateObserverCount(boolean generateObserverCount) {
193: this .generateObserverCount = generateObserverCount;
194: }
195:
196: private ErrorReporter errorReporter;
197:
198: private int languageVersion;
199: private boolean generateDebugInfo;
200: private boolean useDynamicScope;
201: private boolean reservedKeywordAsIdentifier;
202: private boolean allowMemberExprAsFunctionName;
203: private boolean xmlAvailable;
204: private int optimizationLevel;
205: private boolean generatingSource;
206: private boolean strictMode;
207: private boolean warningAsError;
208: private boolean generateObserverCount;
209: Hashtable activationNames;
210: }
|