Fatal编程技术网
  • antlr/
  • NetBeans平台语言和ANTLR lexer

NetBeans平台语言和ANTLR lexer

antlr antlr4

NetBeans平台语言和ANTLR lexer,antlr,antlr4,Antlr,Antlr4,如何使NetBeans LexerInput适应ANTLR的字符流。我有下一个实现，但工作不好。我想通过ANTLR lexer向NetBeans平台添加一种新语言 Lexer只发出EOF，但是令牌类型是ok的，我不明白 import java.util.ArrayList; import java.util.List; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.misc.Interval; import

如何使NetBeans LexerInput适应ANTLR的字符流。我有下一个实现，但工作不好。我想通过ANTLR lexer向NetBeans平台添加一种新语言

Lexer只发出EOF，但是令牌类型是ok的，我不明白

import java.util.ArrayList;
import java.util.List;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.misc.Interval;
import org.netbeans.spi.lexer.LexerInput;

/**
 * @author jonny
 */
public class AntlrCharStream implements CharStream {


    private class CharStreamState {
        int index;
        int line;
        int charPositionInLine;
    }

    private int line = 1;
    private int charPositionInLine = 0;
    private LexerInput input;
    private String name;
    private int index = 0;
    private List<CharStreamState> markers;
    private int markDepth = 0;
    private int lastMarker;

    public AntlrCharStream(LexerInput input, String name) {
        this.input = input;
        this.name = name;
    }

    @Override
    public String getText(Interval intrvl) {
        return input.readText().toString();
    }

    public String substring(int start, int stop) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public int LT(int i) {
        return LA(i);
    }

    public int getLine() {
        return line;
    }

    public void setLine(int line) {
        this.line = line;
    }

    public void setCharPositionInLine(int pos) {
        this.charPositionInLine = pos;
    }

    public int getCharPositionInLine() {
        return charPositionInLine;
    }

    public void consume() {
        int c = input.read();
        index++;
        charPositionInLine++;

        if (c == '\n') {
            line++;
            charPositionInLine = 0;
        }
    }

    public int LA(int i) {
        if (i == 0) {
            return 0; // undefined
        }

        int c = 0;
        for (int j = 0; j < i; j++) {
            c = read();
        }
        backup(i);
        return c;
    }

    public int mark() {
        if (markers == null) {
            markers = new ArrayList<CharStreamState>();
            markers.add(null); // depth 0 means no backtracking, leave blank
        }
        markDepth++;
        CharStreamState state = null;
        if (markDepth >= markers.size()) {
            state = new CharStreamState();
            markers.add(state);
        } else {
            state = (CharStreamState) markers.get(markDepth);
        }
        state.index = index;
        state.line = line;
        state.charPositionInLine = charPositionInLine;
        lastMarker = markDepth;

        return markDepth;
    }

    public void rewind() {
        rewind(lastMarker);
    }

    public void rewind(int marker) {
        CharStreamState state = (CharStreamState) markers.get(marker);
        // restore stream state
        seek(state.index);
        line = state.line;
        charPositionInLine = state.charPositionInLine;
        release(marker);
    }

    public void release(int marker) {
        // unwind any other markers made after m and release m
        markDepth = marker;
        // release this marker
        markDepth--;
    }

    public void seek(int index) {
        if (index < this.index) {
            backup(this.index - index);
            this.index = index; // just jump; don't update stream state (line, ...)
            return;
        }

        // seek forward, consume until p hits index
        while (this.index < index) {
            consume();
        }
    }

    public int index() {
        return index;
    }

    public int size() {
        return -1; //unknown...
    }

    public String getSourceName() {
        return name;
    }

    private int read() {
        int result = input.read();
        if (result == LexerInput.EOF) {
            result = CharStream.EOF;
        }

        return result;
    }

    private void backup(int count) {
        input.backup(count);
    }
}


