为ANTLR 4.5和字符串模板4语法构建Netbeans lexer

我一直在尝试在Netbeans 8.2中构建一个Lexer，以便为字符串模板v4文件提供正确的语法。问题是Netbeans模块只能访问ANTLR 3.3或4.5库，我找不到任何字符串模板v4（预编译或需要编译）Lexer语法文件

有人知道可以用ANTLR 3.3或4.5构建的字符串模板v4语法文件吗？我已经附上了我的代码和示例，它们正在使用ANTLR 4.5和

编辑1:

评论中有人问我一些例子，以及我到目前为止所做的尝试。我已经尝试使用来自的字符串模板Lexer。我从源代码的编译部分获取了代码，它似乎工作正常，但它非常有问题，因为它是用ANTLR 3.5构建的，我试图用Antl3.3运行它。语法着色工作正常，但读取文件时遇到问题，有时完全失败

我的第二次尝试是用。他们正确地加载了所有文件，因为我可以用4.5编译它，但是语法着色完全关闭了。与字符串模板v4相比，语法更适合Java

以下是我目前正在使用的代码，用于在Netbeans模块中构建Lexer：

语言提供者：

import org.netbeans.api.lexer.InputAttributes;
import org.netbeans.api.lexer.Language;
import org.netbeans.api.lexer.LanguagePath;
import org.netbeans.api.lexer.Token;
import org.netbeans.spi.lexer.LanguageEmbedding;
import org.netbeans.spi.lexer.LanguageProvider;

/**
 *
 * @author Cory
 */
@org.openide.util.lookup.ServiceProvider(service=org.netbeans.spi.lexer.LanguageProvider.class)
public class stLanguageProvider extends LanguageProvider {

    @Override
    public Language<?> findLanguage(String mimeType) {
        if ("text/x-st".equals(mimeType)){
            return new stLanguageHierarchy().language();
        }

        return null;
    }

    @Override
    public LanguageEmbedding<?> findLanguageEmbedding(Token<?> token, LanguagePath languagePath, InputAttributes inputAttributes) {
        return null;
    }

}

import org.netbeans.api.lexer.InputAttribute；
导入org.netbeans.api.lexer.Language；
导入org.netbeans.api.lexer.LanguagePath；
导入org.netbeans.api.lexer.Token；
导入org.netbeans.spi.lexer.LanguageEmbedding；
导入org.netbeans.spi.lexer.LanguageProvider；
/**
*
*@作者科里
*/
@org.openide.util.lookup.ServiceProvider（service=org.netbeans.spi.lexer.LanguageProvider.class）
公共类stLanguageProvider扩展了LanguageProvider{
@凌驾
公共语言findLanguage（字符串mimeType）{
if（“text/x-st”.equals（mimeType））{
返回新的stLanguageHierarchy（）.language（）；
}
返回null；
}
@凌驾
公共语言嵌入FindLanguageEmbeding（令牌令牌、语言路径LanguagePath、InputAttribute InputAttribute）{
返回null；
}
}

语言层次结构：

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.netbeans.api.lexer.Language;
import org.netbeans.spi.lexer.LanguageHierarchy;
import org.netbeans.spi.lexer.Lexer;
import org.netbeans.spi.lexer.LexerRestartInfo;

/**
 *
 * @author Cory
 */
public class stLanguageHierarchy extends LanguageHierarchy<stTokenId> {

    private static List<stTokenId> tokens = new ArrayList<stTokenId>();
    private static Map<Integer, stTokenId> idToToken = new HashMap<Integer, stTokenId>();

    private static final Language<stTokenId> language = new stLanguageHierarchy().language();

    public static Language<stTokenId> getLanguage() {
        return language;
    }

    static {
        TokenType[] tokenTypes = TokenType.values();
        for (TokenType tokenType : tokenTypes) {
            tokens.add(new stTokenId(tokenType.name(), tokenType.category, tokenType.id));
        }
        for (stTokenId token : tokens) {
            idToToken.put(token.ordinal(), token);
        }
    }

    /**
     * Returns an actual stTokenId from an id. This essentially allows
     * the syntax highlighter to decide the color of specific words.
     * @param id
     * @return
     */
    static synchronized stTokenId getToken(int id) {
        return idToToken.get(id);
    }

    @Override
    protected Collection<stTokenId> createTokenIds() {
        return tokens;
    }

    @Override
    protected Lexer<stTokenId> createLexer(LexerRestartInfo<stTokenId> lri) {
        return new stEditorLexer(lri);
    }

