import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
public LanguageEmbedding<?> findLanguageEmbedding (
    Token token, 
    LanguagePath languagePath, 
    InputAttributes inputAttributes
) {
    String mimeType = languagePath.innerLanguage ().mimeType ();
    if (!LanguagesManager.getDefault ().isSupported (mimeType)) return null;
    Language<STokenId> language = getTokenImport (mimeType, token);
    if (language == null) 
        language = getPreprocessorImport (languagePath, token);
    if (language == null) return null;
    Integer i = (Integer) token.getProperty ("startSkipLength");
    int startSkipLength = i == null ? 0 : i.intValue ();
    i = (Integer) token.getProperty ("endSkipLength");
    int endSkipLength = i == null ? 0 : i.intValue ();
    return LanguageEmbedding.create (
        language, 
        startSkipLength, 
        endSkipLength
    );
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
@Override
public LanguageEmbedding<?> findLanguageEmbedding (
    Token token,
    LanguagePath arg1,
    InputAttributes arg2
) {
    if (token.id() == OQLTokenId.JSBLOCK) {
        Language lang = Language.find("text/javascript");
        if(lang == null) {
            return null; //no language found
        } else {
            return LanguageEmbedding.create(lang, 0, 0, true);
        }
    }
    return null;
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
public LanguageEmbedding<?> findLanguageEmbedding(
Token<?> token, LanguagePath languagePath, InputAttributes inputAttributes) {
    synchronized(LOCK) {
        LanguageEmbedding<?> lang = tokenLangCache.get(token);
        
        if (lang == null) {
            for(LanguageProvider p : providers) {
                if (null != (lang = p.findLanguageEmbedding(token, languagePath, inputAttributes))) {
                    break;
                }
            }
            
            if (lang == null) {
                lang = NO_LANG_EMBEDDING();
            }
            
            tokenLangCache.put(token, lang);
        }
        
        return lang == NO_LANG_EMBEDDING() ? null : lang;
    }
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
/**
 * Find the language embedding for the given parameters.
 * <br/>
 * First the <code>LanguageHierarchy.embedding()</code> method is queried
 * and if no embedding is found then the <code>LanguageProvider.findLanguageEmbedding()</code>.
 */
public static <T extends TokenId> LanguageEmbedding<?>
findEmbedding(LanguageHierarchy<T> languageHierarchy, AbstractToken<T> token,
LanguagePath languagePath, InputAttributes inputAttributes) {
    LanguageEmbedding<?> embedding =
            LexerSpiPackageAccessor.get().embedding(
            languageHierarchy, token, languagePath, inputAttributes);

    if (embedding == null) {
        // try language embeddings registered in Lookup
        embedding = LanguageManager.getInstance().findLanguageEmbedding(
                token, languagePath, inputAttributes);
    }
    
    return embedding;
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
@Override
        public LanguageEmbedding<?> embedding(
        Token<TestJoinTextTokenId> token, LanguagePath languagePath, InputAttributes inputAttributes) {
            // Test language embedding in the block comment
            switch (token.id()) {
//                case PARENS: - explicit custom embedding
//                    return LanguageEmbedding.create(TestPlainTokenId.inParensLanguage, 1, 1, true);
                case BRACKETS:
                    return LanguageEmbedding.create(TestPlainTokenId.inBracketsLanguage, 1, 1, true);
                case APOSTROPHES:
                    return LanguageEmbedding.create(TestPlainTokenId.inApostrophesLanguage, 1, 1, false);
//                case TEXT:
//                    return LanguageEmbedding.create(TestStringTokenId.language(), 1, 1);
            }
            return null; // No embedding
        }
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
@Override
public LanguageEmbedding<?> findLanguageEmbedding (
    Token arg0,
    LanguagePath arg1,
    InputAttributes arg2
) {
    return null;
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
/**
 * Find the language paths either for this language only
 * or from TokenHierarchyOperation when adding a new default or custom embedding
 * to the token hierarchy.
 * <br/>
 * As a language may finally be embedded in itself (e.g. someone might
 * want to syntax color java code snippet embedded in javadoc)
 * this method must prevent creation of infinite language paths
 * by using exploredLanguages parameter.
 * 
 * @param existingLanguagePaths set of language paths that are already known.
 *  This set is not modified by the method.
 * @param newLanguagePaths newly discovered language paths will be added to this set.
 * @param exploredLanguages used for checking whether the subpaths containing
 *  this language were already discovered.
 * @param lp language path that will be checked. Its innermost language
 *  will be checked for embeddings automatically.
 */
public static <T extends TokenId> void findLanguagePaths(
Set<LanguagePath> existingLanguagePaths, Set<LanguagePath> newLanguagePaths,
Set<Language<?>> exploredLanguages, LanguagePath lp) {
    // Get the complete language path
    if (!existingLanguagePaths.contains(lp)) {
        newLanguagePaths.add(lp);
    }
    Language<T> language = (Language<T>)LexerUtilsConstants.<T>innerLanguage(lp);
    if (!exploredLanguages.contains(language)) {
        exploredLanguages.add(language);
        Set<T> ids = language.tokenIds();
        for (T id : ids) {
            // Create a fake empty token
            DefaultToken<T> emptyToken = new DefaultToken<T>(new WrapTokenId<T>(id));
            // Find embedding for non-flyweight token
            LanguageHierarchy<T> languageHierarchy = LexerUtilsConstants.innerLanguageHierarchy(lp);
            LanguageEmbedding<?> embedding = LexerUtilsConstants.findEmbedding(
                    languageHierarchy, emptyToken, lp, null);
            if (embedding != null) {
                LanguagePath elp = LanguagePath.get(lp, embedding.language());
                findLanguagePaths(existingLanguagePaths, newLanguagePaths,
                        exploredLanguages, elp);
            }
        }
    }
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
public EmbeddedTokenList(TokenList<?> rootTokenList,
        LanguagePath languagePath, LanguageEmbedding<ET> embedding
) {
    super(1); // Suitable for adding join-token parts
    this.rootTokenList = rootTokenList;
    this.languagePath = languagePath;
    this.embedding = embedding;
    initLAState();
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
@Override
public LanguageEmbedding<?> embedding(
Token<TestJoinMixTextTokenId> token, LanguagePath languagePath, InputAttributes inputAttributes) {
    // Test language embedding in the block comment
    switch (token.id()) {
        case WORD:
            return null;
        case WHITESPACE:
            return null;
    }
    return null; // No embedding
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
public static void registerEmbedding(String mimePath, TokenId id, LanguageEmbedding<?> embedding) {
//        checkInstanceExists();
        synchronized (LOCK) {
            Map<TokenId,LanguageEmbedding<?>> id2embedding = mime2embeddings.get(mimePath);
            if (id2embedding == null) {
                id2embedding = new HashMap<TokenId,LanguageEmbedding<?>>();
                mime2embeddings.put(mimePath, id2embedding);
            }
            id2embedding.put(id, embedding);
        }
        fireChange();
    }
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
public void testEmbeddingCaching() throws Exception {
    LanguageEmbedding<?> e = LanguageEmbedding.create(TestTokenId.language(), 2, 1);
    assertSame(TestTokenId.language(), e.language());
    assertSame(2, e.startSkipLength());
    assertSame(1, e.endSkipLength());
    LanguageEmbedding<?> e2 = LanguageEmbedding.create(TestTokenId.language(), 2, 1);
    assertSame(e, e2);
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
public LanguageEmbedding<?> findLanguageEmbedding(
Token<?> token, LanguagePath languagePath, InputAttributes inputAttributes) {
    if ("text/x-simple-plain".equals(languagePath.mimePath()) && token.id().name().equals("WORD")) {
        return LanguageEmbedding.create(TestCharTokenId.language(), 0, 0);
    } else {
        return null;
    }
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
@Override
public LanguageEmbedding<?> findLanguageEmbedding(Token<?> token, LanguagePath languagePath, InputAttributes inputAttributes) {
    if(embeddedLanguage == null) {
        initLanguage();
    }
    if(token.id() instanceof SilverstripeTokenId && token.text() != null) {
        SilverstripeTokenId silverstripeToken = (SilverstripeTokenId)token.id();
        if(silverstripeToken == SilverstripeTokenId.TEXT) {
            return LanguageEmbedding.create(embeddedLanguage, 0, 0, true);
        }
    }
    return null;
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
@Override
public LanguageEmbedding<?> findLanguageEmbedding(Token<?> token,
        LanguagePath languagePath, InputAttributes inputAttributes) {

    String embeddedMime = NbPreferences.forModule(FTLPanel.class).get("embeddedMime", "text/html");

    Language<?> embeddedLanguage = MimeLookup.getLookup(embeddedMime).lookup(Language.class);

    if (embeddedLanguage != null && languagePath.mimePath().equals("text/x-ftl")) {
        if (token.id().name().startsWith("STATIC_TEXT")) {
            return LanguageEmbedding.create(embeddedLanguage, 0, 0, true);
        }
    }
    return null;
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
@Override
    public LanguageEmbedding<?> findLanguageEmbedding(Token<?> token, LanguagePath languagePath, InputAttributes inputAttributes) {
//        Logger.Log("findEmbedding: " + languagePath.mimePath() + " - " + token.id().name());
        if (languagePath.mimePath().equals("text/isc-cls")) {
            if (CLSLanguageHierarchy.getToken(clsLexer.MethodDeclaration) == token.id()) {
                return LanguageEmbedding.create(new macLanguageHierarchy().language(), 1, 1);
            } else if (CLSLanguageHierarchy.getToken(clsLexer.XDataDeclaration) == token.id()) {
                return LanguageEmbedding.create(new xdataLanguageHierarchy().language(), 1, 1);
            }
        }
        return null;
    }
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
@Override
public LanguageEmbedding<?> findLanguageEmbedding(Token<?> token, LanguagePath languagePath, InputAttributes inputAttributes) {
    return null;
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
public LanguageEmbedding<?> findLanguageEmbedding(
Token<?> token, LanguagePath languagePath, InputAttributes inputAttributes) {
    Lookup lookup = MimeLookup.getLookup(MimePath.parse(languagePath.mimePath()));
    LanguagesEmbeddingMap map = lookup.lookup(LanguagesEmbeddingMap.class);
    return map == null ? null : map.getLanguageEmbeddingForTokenName(token.id().name());
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
/** Creates a new instance of LanguagesEmbeddingMap */
public LanguagesEmbeddingMap(Map<String, LanguageEmbedding<?>> map) {
    this.map = map;
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
public synchronized LanguageEmbedding<?> getLanguageEmbeddingForTokenName(String tokenName) {
    return map.get(tokenName);
}
 

import org.netbeans.spi.lexer.LanguageEmbedding; //导入依赖的package包/类
@Override
protected LanguageEmbedding embedding(
        Token<CPTokenId> token, LanguagePath languagePath, InputAttributes inputAttributes) {
    //there can be just one token with CssTokenId.CSS type - always create core css language embedding
    return LanguageEmbedding.create(getCoreCssLanguage(), 0, 0);
}