import java.util.ArrayList；
导入java.util.List；
导入org.antlr.v4.runtime.CharStream；
导入org.antlr.v4.runtime.misc.Interval；
导入org.netbeans.spi.lexer.LexerInput；
/**
*@作者jonny
*/
公共类AntlrCharStream实现了CharStream{
私有类状态{
整数指数；
内线；
int-charPositionInLine；
}
专用int线=1；
私有int charPositionInLine=0；
专用输入；
私有字符串名称；
私有整数指数=0；
私有列表标记；
私有int markDepth=0；
私有标记；
公共AntlrCharStream（LexerInput输入，字符串名称）{
这个输入=输入；
this.name=名称；
}
@凌驾
公共字符串getText（Interval intrvl）{
返回input.readText（）.toString（）；
}
公共字符串子字符串（int开始，int停止）{
抛出新的UnsupportedOperationException（“尚未支持”）；
}
公共内部LT（内部i）{
返回LA（i）；
}
公共int getLine（）{
回流线；
}
公共无效设置线（内部线）{
this.line=line；
}
公共无效setCharPositionInLine（内部位置）{
this.charPositionInLine=pos；
}
public int getCharPositionInLine（）{
返回charPositionInLine；
}
公共消费（）{
int c=input.read（）；
索引++；
charPositionInLine++；
如果（c=='\n'）{
line++；
charPositionInLine=0；
}
}
公共内部LA（内部i）{
如果（i==0）{
返回0；//未定义
}
int c=0；
对于（int j=0；j=markers.size（））{
state=新的CharStreamState（）；
添加（状态）；
}否则{
state=（CharStreamState）markers.get（markDepth）；
}
state.index=索引；
state.line=行；
state.charPositionInLine=charPositionInLine；
lastMarker=标记深度；
返回深度；
}
公共无效倒带（）{
倒带（最后标记）；
}
公共无效回放（整数标记）{
CharStreamState状态=（CharStreamState）markers.get（marker）；
//恢复流状态
seek（state.index）；
line=state.line；
charPositionInLine=state.charPositionInLine；
释放（标记）；
}
公共无效释放（int标记）{
//松开m之后制作的任何其他标记，然后松开m
标记深度=标记；
//释放这个标记
标记深度--；
}
公共无效搜索（整数索引）{
如果（索引<此索引）{
备份（this.index-index）；
this.index=index；//只需跳转；不更新流状态（行，…）
返回；
}
//向前搜索，消耗直到p到达索引
而（this.index

'[@-1,6:6=''，2:2]'
'[@-1,7:7='',,2:3]'
'[@-1,8:15='',,2:4]'
'[@-1,16:16='',,2:12]'
'[@-1,17:23='',,2:13]'
'[@-1,24:24='',,2:20]'
'[@-1,25:25='',,2:21]'
'[@-1,26:26='',,3:0]'
'[@-1,27:27='',,3:1]'
'[@-1,28:28='',,3:2]'
'[@-1,29:29='',,3:3]'
'[@-1,30:37='',,3:4]'
'[@-1,38:38='',,3:12]'
'[@-1,39:43='',,3:13]'
'[@-1,44:44='',,3:18]'
'[@-1,45:48='',,3:19]'
'[@-1,49:49='',,3:23]'
'[@-1,50:53='',,3:24]'
'[@-1,54:54='',,3:28]'
'[@-1,55:56='',,3:29]'
'[@-1,57:57='',,3:31]'
'[@-1,58:57='',,4:32]'
谷歌查询“antlr netbeans”显示了许多文章，尽管是针对v3而不是v4。例如。，

你运行了不同的查询吗？

我还尝试使用ANTLR 4制作一个NetBeans插件。下面是我在修改中的
AntlrCharStream
后得出的结论。到目前为止，它对我有效

import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.misc.Interval;
import org.netbeans.spi.lexer.LexerInput;

public class AntlrCharStream implements CharStream {

    private final LexerInput input;
    private final String name;
    private int index = 0;
    private int markDepth = 0;

    public AntlrCharStream(LexerInput input, String name) {
        this.input = input;
        this.name = name;
    }

    @Override
    public String getText(Interval interval) {
        throw new UnsupportedOperationException("Not supported.");
    }

    @Override
    public void consume() {
        int character = read();
        if (character == EOF) {
            backup(1);
            throw new IllegalStateException("Attempting to consume EOF");
        }
        index++;
    }

    @Override
    public int LA(int lookaheadAmount) {
        if (lookaheadAmount < 0) {
            return lookBack(-lookaheadAmount);
        } else if (lookaheadAmount > 0) {
            return lookAhead(lookaheadAmount);
        } else {
            return 0; //Behaviour is undefined when lookaheadAmount == 0
        }
    }

    private int lookBack(int amount) {
        backup(amount);
        int character = read();
        for (int i = 1; i < amount; i++) {
            read();
        }
        return character;
    }

    private int lookAhead(int amount) {
        int character = 0;
        for (int i = 0; i < amount; i++) {
            character = read();
        }
        backup(amount);
        return character;
    }

    @Override
    public int mark() {
        return ++markDepth;
    }

    @Override
    public void release(int marker) {
        // unwind any other markers made after m and release m
        markDepth = marker;
        // release this marker
        markDepth--;
    }

    @Override
    public void seek(int index) {
        if (index < 0) {
            throw new IllegalArgumentException(String.format("Invalid index (%s < 0)", index));
        }

        if (index < this.index) {
            backup(this.index - index);
            this.index = index;
            return;
        }

        // seek forward, consume until p hits index
        while (this.index < index) {
            consume();
        }
    }

    @Override
    public int index() {
        return index;
    }

    @Override
    public int size() {
        throw new UnsupportedOperationException("Stream size unknown");
    }

    @Override
    public String getSourceName() {
        return name;
    }

    private int read() {
        int result = input.read();
        if (result == LexerInput.EOF) {
            return EOF;
        } else {
            return result;
        }
    }

    private void backup(int count) {
        input.backup(count);
    }
}

import org.antlr.v4.runtime.CharStream；
导入org.antlr.v4.runtime.misc.Interval；
导入org.netbeans.spi.lexer.LexerInput；
公共类AntlrCharStream实现了CharStream{
专用最终输入；
私有最终字符串名；
私有整数指数=0；
私有int markDepth=0；
公共AntlrCharStream（LexerInput输入，字符串名称）{
这个输入=输入；
this.name=名称；
}
@凌驾
公共字符串getText（间隔）{
抛出新的UnsupportedOperationException（“不受支持”）；
}
@凌驾
公共消费（）{
int character=read（）；
如果（字符==EOF）{
备份（1）；
抛出新的非法状态异常（“尝试使用EOF”）；
}
索引++；
}
@凌驾
公共内部LA（内部lookaheadAmount）{
如果（lookaheadAmount<0）{
返回回望（-lookaheadAmount）；
}否则如果（lookaheadAmount>0）{
返回前瞻（lookaheadAmount）；
}否则{
返回0；//lookaheadAmount==0时行为未定义
}
}
私有int回望（int）

import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.misc.Interval;
import org.netbeans.spi.lexer.LexerInput;

public class AntlrCharStream implements CharStream {

    private final LexerInput input;
    private final String name;
    private int index = 0;
    private int markDepth = 0;

    public AntlrCharStream(LexerInput input, String name) {
        this.input = input;
        this.name = name;
    }

    @Override
    public String getText(Interval interval) {
        throw new UnsupportedOperationException("Not supported.");
    }

    @Override
    public void consume() {
        int character = read();
        if (character == EOF) {
            backup(1);
            throw new IllegalStateException("Attempting to consume EOF");
        }
        index++;
    }

    @Override
    public int LA(int lookaheadAmount) {
        if (lookaheadAmount < 0) {
            return lookBack(-lookaheadAmount);
        } else if (lookaheadAmount > 0) {
            return lookAhead(lookaheadAmount);
        } else {
            return 0; //Behaviour is undefined when lookaheadAmount == 0
        }
    }

    private int lookBack(int amount) {
        backup(amount);
        int character = read();
        for (int i = 1; i < amount; i++) {
            read();
        }
        return character;
    }

    private int lookAhead(int amount) {
        int character = 0;
        for (int i = 0; i < amount; i++) {
            character = read();
        }
        backup(amount);
        return character;
    }

    @Override
    public int mark() {
        return ++markDepth;
    }

    @Override
    public void release(int marker) {
        // unwind any other markers made after m and release m
        markDepth = marker;
        // release this marker
        markDepth--;
    }

    @Override
    public void seek(int index) {
        if (index < 0) {
            throw new IllegalArgumentException(String.format("Invalid index (%s < 0)", index));
        }

        if (index < this.index) {
            backup(this.index - index);
            this.index = index;
            return;
        }

        // seek forward, consume until p hits index
        while (this.index < index) {
            consume();
        }
    }

    @Override
    public int index() {
        return index;
    }

    @Override
    public int size() {
        throw new UnsupportedOperationException("Stream size unknown");
    }

    @Override
    public String getSourceName() {
        return name;
    }

    private int read() {
        int result = input.read();
        if (result == LexerInput.EOF) {
            return EOF;
        } else {
            return result;
        }
    }

    private void backup(int count) {
        input.backup(count);
    }
}



import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.misc.Interval;
import org.netbeans.spi.lexer.LexerInput;

public class AntlrCharStream implements CharStream {

  private final LexerInput input;
  private final String name;
  private int index = 0;
  private int markDepth = 0;

  public AntlrCharStream(LexerInput input, String name) {
    this.input = input;
    this.name = name;
  }

  @Override
  public String getText(Interval interval) {
    int start = interval.a;
    int stop = interval.b;

    if (start < 0 || stop < start) {
      return "";
    }

    final int pos = this.index;
    final int length = interval.length();
    final char[] data = new char[length];

    seek(interval.a);
    int r = 0;
    while (r < length) {
      final int character = read();
      if (character == EOF) {
        break;
      }

      data[r] = (char) character;
      r++;
    }
    seek(pos);

    if (r > 0) {
      return new String(data, 0, r);
    } else {
      return "";
    }
  }

  @Override
  public void consume() {
    int character = read();
    if (character == EOF) {
      backup(1);
      throw new IllegalStateException("Attempting to consume EOF");
    }
  }

  @Override
  public int LA(int lookaheadAmount) {
    if (lookaheadAmount < 0) {
      return lookBack(-lookaheadAmount);
    } else if (lookaheadAmount > 0) {
      return lookAhead(lookaheadAmount);
    } else {
      return 0; //Behaviour is undefined when lookaheadAmount == 0
    }
  }

  private int lookBack(int amount) {
    backup(amount);
    int character = read();
    for (int i = 1; i < amount; i++) {
      read();
    }
    return character;
  }

  private int lookAhead(int amount) {
    int character = 0;
    for (int i = 0; i < amount; i++) {
      character = read();
    }
    backup(amount);
    return character;
  }

  @Override
  public int mark() {
    return ++markDepth;
  }

  @Override
  public void release(int marker) {
    // unwind any other markers made after m and release m
    markDepth = marker;
    // release this marker
    markDepth--;
  }

  @Override
  public void seek(int index) {
    if (index < 0) {
      throw new IllegalArgumentException(String.format("Invalid index (%s < 0)", index));
    }

    if (index < this.index) {
      backup(this.index - index);
      return;
    }

    // seek forward, consume until p hits index
    while (this.index < index) {
      consume();
    }
  }

  @Override
  public int index() {
    return index;
  }

  @Override
  public int size() {
    return -1; //unknown...
  }

  @Override
  public String getSourceName() {
    return name;
  }

  private int read() {
    int result = input.read();
    index++;

    if (result == LexerInput.EOF) {
      return EOF;
    } else {
      return result;
    }
  }

  private void backup(int count) {
    input.backup(count);
    index -= count;
  }
}