    @Override
    protected String mimeType() {
        return "text/x-st";
    }
}

import java.util.ArrayList；
导入java.util.Collection；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
导入org.netbeans.api.lexer.Language；
导入org.netbeans.spi.lexer.LanguageHierarchy；
导入org.netbeans.spi.lexer.lexer；
导入org.netbeans.spi.lexer.LexerRestartInfo；
/**
*
*@作者科里
*/
公共类stLanguageHierarchy扩展了LanguageHierarchy{
私有静态列表标记=新的ArrayList（）；
私有静态映射idToToken=newhashmap（）；
私有静态最终语言=新stLanguageHierarchy（）.Language（）；
公共静态语言getLanguage（）{
返回语言；
}
静止的{
TokenType[]tokenTypes=TokenType.values（）；
for（令牌类型令牌类型：令牌类型）{
添加（新的stTokenId（tokenType.name（），tokenType.category，tokenType.id））；
}
for（stTokenId令牌：令牌）{
idToToken.put（token.ordinal（），token）；
}
}
/**
*从一个id返回一个实际的stTokenId。这本质上允许
*语法高亮显示以决定特定单词的颜色。
*@param-id
*@返回
*/
静态同步stTokenId getToken（int-id）{
返回idToToken.get（id）；
}
@凌驾
受保护的集合CreateTokeIDS（）{
归还代币；
}
@凌驾
受保护的Lexer createLexer（LexerRestartInfo lri）{
返回新的stEditorLexer（lri）；
}
@凌驾
受保护的字符串mimeType（）{
返回“text/x-st”；
}
}

编辑器lexer：如果我能找到字符串模板lexer，应该在这里引入它。这里的代码使用的是ANTLR 4.5版本中的lexer

