long long RainbowFrontStatusCheekOfStaticWordValiditySp(const char *token);
long long RainbowFrontStatusCheekOfStaticWordValidity(const char *token)
{
    switch (*token++)
    {
    case 'I':
    {
        switch (*token++)
        {
        case 'G':
        {
            switch (*token++)
            {
            case 'N':
            {
                switch (*token++)
                {
                case 'O':
                {
                    switch (*token++)
                    {
                    case 'R':
                    {
                        return 3;
                        break;
                    }
                    default:
                    {
                        return -1;
                        break;
                    }
                    }
                }
                default:
                {
                    return -1;
                    break;
                }
                }
            }
            default:
            {
                return -1;
                break;
            }
            }
        }
        default:
        {
            return -1;
            break;
        }
        }
    }
    case 'N':
    {
        switch (*token++)
        {
        case 'U':
        {
            switch (*token++)
            {
            case 'M':
            {
                switch (*token++)
                {
                case 'B':
                {
                    switch (*token++)
                    {
                    case 'E':
                    {
                        return 14;
                        break;
                    }
                    default:
                    {
                        return -1;
                        break;
                    }
                    }
                }
                default:
                {
                    return -1;
                    break;
                }
                }
            }
            default:
            {
                return -1;
                break;
            }
            }
        }
        default:
        {
            return -1;
            break;
        }
        }
    }
    case 'S':
    {
        switch (*token++)
        {
        case 'T':
        {
            switch (*token++)
            {
            case 'R':
            {
                switch (*token++)
                {
                case 'I':
                {
                    switch (*token++)
                    {
                    case 'N':
                    {
                        switch (*token++)
                        {
                        case 'G':
                        {
                            switch (*token++)
                            {
                            case '_':
                            {
                                switch (*token++)
                                {
                                case 'S':
                                {
                                    switch (*token++)
                                    {
                                    case 'I':
                                    {
                                        switch (*token++)
                                        {
                                        case 'N':
                                        {
                                            switch (*token++)
                                            {
                                            case 'G':
                                            {
                                                switch (*token++)
                                                {
                                                case 'L':
                                                {
                                                    return 12;
                                                    break;
                                                }
                                                default:
                                                {
                                                    return -1;
                                                    break;
                                                }
                                                }
                                            }
                                            default:
                                            {
                                                return -1;
                                                break;
                                            }
                                            }
                                        }
                                        default:
                                        {
                                            return -1;
                                            break;
                                        }
                                        }
                                    }
                                    default:
                                    {
                                        return -1;
                                        break;
                                    }
                                    }
                                }
                                case 'D':
                                {
                                    switch (*token++)
                                    {
                                    case 'O':
                                    {
                                        switch (*token++)
                                        {
                                        case 'U':
                                        {
                                            switch (*token++)
                                            {
                                            case 'B':
                                            {
                                                switch (*token++)
                                                {
                                                case 'L':
                                                {
                                                    return 13;
                                                    break;
                                                }
                                                default:
                                                {
                                                    return -1;
                                                    break;
                                                }
                                                }
                                            }
                                            default:
                                            {
                                                return -1;
                                                break;
                                            }
                                            }
                                        }
                                        default:
                                        {
                                            return -1;
                                            break;
                                        }
                                        }
                                    }
                                    default:
                                    {
                                        return -1;
                                        break;
                                    }
                                    }
                                }
                                default:
                                {
                                    return -1;
                                    break;
                                }
                                }
                            }
                            default:
                            {
                                return -1;
                                break;
                            }
                            }
                        }
                        default:
                        {
                            return -1;
                            break;
                        }
                        }
                    }
                    default:
                    {
                        return -1;
                        break;
                    }
                    }
                }
                default:
                {
                    return -1;
                    break;
                }
                }
            }
            default:
            {
                return -1;
                break;
            }
            }
        }
        default:
        {
            return -1;
            break;
        }
        }
    }
    case '_':
    {
        switch (*token++)
        {
        case '_':
        {
            switch (*token++)
            {
            case 'V':
            {
                switch (*token++)
                {
                case 'A':
                {
                    switch (*token++)
                    {
                    case 'R':
                    {
                        switch (*token++)
                        {
                        case '_':
                        {
                            return 11;
                            break;
                        }
                        default:
                        {
                            return -1;
                            break;
                        }
                        }
                    }
                    default:
                    {
                        return -1;
                        break;
                    }
                    }
                }
                default:
                {
                    return -1;
                    break;
                }
                }
            }
            default:
            {
                return -1;
                break;
            }
            }
        }
        default:
        {
            return -1;
            break;
        }
        }
    }
    case 's':
    {
        switch (*token++)
        {
        case 't':
        {
            switch (*token++)
            {
            case 'a':
            {
                switch (*token++)
                {
                case 't':
                {
                    switch (*token++)
                    {
                    case 'i':
                    {
                        switch (*token++)
                        {
                        case 'c':
                        {
                            switch (*token++)
                            {
                            case 'W':
                            {
                                switch (*token++)
                                {
                                case 'o':
                                {
                                    switch (*token++)
                                    {
                                    case 'r':
                                    {
                                        return 1;
                                        break;
                                    }
                                    default:
                                    {
                                        return -1;
                                        break;
                                    }
                                    }
                                }
                                default:
                                {
                                    return -1;
                                    break;
                                }
                                }
                            }
                            default:
                            {
                                return -1;
                                break;
                            }
                            }
                        }
                        default:
                        {
                            return -1;
                            break;
                        }
                        }
                    }
                    default:
                    {
                        return -1;
                        break;
                    }
                    }
                }
                default:
                {
                    return -1;
                    break;
                }
                }
            }
            default:
            {
                return -1;
                break;
            }
            }
        }
        case 'w':
        {
            return 1;
            break;
        }
        case 'p':
        {
            switch (*token++)
            {
            case 'e':
            {
                switch (*token++)
                {
                case 'r':
                {
                    switch (*token++)
                    {
                    case 'a':
                    {
                        switch (*token++)
                        {
                        case 't':
                        {
                            switch (*token++)
                            {
                            case 'o':
                            {
                                return 2;
                                break;
                            }
                            default:
                            {
                                return -1;
                                break;
                            }
                            }
                        }
                        default:
                        {
                            return -1;
                            break;
                        }
                        }
                    }
                    default:
                    {
                        return -1;
                        break;
                    }
                    }
                }
                default:
                {
                    return -1;
                    break;
                }
                }
            }
            default:
            {
                return RainbowFrontStatusCheekOfStaticWordValiditySp(token) == -1 ? 2 : -1;
                break;
            }
            }
        }
        default:
        {
            return -1;
            break;
        }
        }
    }
    default:
        return -1;
        break;
    }
}
long long RainbowFrontStatusCheekOfStaticWordValiditySp(const char *token)
{
    switch (*token++)
    {
    case '\t':
    {
        return 2147473648;
        break;
    }

    case '\n':
    {
        return 2147473647;
        break;
    }
    case ' ':
    {
        return 2147473649;
        break;
    }
    case ',':
    {
        return 20;
        break;
    }
    case ';':
    {
        return 22;
        break;
    }
    case '-':
    {
        return 19;
        break;
    }
    case ':':
    {
        return 21;
        break;
    }
    case '[':
    {
        return 17;
        break;
    }
    case ']':
    {
        return 18;
        break;
    }
    case '{':
    {
        return 15;
        break;
    }
    case '}':
    {
        return 16;
        break;
    }
    default:
        return -1;
        break;
    }
}
int RainbowFrontStatuSperatorMatch(const char *token)
{
    int id = RainbowFrontStatusCheekOfStaticWordValiditySp(token);
    switch (id)
    {
    case 2147473647:
    case 2147473648:
    case 2147473649:
    case 21:
    case 20:
    case 19:
    case 18:
    case 17:
    case 15:
    case 16:
    case 22:
        return 0;
        break;
    default:
    {
        return -1;
        break;
    }
    }
}

