Custom Language JFlex, parsing error

Hello!
I generated lexer with jflex
Code:

package net.silnote.bss.Language;


import com.intellij.lexer.FlexLexer;
import com.intellij.psi.tree.IElementType;
import net.silnote.bss.Psi.BSSTypes;
import com.intellij.psi.TokenType;


%%


%line
%column
%public
%class BSSLexer
%implements FlexLexer
%unicode
%function advance
%type IElementType
%{
    private int yycolumn = 0;
    private int yyline = 0;
    private StringBuilder string = new StringBuilder();
%}
%eof{
    return;
%eof}


/*-*
* PATTERN DEFINITIONS:
*/
letter          = [A-Za-z]
digit           = [0-9]
alphanumeric    = {letter}|{digit}
other_id_char   = [_]
identifier      = {letter}({alphanumeric}|{other_id_char})*
integer         = {digit}*
real            = {integer}\.{integer}
char            = {alphanumeric}
leftbrace       = \{
rightbrace      = \}
leftbrace_alt   = \(\*
rightbrace_alt  = \*\)
nonrightbrace   = [^}]
nonrightbrace_alt   = .
dot             = \.
comment_body    = {nonrightbrace}*
comment_body_alt= {nonrightbrace_alt}*
comment         = {leftbrace}{comment_body}{rightbrace}
LineTerminator = [\r\n]
whitespace     = ({LineTerminator} | [\ \t\f])+
HexDigit        = [0-9a-fA-F]
TwoDigits       = [0-9][0-9]
TOKEN_HEX_LITERAL = \${HexDigit}+
TOKEN_DEC_LITERAL        = ([0] | [1-9][0-9]*)
TOKEN_DOUBLE_LITERAL     = ([0-9]+ \. [0-9]*)
TOKEN_STRING_BRACK       = \'
TOKEN_STRING_LITERAL     = {TOKEN_STRING_BRACK}[^']*{TOKEN_STRING_BRACK}
TOKEN_STRING_LITERAL_HEX = #([0-9])+
TOKEN_DATE_LITERAL       = {TwoDigits}\.{TwoDigits}\.([0-9])([0-9])([0-9])([0-9])
TOKEN_TIME_LITERAL       = {TwoDigits}\:{TwoDigits}\:{TwoDigits}(\.([0-9])+)?
TOKEN_DATETIME_LITERAL   = {TOKEN_DATE_LITERAL}(\:{TOKEN_TIME_LITERAL})?
TOKEN_COMMENT1           = {leftbrace_alt}({comment_body_alt}*?){rightbrace_alt}
TOKEN_LINE_COMMENT       = \/\/[^\n\r]*


KEYWORD_AND              = (A|a)(N|n)(D|d)
KEYWORD_ARRAY            = (A|a)(R|r)(R|r)(A|a)(Y|y)
KEYWORD_BEGIN            = (B|b)(E|e)(G|g)(I|i)(N|n)
KEYWORD_BOOLEAN          = (B|b)(O|o)(O|o)(L|l)(E|e)(A|a)(N|n)
KEYWORD_BREAK            = (B|b)(R|r)(E|e)(A|a)(K|k)
KEYWORD_BYTE             = (B|b)(Y|y)(T|t)(E|e)
KEYWORD_CARDINAL         = (C|c)(A|a)(R|r)(D|d)(I|i)(N|n)(A|a)(L|l)
KEYWORD_CASE             = (C|c)(A|a)(S|s)(E|e)
KEYWORD_CHAR             = (C|c)(H|h)(A|a)(R|r)
KEYWORD_CHR              = (C|c)(H|h)(R|r)
KEYWORD_CONST            = (C|c)(O|o)(N|n)(S|s)(T|t)
KEYWORD_CONTINUE         = (C|c)(O|o)(N|n)(T|t)(I|i)(N|n)(U|u)(E|e)
KEYWORD_DATE             = (D|d)(A|a)(T|t)(E|e)
KEYWORD_DATETIME         = (D|d)(A|a)(T|t)(E|e)(T|t)(I|i)(M|m)(E|e)
KEYWORD_DIV              = (D|d)(I|i)(V|v)
KEYWORD_DO               = (D|d)(O|o)
KEYWORD_DOUBLE           = (D|d)(O|o)(U|u)(B|b)(L|l)(E|e)
KEYWORD_DOWNTO           = (D|d)(O|o)(W|w)(N|n)(T|t)(O|o)
KEYWORD_ELSE             = (E|e)(L|l)(S|s)(E|e)
KEYWORD_END              = (E|e)(N|n)(D|d)
KEYWORD_LAST_END         = (E|e)(N|n)(D|d)\.
KEYWORD_EXCEPT           = (E|e)(X|x)(C|c)(E|e)(P|p)(T|t)
KEYWORD_EXIT             = (E|e)(X|x)(I|i)(T|t)
KEYWORD_EXPORTS          = (E|e)(X|x)(P|p)(O|o)(R|r)(T|t)(S|s)
KEYWORD_EXTCONST         = (E|e)(X|x)(T|t)(C|c)(O|o)(N|n)(S|s)(T|t)
KEYWORD_EXTENDED         = (E|e)(X|x)(T|t)(E|e)(N|n)(D|d)(E|e)(D|d)
KEYWORD_FALSE      = (F|f)(A|a)(L|l)(S|s)(E|e)
KEYWORD_FINALLY          = (F|f)(I|i)(N|n)(A|a)(L|l)(L|l)(Y|y)
KEYWORD_FINALIZATION     = (F|f)(I|i)(N|n)(A|a)(L|l)(I|i)(Z|z)(A|a)(T|t)(I|i)(O|o)(N|n)
KEYWORD_FOR              = (F|f)(O|o)(R|r)
KEYWORD_FUNCTION         = (F|f)(U|u)(N|n)(C|c)(T|t)(I|i)(O|o)(N|n)
KEYWORD_IF               = (I|i)(F|f)
KEYWORD_IN               = (I|i)(N|n)
KEYWORD_INCLUDE          = (I|i)(N|n)(C|c)(L|l)(U|u)(D|d)(E|e)
KEYWORD_INITIALIZATION   = (I|i)(N|n)(I|i)(T|t)(I|i)(A|a)(L|l)(I|i)(Z|z)(A|a)(T|t)(I|i)(O|o)(N|n)
KEYWORD_INTEGER          = (I|i)(N|n)(T|t)(E|e)(G|g)(E|e)(R|r)
KEYWORD_MOD              = (M|m)(O|o)(D|d)
KEYWORD_NIL              = (N|n)(I|i)(L|l)
KEYWORD_NOT              = (N|n)(O|o)(T|t)
KEYWORD_NULL             = (N|n)(U|u)(L|l)(L|l)
KEYWORD_OBJECT          = (O|o)(B|b)(J|j)(E|e)(C|c)(T|t)
KEYWORD_OF               = (O|o)(F|f)
KEYWORD_OR               = (O|o)(R|r)
KEYWORD_POINTER          = (P|p)(O|o)(I|i)(N|n)(T|t)(E|e)(R|r)
KEYWORD_PROCEDURE        = (P|p)(R|r)(O|o)(C|c)(E|e)(D|d)(U|u)(R|r)(E|e)
KEYWORD_RAISE            = (R|r)(A|a)(I|i)(S|s)(E|e)
KEYWORD_RECORD           = (R|r)(E|e)(C|c)(O|o)(R|r)(D|d)
KEYWORD_REPEAT           = (R|r)(E|e)(P|p)(E|e)(A|a)(T|t)
KEYWORD_RERAISE          = (R|r)(E|e)(R|r)(A|a)(I|i)(S|s)(E|e)
KEYWORD_RESULT           = (R|r)(E|e)(S|s)(U|u)(L|l)(T|t)
KEYWORD_SMALLINT         = (S|s)(M|m)(A|a)(L|l)(L|l)(I|i)(N|n)(T|t)
KEYWORD_STRING      = (S|s)(T|t)(R|r)(I|i)(N|n)(G|g)
KEYWORD_TABLE            = (T|t)(A|a)(B|b)(L|l)(E|e)
KEYWORD_TIME             = (T|t)(I|i)(M|m)(E|e)
KEYWORD_THEN             = (T|t)(H|h)(E|e)(N|n)
KEYWORD_TO               = (T|t)(O|o)
KEYWORD_TRUE             = (T|t)(R|r)(U|u)(E|e)
KEYWORD_TRY              = (T|t)(R|r)(Y|y)
KEYWORD_TYPE             = (T|t)(Y|y)(P|p)(E|e)
KEYWORD_UNTIL            = (U|u)(N|n)(T|t)(I|i)(L|l)
KEYWORD_USES             = (U|u)(S|s)(E|e)(S|s)
KEYWORD_VAR              = (V|v)(A|a)(R|r)
KEYWORD_VARIANT          = (V|v)(A|a)(R|r)(I|i)(A|a)(N|n)(T|t)
KEYWORD_WHILE            = (W|w)(H|h)(I|i)(L|l)(E|e)
KEYWORD_WORD             = (W|w)(O|o)(R|r)(D|d)
KEYWORD_WORDBOOL         = (W|w)(O|o)(R|r)(D|d)(B|b)(O|o)(O|o)(L|l)


multyIdentifirePart = (\.{identifier}) | ({multyIdentifirePartFunc})
multyIdentifirePartFuncPart = (,?{identifier}) | (,?\'[^']*\')
multyIdentifirePartFunc = \.{identifier}(\({multyIdentifirePartFuncPart}*\))?
multyIdentifire = {identifier}{multyIdentifirePart}+
multyIdentifirePartConst = \.({KEYWORD_AND}|{KEYWORD_ARRAY}|{KEYWORD_BEGIN}|{KEYWORD_BOOLEAN}|{KEYWORD_BREAK}|{KEYWORD_BYTE}|{KEYWORD_CARDINAL}|{KEYWORD_CASE}|{KEYWORD_CHAR}|{KEYWORD_CHR}|{KEYWORD_CONST}|{KEYWORD_CONTINUE}|{KEYWORD_DATE}|{KEYWORD_DATETIME}|{KEYWORD_DIV}|{KEYWORD_DO}|{KEYWORD_DOUBLE}|{KEYWORD_DOWNTO}|{KEYWORD_ELSE}|{KEYWORD_END}|{KEYWORD_EXCEPT}|{KEYWORD_EXIT}|{KEYWORD_EXPORTS}|{KEYWORD_EXTCONST}|{KEYWORD_EXTENDED}|{KEYWORD_FALSE }|{KEYWORD_FINALLY }|{KEYWORD_FINALIZATION}|{KEYWORD_FOR}|{KEYWORD_FUNCTION}|{KEYWORD_IF}|{KEYWORD_IN}|{KEYWORD_INCLUDE}|{KEYWORD_INITIALIZATION}|{KEYWORD_INTEGER}|{KEYWORD_MOD}|{KEYWORD_NIL}|{KEYWORD_NOT}|{KEYWORD_NULL}|{KEYWORD_OBJECT }|{KEYWORD_OF}|{KEYWORD_OR}|{KEYWORD_POINTER}|{KEYWORD_PROCEDURE}|{KEYWORD_RAISE}|{KEYWORD_RECORD}|{KEYWORD_REPEAT}|{KEYWORD_RERAISE}|{KEYWORD_RESULT}|{KEYWORD_SMALLINT}|{KEYWORD_STRING }|{KEYWORD_TABLE}|{KEYWORD_TIME}|{KEYWORD_THEN}|{KEYWORD_TO}|{KEYWORD_TRUE}|{KEYWORD_TRY}|{KEYWORD_TYPE}|{KEYWORD_UNTIL}|{KEYWORD_USES}|{KEYWORD_VAR}|{KEYWORD_VARIANT}|{KEYWORD_WHILE}|{KEYWORD_WORD}|{KEYWORD_WORDBOOL})


expression               = {compareToken} ( {logicalOperator} {compareToken} )*
logicalOperator          = "=="|"<>"|"<"|">"|"<="|">="
compareToken             = {addToken} ( {addOperator} {addToken} )*
addOperator              = "+"|"-"|{KEYWORD_OR}
addToken                 = {multToken} ( {multOperator} {multToken} )*
multOperator             = "*"|"\\"|{KEYWORD_DIV}|{KEYWORD_AND}|{KEYWORD_MOD}
multToken                = ( {unaryOperator} )* {primaryExpression}
unaryOperator            = "+"|"-"|([aA][tT])|{KEYWORD_NOT}
primaryExpression        = {elementaryExpression} ( {postfixOperator} )*
postfixOperator          = {arrayItem} | (\.{memberCall}) | \.?{TOKEN_STRING_LITERAL}
arrayItem                = \[ {expression} \]
elementaryExpression     = (\( {expression} \))|{constant}|{dateConstant}|{memberCall}|{KEYWORD_RESULT}
memberCall               = {identifire} ({functionParamValueList})?
functionParamValueList   = \( ({expression} ( ,{expression} )*)? \)
constant                 = {TOKEN_STRING_LITERAL}|{TOKEN_DOUBLE_LITERAL}| ({TOKEN_DEC_LITERAL}|{TOKEN_HEX_LITERAL}) |{KEYWORD_NIL}|{KEYWORD_NULL}|{KEYWORD_FALSE}|{KEYWORD_TRUE}
dateConstant             = ({TOKEN_DATE_LITERAL}|{TOKEN_TIME_LITERAL}|{TOKEN_DATETIME_LITERAL})


%state MULTY


%%


<YYINITIAL> {
    {KEYWORD_AND}                   { return BSSTypes.KEYWORD_AND; }
    {KEYWORD_ARRAY}                 { return BSSTypes.KEYWORD_ARRAY; }
    {KEYWORD_BEGIN}                 { return BSSTypes.KEYWORD_BEGIN; }
    {KEYWORD_BOOLEAN}               { return BSSTypes.KEYWORD_BOOLEAN; }
    {KEYWORD_BREAK}                 { return BSSTypes.KEYWORD_BREAK; }
    {KEYWORD_BYTE}                  { return BSSTypes.KEYWORD_BYTE; }
    {KEYWORD_CARDINAL}              { return BSSTypes.KEYWORD_CARDINAL; }
    {KEYWORD_CASE}                  { return BSSTypes.KEYWORD_CASE; }
    {KEYWORD_CHAR}                  { return BSSTypes.KEYWORD_CHAR; }
    {KEYWORD_CHR}                   { return BSSTypes.KEYWORD_CHR; }
    {KEYWORD_CONST}                 { return BSSTypes.KEYWORD_CONST; }
    {KEYWORD_CONTINUE}              { return BSSTypes.KEYWORD_CONTINUE; }
    {KEYWORD_DATE}                  { return BSSTypes.KEYWORD_DATE; }
    {KEYWORD_DATETIME}              { return BSSTypes.KEYWORD_DATETIME; }
    {KEYWORD_DIV}                   { return BSSTypes.KEYWORD_DIV; }
    {KEYWORD_DO}                    { return BSSTypes.KEYWORD_DO; }
    {KEYWORD_DOUBLE}                { return BSSTypes.KEYWORD_DOUBLE; }
    {KEYWORD_DOWNTO}                { return BSSTypes.KEYWORD_DOWNTO; }
    {KEYWORD_ELSE}                  { return BSSTypes.KEYWORD_ELSE; }
    {KEYWORD_END}                   { return BSSTypes.KEYWORD_END; }
    {KEYWORD_EXCEPT}                { return BSSTypes.KEYWORD_EXCEPT; }
    {KEYWORD_EXIT}                  { return BSSTypes.KEYWORD_EXIT; }
    {KEYWORD_EXPORTS}               { return BSSTypes.KEYWORD_EXPORTS; }
    {KEYWORD_EXTCONST}              { return BSSTypes.KEYWORD_EXTCONST; }
    {KEYWORD_EXTENDED}              { return BSSTypes.KEYWORD_EXTENDED; }
    {KEYWORD_FALSE}             { return BSSTypes.KEYWORD_FALSE; }
    {KEYWORD_FINALLY}             { return BSSTypes.KEYWORD_FINALLY; }
    {KEYWORD_FINALIZATION}          { return BSSTypes.KEYWORD_FINALIZATION; }
    {KEYWORD_FOR}                   { return BSSTypes.KEYWORD_FOR; }
    {KEYWORD_FUNCTION}              { return BSSTypes.KEYWORD_FUNCTION; }
    {KEYWORD_IF}                    { return BSSTypes.KEYWORD_IF; }
    {KEYWORD_IN}                    { return BSSTypes.KEYWORD_IN; }
    {KEYWORD_INCLUDE}               { return BSSTypes.KEYWORD_INCLUDE; }
    {KEYWORD_INITIALIZATION}        { return BSSTypes.KEYWORD_INITIALIZATION; }
    {KEYWORD_INTEGER}               { return BSSTypes.KEYWORD_INTEGER; }
    {KEYWORD_MOD}                   { return BSSTypes.KEYWORD_MOD; }
    {KEYWORD_NIL}                   { return BSSTypes.KEYWORD_NIL; }
    {KEYWORD_NOT}                   { return BSSTypes.KEYWORD_NOT; }
    {KEYWORD_NULL}                  { return BSSTypes.KEYWORD_NULL; }
    {KEYWORD_OBJECT}             { return BSSTypes.KEYWORD_OBJECT; }
    {KEYWORD_OF}                    { return BSSTypes.KEYWORD_OF; }
    {KEYWORD_OR}                    { return BSSTypes.KEYWORD_OR; }
    {KEYWORD_POINTER}               { return BSSTypes.KEYWORD_POINTER; }
    {KEYWORD_PROCEDURE}             { return BSSTypes.KEYWORD_PROCEDURE; }
    {KEYWORD_RAISE}                 { return BSSTypes.KEYWORD_RAISE; }
    {KEYWORD_RECORD}                { return BSSTypes.KEYWORD_RECORD; }
    {KEYWORD_REPEAT}                { return BSSTypes.KEYWORD_REPEAT; }
    {KEYWORD_RERAISE}               { return BSSTypes.KEYWORD_RERAISE; }
    {KEYWORD_RESULT}                { return BSSTypes.KEYWORD_RESULT; }
    {KEYWORD_SMALLINT}              { return BSSTypes.KEYWORD_SMALLINT; }
    {KEYWORD_STRING}         { return BSSTypes.KEYWORD_STRING; }
    {KEYWORD_TABLE}                 { return BSSTypes.KEYWORD_TABLE; }
    {KEYWORD_TIME}                  { return BSSTypes.KEYWORD_TIME; }
    {KEYWORD_THEN}                  { return BSSTypes.KEYWORD_THEN; }
    {KEYWORD_TO}                    { return BSSTypes.KEYWORD_TO; }
    {KEYWORD_TRUE}                  { return BSSTypes.KEYWORD_TRUE; }
    {KEYWORD_TRY}                   { return BSSTypes.KEYWORD_TRY; }
    {KEYWORD_TYPE}                  { return BSSTypes.KEYWORD_TYPE; }
    {KEYWORD_UNTIL}                 { return BSSTypes.KEYWORD_UNTIL; }
    {KEYWORD_USES}                  { return BSSTypes.KEYWORD_USES; }
    {KEYWORD_VAR}                   { return BSSTypes.KEYWORD_VAR; }
    {KEYWORD_VARIANT}               { return BSSTypes.KEYWORD_VARIANT; }
    {KEYWORD_WHILE}                 { return BSSTypes.KEYWORD_WHILE; }
    {KEYWORD_WORD}                  { return BSSTypes.KEYWORD_WORD; }
    {KEYWORD_WORDBOOL}              { return BSSTypes.KEYWORD_WORDBOOL; }
    {KEYWORD_LAST_END}              { return BSSTypes.KEYWORD_LAST_END; }
    \.                              { yybegin(MULTY);return BSSTypes.OPERATOR_DOT;}
    {identifier}                    { return BSSTypes.TOKEN_IDENTIFIRE; }
    {TOKEN_STRING_LITERAL_HEX}      { return BSSTypes.TOKEN_STRING_LITERAL; }
    {TOKEN_HEX_LITERAL}             { return BSSTypes.TOKEN_HEX_LITERAL; }
    {TOKEN_DEC_LITERAL}             { return BSSTypes.TOKEN_DEC_LITERAL; }
    {TOKEN_DOUBLE_LITERAL}          { return BSSTypes.TOKEN_DOUBLE_LITERAL; }
    {TOKEN_DATE_LITERAL}            { return BSSTypes.TOKEN_DATE_LITERAL; }
    {TOKEN_TIME_LITERAL}            { return BSSTypes.TOKEN_TIME_LITERAL; }
    {TOKEN_DATETIME_LITERAL}        { return BSSTypes.TOKEN_DATETIME_LITERAL; }
    {TOKEN_STRING_LITERAL}          { return BSSTypes.TOKEN_STRING_LITERAL; }
    {integer}                       { return BSSTypes.VALUE; }
    {real}                          { return BSSTypes.VALUE; }
    {char}                          { return BSSTypes.VALUE; }


    /* operators */
    "*"             { return BSSTypes.OPERATOR_STAR; }
    "+"             { return BSSTypes.OPERATOR_PLUS; }
    "-"             { return BSSTypes.OPERATOR_MINUS; }
    "/"             { return BSSTypes.OPERATOR_SLASH; }
    ";"             { return BSSTypes.OPERATOR_SEMI; }
    "("             { return BSSTypes.OPERATOR_L_PARENTHESIS; }
    ")"             { return BSSTypes.OPERATOR_R_PARENTHESIS; }
    "["             { return BSSTypes.OPERATOR_L_SQUAREBRACKET; }
    "]"             { return BSSTypes.OPERATOR_R_SQUAREBRACKET; }
    "{"             { return BSSTypes.OPERATOR_L_CURLYBRACKET; }
    "}"             { return BSSTypes.OPERATOR_R_CURLYBRACKET; }
    "$"             { return BSSTypes.OPERATOR_HEX; }
    "@"             { return BSSTypes.OPERATOR_AT; }
    "<>"            { return BSSTypes.OPERATOR_NOT_EQUAL; }
    "="             { return BSSTypes.OPERATOR_EQUAL; }
    "=="            { return BSSTypes.OPERATOR_DOUBLE_EQUAL; }
    "<"             { return BSSTypes.OPERATOR_LESS; }
    ">"             { return BSSTypes.OPERATOR_MORE; }
    "<="            { return BSSTypes.OPERATOR_LESS_OR_EQUAL; }
    ">="            { return BSSTypes.OPERATOR_MORE_OR_EQUAL; }
    ":"             { return BSSTypes.OPERATOR_COLON; }
    ":="            { return BSSTypes.OPERATOR_ASSIGN; }
    ","             { return BSSTypes.OPERATOR_COMMA; }


    {TOKEN_COMMENT1}       { yybegin(YYINITIAL);return BSSTypes.COMMENT; }
    {TOKEN_LINE_COMMENT}   { yybegin(YYINITIAL);return BSSTypes.COMMENT; }
    {comment}              { yybegin(YYINITIAL);return BSSTypes.COMMENT; }


    .               { yybegin(YYINITIAL); yypushback(yylength());return TokenType.BAD_CHARACTER; }
}


<MULTY> {
    {identifier}            { yybegin(YYINITIAL);return BSSTypes.TOKEN_IDENTIFIRE; }
    {constant}              { yybegin(YYINITIAL);return BSSTypes.TOKEN_IDENTIFIRE; }
    {dateConstant}          { yybegin(YYINITIAL);return BSSTypes.TOKEN_IDENTIFIRE; }
    .                       { yybegin(YYINITIAL); yypushback(yylength()); }
}


{TOKEN_COMMENT1}       { yybegin(YYINITIAL);return BSSTypes.COMMENT; }
{TOKEN_LINE_COMMENT}   { yybegin(YYINITIAL);return BSSTypes.COMMENT; }
{comment}              { yybegin(YYINITIAL);return BSSTypes.COMMENT; }


{whitespace}   { yybegin(YYINITIAL);return TokenType.WHITE_SPACE; }
.|[\n\r]       { yybegin(YYINITIAL);return TokenType.BAD_CHARACTER; }





I have next problem:
[  10469]  ERROR - api.project.CacheUpdateSession - Error while indexing *****
To reindex this file IDEA has to be restarted
java.lang.Error: net.silnote.bss.Language.BSSLexer: Error: could not match input
 at net.silnote.bss.Language.BSSLexer.zzScanError(BSSLexer.java:754)
 at net.silnote.bss.Language.BSSLexer.advance(BSSLexer.java:1339)
 at com.intellij.lexer.FlexAdapter.locateToken(FlexAdapter.java:93)
 at com.intellij.lexer.FlexAdapter.getTokenType(FlexAdapter.java:57)
 at com.intellij.lang.cacheBuilder.DefaultWordsScanner.processWords(DefaultWordsScanner.java:74)
 at com.intellij.psi.impl.cache.impl.id.IdTableBuilding$WordsScannerFileTypeIdIndexerAdapter.map(IdTableBuilding.java:137)
 at com.intellij.psi.impl.cache.impl.id.IdTableBuilding$WordsScannerFileTypeIdIndexerAdapter.map(IdTableBuilding.java:124)
 at com.intellij.psi.impl.cache.impl.id.IdIndex$4.map(IdIndex.java:83)
 at com.intellij.psi.impl.cache.impl.id.IdIndex$4.map(IdIndex.java:77)
 at com.intellij.util.indexing.MapReduceIndex.update(MapReduceIndex.java:215)
 at com.intellij.util.indexing.FileBasedIndexImpl$24.run(FileBasedIndexImpl.java:1706)
 at com.intellij.openapi.progress.impl.ProgressManagerImpl.executeNonCancelableSection(ProgressManagerImpl.java:137)
 at com.intellij.util.indexing.FileBasedIndexImpl.updateSingleIndex(FileBasedIndexImpl.java:1702)
 at com.intellij.util.indexing.FileBasedIndexImpl.indexFileContent(FileBasedIndexImpl.java:1666)
 at com.intellij.util.indexing.UnindexedFilesUpdater.processFile(UnindexedFilesUpdater.java:68)
 at com.intellij.openapi.project.CacheUpdateSession.processFile(CacheUpdateSession.java:102)
 at com.intellij.openapi.project.CacheUpdateRunner$MyRunnable$1.run(CacheUpdateRunner.java:231)
 at com.intellij.openapi.application.impl.ApplicationImpl.runReadAction(ApplicationImpl.java:940)
 at com.intellij.openapi.project.CacheUpdateRunner$MyRunnable.run(CacheUpdateRunner.java:237)
 at com.intellij.openapi.application.impl.ApplicationImpl$8.run(ApplicationImpl.java:454)
 at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
 at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:334)
 at java.util.concurrent.FutureTask.run(FutureTask.java:166)
 at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110)
 at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
 at java.lang.Thread.run(Thread.java:722)
 at com.intellij.openapi.application.impl.ApplicationImpl$1$1.run(ApplicationImpl.java:152)


This error occurs when the files are more than 10-15, if the file is less than that there are no errors.
Files in utf8 and cp1251.
If restart IDE 3-4 times, the errors disappear.
When open a file with an error, IDE parses it without mistakes.
Any ideas?

P/S Sorry for my english.

Please sign in to leave a comment.