import org.antlr.parser.st4.STLexer；
导入org.antlr.v4.runtime.CommonTokenStream；
导入org.antlr.v4.runtime.Token；
导入org.netbeans.spi.lexer.lexer；
导入org.netbeans.spi.lexer.LexerInput；
导入org.netbeans.spi.lexer.LexerRestartInfo；
导入org.openide.util.Exceptions；
/**
*
*@作者科里
*/
公共类stEditorLexer实现Lexer{
私有静态最终字符串源_NAME=“stEditor”；
私有LexerRestartInfo lri；
专用stl-lexer；
公共存储库（LexerRestartInfo lri）{
this.lri=lri；
尝试
{
LexerInput LexerInput=lri.input（）；
AntlrCharStream charStream=新的AntlrCharStream（lexerInput，源名称）；
lexer=新的STLexer（charStream）；
lexer.setDelimiters（“$”，“$”）；
lexer.setChannel（STLexer.OFF_通道）；
lexer.reset（）；
AntlLexerState=（AntlLexerState）lri.state（）；
如果（状态！=null）{
状态。应用（lexer）；
}
}
捕获（例外情况除外）
{
例外情况。printStackTrace（ex）；
}
}
/**
*@返回lexer识别的下一个令牌，如果没有，则返回null
*更多要标记的字符（输入中可用）。
*/
@凌驾
public org.netbeans.api.lexer.Token nextToken（）{
Token Token=lexer.nextToken（）；
stTokenId-tokenId=null；
if（token.getType（）！=LexerInput.EOF）{
tokenId=stLanguageHierarchy.getToken（token.getType（））；
System.out.println（“nextToken-”+tokenId.toString（）+“”+token.getText（））；
}else if（lri.input（）.readLength（）>0）{
//输入上的剩余字符应标记化
//看https://netbeans.org/bugzilla/show_bug.cgi?id=240826
tokenId=stLanguageHierarchy.getToken（STLexer.HORZ_-WS）；
System.out.println（“nextToken-ERROR（as-WS）”；
}
if（tokenId==null）{
System.out.pri
import org.antlr.parser.st4.STLexer;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.Token;
import org.netbeans.spi.lexer.Lexer;
import org.netbeans.spi.lexer.LexerInput;
import org.netbeans.spi.lexer.LexerRestartInfo;
import org.openide.util.Exceptions;

/**
 *
 * @author Cory
 */
public class stEditorLexer implements Lexer<stTokenId> {

    private static final String SOURCE_NAME = "stEditor";

    private LexerRestartInfo<stTokenId> lri;
    private STLexer lexer;

    public stEditorLexer(LexerRestartInfo<stTokenId> lri) {
        this.lri = lri;
        try
        {
            LexerInput lexerInput = lri.input();
            AntlrCharStream charStream = new AntlrCharStream(lexerInput, SOURCE_NAME);
            lexer = new STLexer(charStream);
            lexer.setDelimiters('$', '$');
            lexer.setChannel(STLexer.OFF_CHANNEL);
            lexer.reset();
            AntlrLexerState state = (AntlrLexerState) lri.state();

            if (state != null) {
                state.apply(lexer);
            }
        }
        catch(Exception ex)
        {
            Exceptions.printStackTrace(ex);
        }
    }

    /**
     * @return the next token recognized by the lexer or null if there are no
     *         more characters (available in the input) to be tokenized.
     */
    @Override
    public org.netbeans.api.lexer.Token<stTokenId> nextToken() {
        Token token = lexer.nextToken();

        stTokenId tokenId = null;

        if (token.getType() != LexerInput.EOF) {
            tokenId  = stLanguageHierarchy.getToken(token.getType());
            System.out.println("nextToken - " + tokenId.toString() + " " + token.getText());
        }  else if (lri.input().readLength() > 0) {
            // Remaining chars on the input should be tokenized
            // see https://netbeans.org/bugzilla/show_bug.cgi?id=240826
            tokenId = stLanguageHierarchy.getToken(STLexer.HORZ_WS);
            System.out.println("nextToken - ERROR (as WS)");
        }

        if (tokenId == null) {
            System.out.println("nextToken - EOF");
            return null;
        }

        // According to the method specification, this must *not* return any
        // other Token instances than those obtained from the TokenFactory.
        return lri.tokenFactory().createToken(tokenId);
    }

    @Override
    public Object state() {
        return new AntlrLexerState(lexer._mode, lexer._modeStack);
    }

    @Override
    public void release() {
    }
}

import org.netbeans.api.lexer.Language;
import org.netbeans.api.lexer.TokenId;

/**
 *
 * @author Cory
 */
public enum TokenType implements TokenId {

    DOC_COMMENT(1, "other"),
    BLOCK_COMMENT(2, "comment"),
    LINE_COMMENT(3, "comment"),
    TMPL_COMMENT(4, "comment"),
    HORZ_WS(5, "other"),
    VERT_WS(6, "other"),
    ESCAPE(7, "separator"),
    LDELIM(8, "specialCharacter"),
    RBRACE(9, "separator"),
    TEXT(10, "text"),
    LBRACE(11, "separator"),
    RDELIM(12, "specialCharacter"),
    STRING(13, "string"),
    IF(14, "keyword"),
    ELSEIF(15, "keyword"),
    ELSE(16, "keyword"),
    ENDIF(17, "keyword"),
    SUPER(18, "keyword"),
    END(19, "keyword"),
    TRUE(20, "keyword"),
    FALSE(21, "keyword"),
    AT(22, "keyword"),
    ELLIPSIS(23, "keyword"),
    DOT(24, "separator"),
    COMMA(25, "separator"),
    COLON(26, "separator"),
    SEMI(27, "separator"),
    AND(28, "keyword"),
    OR(29, "keyword"),
    LPAREN(30, "separator"),
    RPAREN(31, "separator"),
    LBRACK(32, "separator"),
    RBRACK(33, "separator"),
    EQUALS(34, "separator"),
    BANG(35, "separator"),
    ERR_CHAR(36, "keyword"),
    ID(37, "keyword"),
    PIPE(38, "separator");

    public int id;
    public String category;
    public String text;

    private static final Language<stTokenId> langauge = new stLanguageHierarchy().language();

    private TokenType(int id, String category) {
        this.id = id;
        this.category = category;
    }

    public static TokenType valueOf(int id) {
        TokenType[] values = values();
        for (TokenType value : values) {
            if (value.id == id) {
                return value;
            }
        }
        throw new IllegalArgumentException("The id " + id + " is not recognized");
    }

    @Override
    public String primaryCategory() {
        return category;
    }

    public static final Language<stTokenId> getLanguage() {
        return langauge;
    }
}

<fontcolor name="keyword"           foreColor="blue" default="default"/>
<fontcolor name="comment"           foreColor="green" default="default"/>    
<fontcolor name="other"             foreColor="gray" default="default"/>    
<fontcolor name="specialCharacter"  foreColor="orange" default="default"/> 
<fontcolor name="text"              foreColor="pink" default="default"/> 
<fontcolor name="string"            foreColor="red" default="default"/> 
<fontcolor name="separator"         foreColor="magenta" default="default"/>