void RainbowFrontLex(const char* string,long long* id_list)
{
    /* 将string解析
        并加入到ret列表中
    */
    const char* strptr = string;
    WHITESPACE_SKIP(strptr);
    char buf[BUF_SIZE] = {'\0'};
    size_t index = 0;
    while(*strptr != '\0')
    {
            if(*strptr == '\"')//处理字符串
            {
                if(*buf!='\0')
                {
                    long long id = 0;
                    id = RainbowFrontStatusCheekOfStaticWordValidity(buf);
                    if(id >= 0) RainbowRetAdd(buf,id,&RainbowFrontLexer_Ret);
                    else if(isalpha(*buf)&&(RainbowStatusCheekVarNameValidity(buf) != -1)&& (RainBowLexer_id_var!=-1))
                        RainbowRetAdd(buf,RainBowLexer_id_var,&RainbowFrontLexer_Ret);
                    else if(isdigit(*buf)&&(RainbowStatusCheekNumValidity(buf) != -1)&& (RainBowLexer_id_num!=-1))
                        RainbowRetAdd(buf,RainBowLexer_id_num,&RainbowFrontLexer_Ret);
                    else//错误处理
                    {
                        RAINBOW_RAISE(UndefineToken);
                        printf("%s\n",buf);
                        getchar();
                        putchar('\n');
                    }
                }
                char* stringToken = RainbowStatusCheekOfString(strptr+1,'\"');
                if(stringToken == NULL)return;
                int len = strlen(stringToken);
                strptr+=len+2;
                RainbowRetAdd(stringToken,RainBowLexer_id_string,&RainbowFrontLexer_Ret);
                free(stringToken);
                continue;
            }
            int spRet = RainbowFrontStatuSperatorMatch(strptr);
            if(*buf == '\0' && spRet >= 0) goto BUF_EMPTY_CASE_;//处理第一个字符是分隔符的情况
            if(spRet >= 0)
            {   
                int id = 0;
                id = RainbowFrontStatusCheekOfStaticWordValidity(buf);
                if(id >= 0) RainbowRetAdd(buf,id,&RainbowFrontLexer_Ret);
                else if(*buf != '\0' && isalpha(*buf)&&(RainbowStatusCheekVarNameValidity(buf) != -1)&&RainBowLexer_id_var!=-1)
                    RainbowRetAdd(buf,RainBowLexer_id_var,&RainbowFrontLexer_Ret);
                else if(*buf != '\0' && isdigit(*buf)&&(RainbowStatusCheekNumValidity(buf) != -1)&&RainBowLexer_id_num!=-1)
                    RainbowRetAdd(buf,RainBowLexer_id_num,&RainbowFrontLexer_Ret);
                else if(*buf == '\0')goto BUF_EMPTY_CASE_;//用于处理多个连续分隔符的情况
                else//错误处理
                {
                    RAINBOW_RAISE(UndefineToken);
                    printf("%s\n",buf);
                    getchar();
                    putchar('\n');
                }

                BUF_EMPTY_CASE_:
                memset(buf,'\0',BUF_SIZE);
                index = 0;
                for (size_t i = 0; i <= spRet; i++)buf[i] = *strptr++;
                RainbowRetAdd(buf,RainbowFrontStatusCheekOfStaticWordValiditySp(buf),&RainbowFrontLexer_Ret);
                memset(buf,'\0',BUF_SIZE);
            }
            else
                buf[index++] = *strptr++;
    }
    
    if(*buf == '\0')return;//buf已空  情况出现在最后一个字符是分隔符时

    //清理buf
    long long id = 0;
    id = RainbowFrontStatusCheekOfStaticWordValidity(buf);
    if(id >= 0) RainbowRetAdd(buf,id,&RainbowFrontLexer_Ret);
    else if(*buf != '\0' && isalpha(*buf)&&(RainbowStatusCheekVarNameValidity(buf) != -1)&&RainBowLexer_id_var!=-1)
        RainbowRetAdd(buf,RainBowLexer_id_var,&RainbowFrontLexer_Ret);
    else if(*buf != '\0' && isdigit(*buf)&&(RainbowStatusCheekNumValidity(buf) != -1)&&RainBowLexer_id_num!=-1)
        RainbowRetAdd(buf,RainBowLexer_id_num,&RainbowFrontLexer_Ret);
    else//错误处理
    {
        RAINBOW_RAISE(UndefineToken);
        printf("%s\n",buf);
        getchar();
        putchar('\n');
    }
    return;
}