Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   ***** BEGIN LICENSE BLOCK *****
   * Version: EPL 1.0/GPL 2.0/LGPL 2.1
   * The contents of this file are subject to the Eclipse 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
  * 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 EPL, 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 EPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 package org.jruby.parser;
 import org.jruby.Ruby;
 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;
     // 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;
     private int[] coverage = ;
     private static final int[] EMPTY_COVERAGE = new int[0];
     public ParserConfiguration(Ruby runtimeint lineNumberboolean inlineSource,
             CompatVersion version) {
     public ParserConfiguration(Ruby runtimeint lineNumber,
             boolean extraPositionInformationboolean inlineSourceCompatVersion version) {
     public ParserConfiguration(Ruby runtimeint lineNumberboolean extraPositionInformation,
             boolean inlineSourceboolean isFileParseCompatVersion versionboolean saveData) {
         this. = runtime;
         this. = inlineSource;
         this. = lineNumber;
         this. = extraPositionInformation;
         this. = !isFileParse;
         this. = version;
         this. = saveData;
     public ParserConfiguration(Ruby runtimeint lineNumberboolean extraPositionInformation,
             boolean inlineSourceboolean isFileParseRubyInstanceConfig config) {
     public ParserConfiguration(Ruby runtimeint lineNumberboolean extraPositionInformation,
             boolean inlineSourceboolean isFileParseboolean saveDataRubyInstanceConfig config) {
                config.getCompatVersion(), saveData);
        this. = config.isParserDebug();
    private static final ByteList USASCII = new ByteList(new byte[]{'U''S''-''A''S''C''I''I'});
    public void setDefaultEncoding(Encoding encoding) {
        this. = encoding;
    public Encoding getDefaultEncoding() {
        if ( == null) {
            if (.is2_0()) {
                 = .;
            } else {
                 = getEncodingService().loadEncoding();
        return ;
        return .getEncodingService();

Set whether this is an parsing of an eval() or not.

isEvalParse says how we should look at it
    public void setEvalParse(boolean isEvalParse) {
        this. = isEvalParse;

Should positions of nodes provide additional information in them (like character offsets).

    public void setExtraPositionInformation(boolean extraPositionInformation) {
        this. = extraPositionInformation;
Should positions of nodes provide addition information?

true if they should
    public boolean hasExtraPositionInformation() {
        return ;
    public boolean isDebug() {
        return ;

Is the requested parse for an eval()?

true if for eval
    public boolean isEvalParse() {
        return ;
    public KCode getKCode() {
        return .getKCode();
    public int getLineNumber() {
        return ;

If we are performing an eval we should pass existing scope in. Calling this lets the parser know we need to do this.

existingScope is the scope that captures new vars, etc...
    public void parseAsBlock(DynamicScope existingScope) {
        this. = true;
        this. = existingScope;
    public Ruby getRuntime() {
        return ;
This method returns the appropriate first scope for the parser.

correct top scope for source to be parsed
    public DynamicScope getScope() {
        if (return ;
        // 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.

Get the compatibility version we're targeting with this parse.
    public CompatVersion getVersion() {
        return ;
Get whether we are saving the DATA contents of the file.
    public boolean isSaveData() {
        return ;
Are we parsing source provided as part of the '-e' option to Ruby.

true if source is from -e option
    public boolean isInlineSource() {
        return ;

Zero out coverable lines as they're encountered
    public void coverLine(int i) {
        if (i < 0) return// JRUBY-6868: why would there be negative line numbers?
        if (.getCoverageData().isCoverageEnabled()) {
            if ( == null) {
                 = new int[i + 1];
            } else if (. <= i) {
                int[] newCoverage = new int[i + 1];
                Arrays.fill(newCoverage, -1);
                System.arraycopy(, 0, newCoverage, 0, .);
                 = newCoverage;
            // zero means coverable, but not yet covered
            [i] = 0;

Get the coverage array, indicating all coverable lines
    public int[] getCoverage() {
        return ;
New to GrepCode? Check out our FAQ X