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

        return null;
    }

@org.openide.util.lookup.ServiceProvider(service=org.netbeans.spi.lexer.LanguageProvider.class)
public class CMinusLanguageProvider extends LanguageProvider {

public class CMinusTokenId implements TokenId {

    private final String name;
    private final String primaryCategory;
    private final int id;

    public CMinusTokenId(
            String name,
            String primaryCategory,
            int id) {
        this.name = name;
        this.primaryCategory = primaryCategory;
        this.id = id;
    }

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

    @Override
    public int ordinal() {
        return id;
    }

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

public class CMinusLanguageHierarchy extends LanguageHierarchy<CMinusTokenId>{

    private static List<CMinusTokenId> tokens;
    private static Map<Integer, CMinusTokenId> idToToken;

    private static final Language<CMinusTokenId> language = new CMinusLanguageHierarchy().language();

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

    /**
     * Initializes the list of tokens with IDs generated from the ANTLR
     * token file.
     */
    private static void init() {
        AntlrTokenReader reader = new AntlrTokenReader();
        tokens = reader.readTokenFile();
        idToToken = new HashMap<Integer, CMinusTokenId>();
        for (CMinusTokenId token : tokens) {
            idToToken.put(token.ordinal(), token);
        }
    }

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

    /**
     * Initializes the tokens in use.
     *
     * @return
     */
    @Override
    protected synchronized Collection<CMinusTokenId> createTokenIds() {
        if (tokens == null) {
            init();
        }
        return tokens;
    }

    /**
     * Creates a lexer object for use in syntax highlighting.
     *
     * @param info
     * @return
     */
    @Override
    protected synchronized Lexer<CMinusTokenId> createLexer(LexerRestartInfo<CMinusTokenId> info) {
        return new CMinusEditorLexer(info);
    }

    /**
     * Returns the mime type of this programming language ("text/x-cm). This
     * allows NetBeans to load the appropriate editors and file loaders when
     * a file with the cm file extension is loaded.
     *
     * @return
     */
    @Override
    protected String mimeType() {
        return "text/x-cm";
    }

public class CMinusEditorLexer implements Lexer<CMinusTokenId>{

    private LexerRestartInfo<CMinusTokenId> info;
    private CMinusLexer lexer;

    public CMinusEditorLexer(LexerRestartInfo<CMinusTokenId> info) {
        this.info = info;
        ANTLRCharStream charStream = new ANTLRCharStream(info.input(), "CMinusEditor", true);
        lexer = new CMinusLexer(charStream);
    }

    @Override
    public org.netbeans.api.lexer.Token<CMinusTokenId> nextToken() {
        org.antlr.runtime.Token token = lexer.nextToken();

        Token<CMinusTokenId> createdToken = null;

        if (token.getType() != -1){
            CMinusTokenId tokenId  = CMinusLanguageHierarchy.getToken(token.getType());
            createdToken = info.tokenFactory().createToken(tokenId);
        }  else if(info.input().readLength() > 0){
            CMinusTokenId tokenId  = CMinusLanguageHierarchy.getToken(CMinusLexer.WS);
            createdToken = info.tokenFactory().createToken(tokenId);
        }

        return createdToken;
    }

   @Override
   public Object state() {
       return null;
   }

   @Override
   public void release() {
   }

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.demo.cminus.syntaxhighlighter.utils;


import java.util.ArrayList;
import java.util.List;
import org.antlr.runtime.CharStream;
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;

    private boolean ignoreCase = false;

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

    @Override
    public String substring(int start, int stop) {
        return input.readText(start, stop).toString();
    }

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

    @Override
    public int getLine() {
        return line;
    }

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

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

    @Override
    public int getCharPositionInLine() {
        return charPositionInLine;
    }

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

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

    @Override
    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);

        if (ignoreCase && (c != -1)){
            return Character.toLowerCase((char)c);
        } else {
            return c;
        }
    }

    @Override
    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 = markers.get(markDepth);
        }
        state.index = index;
        state.line = line;
        state.charPositionInLine = charPositionInLine;
        lastMarker = markDepth;

        return markDepth;
    }

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

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

    @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 < 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();
        }
    }

    @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();
        if (result == LexerInput.EOF) {
            result = CharStream.EOF;
        }

        return result;
    }

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