Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
***** BEGIN LICENSE BLOCK *****
* Version: CPL 1.0/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Common Public
* License Version 1.0 (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.eclipse.org/legal/cpl-v10.html
*
* 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.
*
* Copyright (C) 2002 Jan Arne Petersen
* Copyright (C) 2004 Thomas E Enebo
* Copyright (C) 2004 Anders Bengtsson
*
* 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 CPL, 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 CPL, the GPL or the LGPL.
***** END LICENSE BLOCK *****/
package org.jruby.parser;
import org.jcodings.Encoding;
import org.jruby.CompatVersion;
import org.jruby.Ruby;
import org.jruby.RubyInstanceConfig;
import org.jruby.runtime.DynamicScope;
import org.jruby.runtime.encoding.EncodingService;
import org.jruby.runtime.scope.ManyVarsDynamicScope;
import org.jruby.util.ByteList;
import org.jruby.util.KCode;
import org.jruby.util.SafePropertyAccessor;
public class ParserConfiguration {
private DynamicScope existingScope = null;
private boolean asBlock = false;
// What linenumber will the source think it starts from?
private int lineNumber = 0;
// Is this inline source (aka -e "...source...")
private boolean inlineSource = false;
// We parse evals more often in source so assume an eval parse.
private boolean isEvalParse = true;
// Should positions added extra IDE-friendly information and leave in all newline nodes
private boolean extraPositionInformation = false;
// Will parser parse Duby grammar Extensions
private boolean isDubyExtensionsEnabled = SafePropertyAccessor.getBoolean("jruby.duby.enabled", false);
// Should we display extra debug information while parsing?
private boolean isDebug = false;
// whether we should save the end-of-file data as DATA
private boolean saveData = false;
private CompatVersion version;
private Encoding defaultEncoding;
private Ruby runtime;
public ParserConfiguration(Ruby runtime, int lineNumber, boolean inlineSource,
CompatVersion version) {
this(runtime, lineNumber, false, inlineSource, version);
}
public ParserConfiguration(Ruby runtime, int lineNumber,
boolean extraPositionInformation, boolean inlineSource, CompatVersion version) {
this(runtime, lineNumber, extraPositionInformation, inlineSource, true, version, false);
}
public ParserConfiguration(Ruby runtime, int lineNumber, boolean extraPositionInformation,
boolean inlineSource, boolean isFileParse, CompatVersion version, boolean saveData) {
this.runtime = runtime;
this.inlineSource = inlineSource;
this.lineNumber = lineNumber;
this.extraPositionInformation = extraPositionInformation;
this.isEvalParse = !isFileParse;
this.version = version;
this.saveData = saveData;
}
public ParserConfiguration(Ruby runtime, int lineNumber, boolean extraPositionInformation,
boolean inlineSource, boolean isFileParse, RubyInstanceConfig config) {
this(runtime, lineNumber, extraPositionInformation, inlineSource, isFileParse, false, config);
}
public ParserConfiguration(Ruby runtime, int lineNumber, boolean extraPositionInformation,
boolean inlineSource, boolean isFileParse, boolean saveData, RubyInstanceConfig config) {
this(runtime, lineNumber, extraPositionInformation, inlineSource, isFileParse,
config.getCompatVersion(), saveData);
this.isDebug = config.isParserDebug();
}
private static final ByteList USASCII = new ByteList(new byte[]{'U', 'S', '-', 'A', 'S', 'C', 'I', 'I'});
public void setDefaultEncoding(Encoding encoding) {
this.defaultEncoding = encoding;
}
public Encoding getDefaultEncoding() {
if (defaultEncoding == null) {
defaultEncoding = getEncodingService().loadEncoding(USASCII);
}
return defaultEncoding;
}
public EncodingService getEncodingService() {
return runtime.getEncodingService();
}
/**
* Set whether this is an parsing of an eval() or not.
*
* @param isEvalParse says how we should look at it
*/
public void setEvalParse(boolean isEvalParse) {
this.isEvalParse = isEvalParse;
}
/**
* Should positions of nodes provide additional information in them (like character offsets).
* @param extraPositionInformation
*/
public void setExtraPositionInformation(boolean extraPositionInformation) {
this.extraPositionInformation = extraPositionInformation;
}
/**
* Should positions of nodes provide addition information?
* @return true if they should
*/
public boolean hasExtraPositionInformation() {
return extraPositionInformation;
}
public boolean isDebug() {
return isDebug;
}
/**
* Is the requested parse for an eval()?
*
* @return true if for eval
*/
public boolean isEvalParse() {
return isEvalParse;
}
public KCode getKCode() {
return runtime.getKCode();
}
public int getLineNumber() {
return lineNumber;
}
/**
* If we are performing an eval we should pass existing scope in.
* Calling this lets the parser know we need to do this.
*
* @param existingScope is the scope that captures new vars, etc...
*/
public void parseAsBlock(DynamicScope existingScope) {
this.asBlock = true;
this.existingScope = existingScope;
}
public Ruby getRuntime() {
return runtime;
}
/**
* This method returns the appropriate first scope for the parser.
*
* @return correct top scope for source to be parsed
*/
public DynamicScope getScope() {
if (asBlock) return existingScope;
// FIXME: We should really not be creating the dynamic scope for the root
// of the AST before parsing. This makes us end up needing to readjust
// this dynamic scope coming out of parse (and for local static scopes it
// will always happen because of $~ and $_).
// FIXME: Because we end up adjusting this after-the-fact, we can't use
// any of the specific-size scopes.
return new ManyVarsDynamicScope(new LocalStaticScope(null), existingScope);
}
/**
* Get the compatibility version we're targeting with this parse.
*/
public CompatVersion getVersion() {
return version;
}
/**
* Get whether we are saving the DATA contents of the file.
*/
public boolean isSaveData() {
return saveData;
}
/**
* Are we parsing source provided as part of the '-e' option to Ruby.
*
* @return true if source is from -e option
*/
public boolean isInlineSource() {
return inlineSource;
}
public boolean isDubyExtensionsEnabled() {
return isDubyExtensionsEnabled;
}
}
