Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   ***** 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) 2004 Thomas E Enebo <enebo@acm.org>
  * 
  * 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 java.util.List;
 
 public class ParserSupport19 extends ParserSupport {
     @Override
     public AssignableNode assignable(Token lhsNode value) {
         checkExpression(value);
 
         switch (lhs.getType()) {
             case .:
                 throw new SyntaxException(.lhs.getPosition(),
                         .getCurrentLine(), "Can't change the value of self");
             case .:
                 throw new SyntaxException(.lhs.getPosition(),
                         .getCurrentLine(), "Can't assign to nil""nil");
             case .:
                 throw new SyntaxException(.lhs.getPosition(),
                         .getCurrentLine(), "Can't assign to true""true");
             case .:
                 throw new SyntaxException(.lhs.getPosition(),
                         .getCurrentLine(), "Can't assign to false""false");
             case .:
                 throw new SyntaxException(.lhs.getPosition(),
                         .getCurrentLine(), "Can't assign to __FILE__""__FILE__");
             case .:
                 throw new SyntaxException(.lhs.getPosition(),
                         .getCurrentLine(), "Can't assign to __LINE__""__LINE__");
             case .:
                 throw new SyntaxException(.lhs.getPosition(),
                         .getCurrentLine(), "Can't assign to __ENCODING__""__ENCODING__");
             case .// keyword args (only 2.0 grammar can ever call assignable with this token)
             case .// normal locals
                 // ENEBO: 1.9 has CURR nodes for local/block variables.  We don't.  I believe we follow proper logic
                 return .assign(lhs.getPosition(), (Stringlhs.getValue(), makeNullNil(value));
             case .:
                 if (isInDef() || isInSingle()) {
                    throw new SyntaxException(.lhs.getPosition(),
                            .getCurrentLine(), "dynamic constant assignment");
                }
                return new ConstDeclNode(lhs.getPosition(), (Stringlhs.getValue(), nullvalue);
            case .:
                return new InstAsgnNode(lhs.getPosition(), (Stringlhs.getValue(), value);
            case .:
                return new ClassVarAsgnNode(lhs.getPosition(), (Stringlhs.getValue(), value);
            case .:
                return new GlobalAsgnNode(lhs.getPosition(), (Stringlhs.getValue(), value);
        }
        throw new SyntaxException(.lhs.getPosition(), .getCurrentLine(),
                "identifier " + (Stringlhs.getValue() + " is not valid to set"lhs.getValue());
    }
    @Override
    public DStrNode createDStrNode(ISourcePosition position) {
        return new DStrNode(position.getEncoding());
    }
    @Override
    protected void getterIdentifierError(ISourcePosition positionString identifier) {
        throw new SyntaxException(.position"identifier " +
                identifier + " is not valid to get"identifier);
    }
    @Override
    public SplatNode newSplatNode(ISourcePosition positionNode node) {
        return new Splat19Node(positionmakeNullNil(node));
    }
    @Override
    public SValueNode newSValueNode(ISourcePosition positionNode node) {
        return new SValue19Node(positionnode);
    }
    private List<IntegerallocateNamedLocals(RegexpNode regexpNode) {
        String[] names = regexpNode.loadPattern(.getRuntime()).getNames();
        int length = names.length;
        List<Integerlocals = new ArrayList<Integer>();
        StaticScope scope = getCurrentScope();
        for (int i = 0; i < lengthi++) {
            // TODO: Pass by non-local-varnamed things but make sure consistent with list we get from regexp
            
            if (RubyYaccLexer.getKeyword(names[i]) == null) {
                int slot = scope.isDefined(names[i]);
                if (slot >= 0) {
                    locals.add(slot);
                } else {
                    locals.add(getCurrentScope().addVariableThisScope(names[i]));
                }
            }
        }
        return locals;
    }
    private boolean is7BitASCII(ByteList value) {
        return StringSupport.codeRangeScan(value.getEncoding(), value) == .;
    }
    // MRI: reg_fragment_setenc_gen
    public void setRegexpEncoding(RegexpNode endByteList value) {
        RegexpOptions options = end.getOptions();
        Encoding optionsEncoding = options.setup19(.getRuntime()) ;
        // Change encoding to one specified by regexp options as long as the string is compatible.
        if (optionsEncoding != null) {
            if (optionsEncoding != value.getEncoding() && !is7BitASCII(value)) {
                compileError(optionsEncodingvalue.getEncoding());
            }
            value.setEncoding(optionsEncoding);
        } else if (options.isEncodingNone()) {
            if (value.getEncoding() == . && !is7BitASCII(value)) {
                compileError(optionsEncodingvalue.getEncoding());
            }
            value.setEncoding(.);
        } else if (.getEncoding() == .) {
            if (!is7BitASCII(value)) {
                value.setEncoding(.); // This will raise later
            } else {
                value.setEncoding(.);
            }
        }
    }
    // TODO: Put somewhere more consolidated (similiar
    private char optionsEncodingChar(Encoding optionEncoding) {
        if (optionEncoding == .return 'n';
        if (optionEncoding == ....return 'e';
        if (optionEncoding == ....return 's';
        if (optionEncoding == .return 'u';
        return ' ';
    }
    protected void compileError(Encoding optionEncodingEncoding encoding) {
                "regexp encoding option '" + optionsEncodingChar(optionEncoding) +
                "' differs from source encoding '" + encoding + "'");
    }
    // MRI: reg_fragment_check
    @Override
    public void regexpFragmentCheck(RegexpNode endByteList value) {
        setRegexpEncoding(endvalue);
        RubyRegexp.preprocessCheck(.getRuntime(), value);
    }
    @Override
    public Node getMatchNode(Node firstNodeNode secondNode) {
        if (firstNode instanceof DRegexpNode) {
            return new Match2Node(firstNode.getPosition(), firstNodesecondNode);
        } else if (firstNode instanceof RegexpNode) {
            List<Integerlocals = allocateNamedLocals((RegexpNodefirstNode);
            if (locals.size() > 0) {
                int[] primitiveLocals = new int[locals.size()];
                for (int i = 0; i < primitiveLocals.lengthi++) {
                    primitiveLocals[i] = locals.get(i);
                }
                return new Match2CaptureNode(firstNode.getPosition(), firstNodesecondNodeprimitiveLocals);
            } else {
                return new Match2Node(firstNode.getPosition(), firstNodesecondNode);
            }
        } else if (secondNode instanceof DRegexpNode || secondNode instanceof RegexpNode) {
            return new Match3Node(firstNode.getPosition(), secondNodefirstNode);
        }
        return getOperatorCallNode(firstNode"=~"secondNode);
    }
    @Override
    public Node new_yield(ISourcePosition positionNode node) {
        if (node != null && node instanceof BlockPassNode) {
            throw new SyntaxException(.node.getPosition(),
                    .getCurrentLine(), "Block argument should not be given.");
        }
        if (node instanceof ArrayNode) {
            ArrayNode args = (ArrayNodenode;
            switch (args.size()) {
                case 0:
                    return new ZYieldNode(position);
                case 1:
                    return new YieldOneNode(positionargs);
                case 2:
                    return new YieldTwoNode(positionargs);
                case 3:
                    return new YieldThreeNode(positionargs);
            }
        }
        return new Yield19Node(positionnode);
    }
New to GrepCode? Check out our FAQ X