Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.lexer.yacc;
  
  import java.util.List;
  

Author(s):
nicksieger
 
 public class ByteArrayLexerSource extends LexerSource {
     private Cursor readCursor;
     private Cursor mainCursorpushbackCursor;
     private final boolean captureSource;
 
     public ByteArrayLexerSource(String sourceNamebyte[] inList<Stringlistint line,
             boolean extraPositionInformation) {
         super(sourceNamelistlineextraPositionInformation);
         this. = new ByteArrayCursor(in);
         this. = ;
         this. = new PushbackCursor(new ByteList(128));
         this. = list != null;
     }
 
     @Override
     @SuppressWarnings("empty-statement")
     public boolean matchMarker(ByteList markerboolean indentboolean withNewlinethrows IOException {
         int matchPos = 0;
         if (indent) {
             for (int c = .at(matchPos);
                  c != . && Character.isWhitespace(c) && c != '\n';
                  c = .at(++matchPos));
         }
         for (int i = 0; i < marker.length(); i++) {
             if (.at(matchPos) != marker.get(i)) {
                 return false;
             }
             matchPos++;
         }
         if (withNewline) {
             int c = .at(matchPos++);
             if (c == '\r') {
                 // skip
                 c = .at(matchPos);
             }
             if (c != '\n' && c != .) {
                 return false;
             }
         }
         for (int i = 0; i < matchPosi++) {
             .read();
         }
         return true;
     }
 
     @Override
     public int read() {
         return .read();
     }
 
     @Override
     public ByteList readUntil(char markerthrows IOException {
         return readUntil(markertrue);
     }
 
     private ByteList readUntil(char markerboolean nullIfEndthrows IOException {
         ByteList result = new ByteList(128);
         int c;
         while ((c = .read()) != marker && c != .) {
             result.append(c);
         }
 
         if (nullIfEnd && c == .) {
             return null;
         }
 
         return result;
     }
 
     @Override
     public ByteList readLineBytes() throws IOException {
         return readUntil('\n'false);
     }
 
     @Override
     public int skipUntil(int markerthrows IOException {
         int c;
         do {
             c = .read();
         } while (c != marker && c != .);
         return c;
     }
 
     @Override
     public void unread(int c) {
         if (c == .) {
            return;
        }
        if () {
            uncaptureFeature(c);
        }
        .unread(c);
    }
    @Override
    public void unreadMany(CharSequence line) {
        for (int i = line.length() - 1; i >= 0; i--) {
            unread(line.charAt(i));
        }
    }
    @Override
    public boolean peek(int cthrows IOException {
        return .at(0) == c;
    }
    @Override
    public boolean lastWasBeginOfLine() {
        int c = .at(-1);
        return c == '\n' || c == .;
    }
    @Override
    public boolean wasBeginOfLine() {
        final int c = .at(-2);
        return c == '\n' || (c == . && c != .at(-1));
    }
    @Override
    public String getCurrentLine() {
        int lineOffset = 0;
        int c;
        while ((c = .at(lineOffset - 1)) != '\n' && c != .) {
            lineOffset--;
        }
        String ptr = makePointer(-(lineOffset + 1));
        StringBuilder lineBuilder = new StringBuilder();
        for (c = .at(lineOffset); c != '\n' && c != .c = .at(++lineOffset)) {
            lineBuilder.append((charc);
        }
        lineBuilder.append('\n').append(ptr);
        return lineBuilder.toString();
    }
    @Override
    public InputStream getRemainingAsStream() {
        ByteList buf = new ByteList(128);
        int c;
        while ((c = read()) != .) {
            buf.append(c);
        }
        return new ByteArrayInputStream(buf.getUnsafeBytes(), 0, buf.length());
    }
    private int forward(int c) {
        if (c != .) {
            ++;
            switch (c) {
                case '\n':
                    ++;
                    break;
                case '\r':
                    // We are peeking ahead.  but we need to make sure we uncapture after this read.  Otherwise
                    // we double report \n 
                    if ((c = read()) != '\n') {
                        unread(c);
                        c = '\r';
                    } else {
                      if (){
                        uncaptureFeature(c);
                        captureFeature('\r');
                      }
                    }
                    break;
            }
        }
        if () {
            captureFeature(c);
        }
        return c;
    }
    private void backward(int c) {
        --;
        if (c == '\n') {
            --;
            if (.at(-1) == '\r') {
                unread('\r');
            }
        }
    }
    interface Cursor {
        int read();
        void unread(int c);
        
Read the character at the offset given without moving the cursor

Parameters:
offset relative to the current cursor position; -1 means previous character
Returns:
the character at that offset
        int at(int offset);
    }
    class ByteArrayCursor implements Cursor {
        private final byte[] region;
        private int index;
        public ByteArrayCursor(byte[] region) {
            this. = region;
            this. = 0;
        }
        public int read() {
            if ( >= .) {
                return forward(.);
            }
            return 0xff & forward([++]);
        }
        public void unread(int c) {
            if ( > 0 && [ - 1] == c) {
                --;
                backward(c);
            } else {
                 = ;
                .unread(c);
            }
        }
        public int at(int offset) {
            int location =  + offset;
            if (location >= . || location < 0) {
                return .;
            }
            return 0xff & [location];
        }
    }
    class PushbackCursor implements Cursor {
        private final Cursor parent;
        private final ByteList region;
        public PushbackCursor(Cursor prevByteList region) {
            this. = prev;
            this. = region;
        }
        public int read() {
            int index = .length() - 1;
            if (index < 0) {
                 = ;
                return .read();
            }
            int c = 0xff & .get(index);
            .setRealSize(index);
            return forward(c);
        }
        public void unread(int c) {
            .append(c);
            backward(c);
        }
        public int at(int offset) {
            if (offset < 0) {
                return .at(offset);
            } else if (offset >= .length()) {
                return .at(offset - .length());
            } else {
                return 0xff & .get(.length() - offset - 1);
            }
        }
    }
New to GrepCode? Check out our FAQ X