package gudusoft.gsqlparser;


import gudusoft.gsqlparser.nodes.TDummy;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.nodes.TParseTreeNodeList;
import gudusoft.gsqlparser.nodes.TNodeFactory;


import java.util.ArrayList;
import java.util.Map;


/**
 * Base parser of all databases.
 */
public class TCustomParser {

    // Make the map static and initialize it directly
//    static final Map<Integer, int[]> postgresRollbackTokens = new HashMap<Integer, int[]>() {{
//        // TBaseType.ident must be the last element in each array
//        put(TBaseType.rrw_postgresql_insert_values, new int[]{TBaseType.rrw_values,TBaseType.ident});
//    }};


    /**
     * Count of entries into yyparse error handling (keyword rollback, error
     * shift/discard, abort) since this parser instance was created. Read by
     * {@link DynamicSqlProofHarness}: the dynamic-SQL publication proof must
     * fail when a parse needed ANY recovery, including silently-successful
     * keyword rollback. Never reset — use a fresh parser per proof.
     */
    int proofRecoveryEvents = 0;

    /**
     * Subset of {@link #proofRecoveryEvents}: entries that attempted the
     * deterministic keyword-to-identifier rollback (e.g. {@code select a.wait
     * from b}). Typed separately so a future audited-rewrite refinement can
     * treat successful keyword rollback as a bounded rewrite instead of a
     * disqualifying recovery — today the proof still refuses on it (sound,
     * conservative; costs recall on the ~72 rollback-only keyword-column
     * shapes, tracked in the design doc).
     */
    int proofKeywordRollbackEvents = 0;

    /** @see #proofRecoveryEvents */
    public int getProofRecoveryEvents() {
        return proofRecoveryEvents;
    }

    /** @see #proofKeywordRollbackEvents */
    public int getProofKeywordRollbackEvents() {
        return proofKeywordRollbackEvents;
    }

    /* ------------------------------------------------------------------
     * Proof-mode LR configuration observation (design R4 — the commitment
     * check for dynamic-SQL edge provenance).
     *
     * A dynamic-SQL site is literal text with holes whose runtime value is
     * unknown. To decide whether a construct is COMMITTED — i.e. no hole
     * instantiation can still extend it and rebind a name — we need the LR
     * automaton's own configuration at the point where the literal prefix
     * ends, because the grammar, not a hand-written table of clause kinds,
     * is what knows which productions are still open.
     *
     * This block only OBSERVES. It never changes an action, a reduction or
     * a token. When {@link #proofLrCutoffOffset} is negative (the default)
     * every field here is untouched and the cost is one int comparison per
     * lookahead fetch.
     * ------------------------------------------------------------------ */

    /** Returned by {@link #do_yyparse} when it stopped at the proof cutoff. */
    public static final int PROOF_LR_STOPPED_AT_CUTOFF = 10099;

    /** One reduction the automaton performed, recorded before the stack is popped. */
    public static final class ProofReduction {
        /** yacc rule number (positive). */
        public final int rule;
        /** Number of stack entries the rule pops. */
        public final int length;
        /** LHS symbol the rule reduces to, as stored in the generated tables. */
        public final int lhsSymbol;
        /** Stack depth BEFORE the pop — the rule spans depths [depth-length+1, depth]. */
        public final int stackDepthBeforePop;
        /**
         * Character offset of the lookahead token in hand when the reduction
         * ran, or -1 when the reduction needed no lookahead (a default
         * reduction). Only reductions taken with a STABLE lookahead — one that
         * lies before the first hole — may be used as positive evidence.
         */
        public final long lookaheadOffset;

        ProofReduction(int rule, int length, int lhsSymbol, int stackDepthBeforePop,
                long lookaheadOffset) {
            this.rule = rule;
            this.length = length;
            this.lhsSymbol = lhsSymbol;
            this.stackDepthBeforePop = stackDepthBeforePop;
            this.lookaheadOffset = lookaheadOffset;
        }

        @Override
        public String toString() {
            return "rule=" + rule + " len=" + length + " lhs=" + lhsSymbol
                    + " depth=" + stackDepthBeforePop + " lookahead@" + lookaheadOffset;
        }
    }

    /**
     * The automaton's configuration at the proof cutoff: the state stack as it
     * stood when the parser first needed a token at or beyond the cutoff, plus
     * every reduction performed before that point.
     *
     * <p>The snapshot is taken while the cutoff token has been READ but not yet
     * shifted, and before any action is looked up for it. So the stack is
     * exactly "what the literal prefix committed to", with no influence from
     * the unstable token — which is the whole point.
     */
    public static final class ProofLrConfiguration {
        /** The state stack, bottom first — a copy of {@code yys[1..yysp]}. */
        public final int[] stateStack;
        /** Character offset of the token the parser stopped before. */
        public final long stoppedBeforeOffset;
        /** Token code of that token. */
        public final int stoppedBeforeTokenCode;
        /** Reductions performed before the cutoff, in order. */
        public final java.util.List<ProofReduction> reductions;

        ProofLrConfiguration(int[] stateStack, long stoppedBeforeOffset,
                int stoppedBeforeTokenCode, java.util.List<ProofReduction> reductions) {
            this.stateStack = stateStack;
            this.stoppedBeforeOffset = stoppedBeforeOffset;
            this.stoppedBeforeTokenCode = stoppedBeforeTokenCode;
            this.reductions = java.util.Collections.unmodifiableList(reductions);
        }

        /** Depth of the state stack. */
        public int depth() {
            return stateStack.length;
        }

        /** The state on top of the stack — the automaton's current state. */
        public int topState() {
            return stateStack.length == 0 ? 0 : stateStack[stateStack.length - 1];
        }

        @Override
        public String toString() {
            return "ProofLrConfiguration{depth=" + depth() + " top=" + topState()
                    + " stoppedBefore@" + stoppedBeforeOffset
                    + " token=" + stoppedBeforeTokenCode
                    + " reductions=" + reductions.size() + "}";
        }
    }

    /**
     * Stop the parse before consuming any token at or beyond this character
     * offset, and record the configuration. Negative (default) disables all
     * observation.
     */
    long proofLrCutoffOffset = -1;

    /** Populated only when the cutoff was actually reached; null otherwise. */
    ProofLrConfiguration proofLrConfiguration;

    /** Reductions seen so far this parse; allocated only when observing. */
    private java.util.List<ProofReduction> proofLrReductions;

    /**
     * Arm the observer. Must be called before {@code yyparse()}. Observation is
     * read-only: the parse proceeds exactly as it otherwise would, up to the
     * cutoff, at which point it stops WITHOUT entering error recovery (recovery
     * unwinds the very stack we are trying to read).
     */
    public void setProofLrCutoffOffset(long offset) {
        this.proofLrCutoffOffset = offset;
        this.proofLrConfiguration = null;
        this.proofLrReductions = offset < 0 ? null : new java.util.ArrayList<ProofReduction>();
    }

    /** The configuration captured at the cutoff, or null if it was never reached. */
    public ProofLrConfiguration getProofLrConfiguration() {
        return proofLrConfiguration;
    }

    EDbVendor dbvendor;
    TDatabaseYYSType yylval;
    TDatabaseYYSType[] yyv; // 1 based array
    int[] yys; // parser state stack, reused across parse calls for performance
    TDatabaseYYSType yyval = null;

    // the terminal or non-terminal numbers in the right side of a BNF rule, start from 1.
    // Take this rule for example:  
    //      sqlstmts:  stmt ';'
    // stmt is non-terminal, its number is 1, ';' is terminal, its number is 2.
    // when sqlstmts rule is reduced, the yysp is 2 which means it points to the ';' token.
    // and if we need to access the stmt node, we can use yyv[yysp-1] to get it.
    int yysp; 
    
    boolean isbeginofbatch; //used by mssql
    TSourceTokenList tmp_sourcetokenlist;
    int tmp_curtokenpos;

    public TSourceTokenList sourcetokenlist;
    public TNodeFactory nf;
    public TParseTreeNode rootNode;
    final int yymaxdepth = 1048;
    final int _error = 256;
    final int yyfnone = 0;
    final int  yyfaccept = 1;
    final int yyfabort = 2;
    final int  yyferror = 3;
    final int aopAbort = 0;
    final int aopContinue = 1;
    final int tsOriginal = 0;
    final int tsDeleted = 1;
    final int tsIgnoreByYacc = 2;
    final int tsMarkDeletedInPPDoWhiteSpace = 3;
    final int tsAddedInPP = 4;
    final int tsDeletedInPP = 5;
    final int tsAlreadlyAddedToList = 6;
    final int tsSynataxError = 7;
    final int tsSynataxErrorProcessed = 8;
    final int tsAddbyHand = 9;
    final int tsAddedInTokensInScript = 10;
    //final int tsNotStartTokenOfSQL,
    final int tsIgnoredByGetRawStatement = 11;
    final int tsDummyStatus = 12;

    // Vendor-specific SQL command resolver (injected by TGSqlParser)
    public gudusoft.gsqlparser.sqlcmds.ISqlCmds sqlcmds;
    public TCustomLexer lexer;

    TParseTreeNode tmpnode,tmpnode1,tmpnode2,tmpnode3,tmpnode4;
    
    int yyflag;//    yyfnone,yyfaccept,yyfabort   ,yyferror
    int nextstmtstartpos , curtokenpos,stmtendpos;
    TSourceToken acceptedtoken,currentsourcetoken,recovertoken,errorstmtstarttoken;
    int currentyystate,currentyysp,currentyyn;
    int[] retvalue = {0};   // used when need to pass VAR variable to a function, return value by this variable
    public TCustomSqlStatement sql;

    public TNodeFactory getNf() {
        return nf;
    }

    private TCustomParser(){
        curtokenpos = 0;
        yylval = new TDatabaseYYSType();
        yyv =    new TDatabaseYYSType[yymaxdepth + 1]; //1 based
        yys =    new int[yymaxdepth + 1]; // 1 based, reused across parse calls
        yyval = null;
        // sqlcmds will be injected by TGSqlParser based on vendor
    }

    TCustomParser(EDbVendor pDbVendor){
        this();
        this.dbvendor = pDbVendor;
        nf = new TNodeFactory(this.dbvendor);
    }

    TParseTreeNodeList yacclcons(Object obj, TParseTreeNodeList parseTreeNodeList,boolean IsParse){
        return null;
    }

    TParseTreeNodeList yaccmakeList1(Object x1,boolean IsParse){
      return null;
    }
    
    TParseTreeNodeList yaccmakeList2(Object x1,Object x2,boolean IsParse){
      return null;
    }
    
    TParseTreeNodeList yaccnconc(TParseTreeNodeList l1, TParseTreeNodeList l2){
        return null;
    }
    TParseTreeNodeList yacclappend(TParseTreeNodeList parseTreeNodeList,Object obj,boolean IsParse){
        return null;
    }
    int yylexwrap(boolean isignore){
        int ret = 0;
        if (sourcetokenlist == null)  return ret;
        TSourceToken ast = getasourcetoken(isignore);
        if (ast == null ) return ret;
        if (ast.tokencode == 0) return ret;
        yylval.yyTSourceToken = ast;

        if ((yylval.yyTSourceToken.tokencode == TBaseType.bind_v)
        && (dbvendor == EDbVendor.dbvmysql))
        {
            yylval.yyTSourceToken.tokencode = TBaseType.ident;
            //yylval.yyTSourceToken.nodetype := T_BindV;
        }
        if (dbvendor == EDbVendor.dbvoracle){
            yylval.yyTSourceToken.tag = 0;
        }
        //System.out.println(yylval.yyTSourceToken.toString());
        return yylval.yyTSourceToken.tokencode;
    }

    TSourceToken read_to_next_parentheses(boolean isIncluding){
        return read_to_next_parentheses(isIncluding, new TDummy());
    }

    TSourceToken read_to_next_parentheses(boolean isIncluding, TParseTreeNode ownerNode){
        int nested = 0;
        int yychar = -1;

        TSourceToken ret = null,prevSt = null;


        while (true){
            yychar = yylexwrap(false);//yyLexer.yylexwrap;
            if (yychar<0) {yychar = 0;}
            if (yychar == 0) { return ret;}

            if (yylval.yyTSourceToken.tokentype == ETokenType.ttleftparenthesis)
            {nested++;}

            if (yylval.yyTSourceToken.tokentype == ETokenType.ttrightparenthesis)
            {nested--;}

            if (prevSt == null){
                ownerNode.setStartToken(yylval.yyTSourceToken);
            }

            if (nested < 0)
            {
                //curtokenpos--; //rollback ')'
                if (isIncluding) {
                    stmtendpos = curtokenpos;// - 1;
                    ret = yylval.yyTSourceToken;
                    ownerNode.setEndToken(ret);
                }else{
                    curtokenpos--;
                    stmtendpos = curtokenpos;// - 1;
                    ret = prevSt;
                    ownerNode.setEndToken(ret);
                }
                break; // end of this node
            }

            ret = yylval.yyTSourceToken;

            if (yylval.yyTSourceToken.tokentype == ETokenType.ttsemicolon)
            {
                ownerNode.setEndToken(ret);
                break;
            }

            prevSt =  yylval.yyTSourceToken;
        } // while

        return ret;

    }

    TSourceToken read_before_subquery(){
        int yychar = -1;
        TSourceToken ret = null;

        while (true){
            yychar = yylexwrap(false);//yyLexer.yylexwrap;
            if (yychar<0) {yychar = 0;}
            if (yychar == 0) { return ret;}

            if (yylval.yyTSourceToken.tokencode == TBaseType.rrw_as)
            {
                TSourceToken next = yylval.yyTSourceToken.nextSolidToken();
                if (next != null){
                    if ((next.tokencode == TBaseType.rrw_select)||(next.tokencode == TBaseType.rrw_with)){
                        curtokenpos--;
                        break;
                    }
                }
            }

            ret = yylval.yyTSourceToken;
            if (yylval.yyTSourceToken.tokentype == ETokenType.ttsemicolon)
            {
                break;
            }
        } // while

        return ret;

    }

    TokenAndText read_consume_valid_filename_token(boolean removeTokenBeforeWhitespace) {
        int yychar = -1;
        String ret = "";
        TSourceToken lastToken = null;

        while (true) {
            yychar = yylexwrap(false); // yyLexer.yylexwrap;
            if (yychar < 0) {
                yychar = 0;
            }
            if (yychar == 0) {
                return new TokenAndText(lastToken, ret);
            }

            if ((yylval.yyTSourceToken.tokentype == ETokenType.ttwhitespace)
                    || (yylval.yyTSourceToken.tokentype == ETokenType.ttreturn)
                    || (yylval.yyTSourceToken.tokentype == ETokenType.ttsemicolon)
                    || (yylval.yyTSourceToken.tokencode == ')')
                    || (yylval.yyTSourceToken.tokencode == '(')
            ) {
                curtokenpos--; // rollback to ensure the token is not consumed
                break;
            }


            ret = ret + yylval.yyTSourceToken.toString();
            lastToken = yylval.yyTSourceToken;
            if (removeTokenBeforeWhitespace) {
                yylval.yyTSourceToken.tokenstatus = ETokenStatus.tsdeleted;
            }
        }
        return new TokenAndText(lastToken, ret);
    }

    TSourceToken read_before_this_token(int[] pTokenCodes){
        int yychar = -1;
        TSourceToken ret = null;
        boolean found = false;

        while (true){
            yychar = yylexwrap(false);//yyLexer.yylexwrap;
            if (yychar<0) {yychar = 0;}
            if (yychar == 0) { return ret;}

            for(int k=0;k<pTokenCodes.length;k++){
                if (yylval.yyTSourceToken.tokencode == pTokenCodes[k])
                {
                    found = true;
                    curtokenpos--;
                    break;
                }
            }
            if (found) break;
            ret = yylval.yyTSourceToken;
            if (yylval.yyTSourceToken.tokentype == ETokenType.ttsemicolon)
            {
                break;
            }
        } // while

        return ret;
    }

    TSourceToken read_before_this_token(int pTokenCode){
        return read_before_this_token(new int[] {pTokenCode});
    }

    TSourceToken read_to_semicolon(){
        return  read_to_semicolon(new TDummy(),true);
    }

    TSourceToken read_to_semicolon(boolean includeSemicolon){
        return  read_to_semicolon(new TDummy(),includeSemicolon);
    }

    TSourceToken read_to_semicolon(TParseTreeNode ownerNode){
        return  read_to_semicolon(ownerNode,true);
    }

    TSourceToken read_to_semicolon(TParseTreeNode ownerNode,boolean includeSemicolon){

        int yychar = -1;

        TSourceToken ret = null;

        while (true){
            yychar = yylexwrap(false);//yyLexer.yylexwrap;
            if (yychar<0) {yychar = 0;}
            if (yychar == 0) { return ret;}

            if ((ret == null)&&(ownerNode.getStartToken() == null)){
                ownerNode.setStartToken(yylval.yyTSourceToken);
            }
            ret = yylval.yyTSourceToken;

            if (yylval.yyTSourceToken.tokentype == ETokenType.ttsemicolon)
            {
                break;
            }
        } // while
        if (ret.tokentype == ETokenType.ttsemicolon){
            ownerNode.setEndToken(ret.getPrevTokenInChain());
            if (!includeSemicolon){
                curtokenpos -- ;
            }
        }else{
            ownerNode.setEndToken(ret);
        }

        return ret;

    }

    TSourceToken read_a_token( ){

        int yychar = -1;

        TSourceToken ret = null;
        yychar = yylexwrap(false);
        ret = yylval.yyTSourceToken;

        return ret;

    }


    TSourceToken read_to_this_token( int tokenCode){

        int yychar = -1;

        TSourceToken ret = null;

        while (true){
            yychar = yylexwrap(false);//yyLexer.yylexwrap;
            if (yychar<0) {yychar = 0;}
            if (yychar == 0) { return ret;}

            ret = yylval.yyTSourceToken;

            if (yylval.yyTSourceToken.tokencode == tokenCode)
            {
                break;
            }
        } // while

        return ret;

    }

    /**
     * Read tokens until we encounter double closing braces }}
     * Used for MLE JavaScript code blocks: AS MLE LANGUAGE JAVASCRIPT {{ ... }}
     */
    TSourceToken read_to_double_close_brace(){
        int yychar = -1;
        TSourceToken ret = null;
        TSourceToken prevToken = null;

        while (true){
            yychar = yylexwrap(false);
            if (yychar < 0) {yychar = 0;}
            if (yychar == 0) { return ret;}

            ret = yylval.yyTSourceToken;

            // Check if we have }} (two consecutive closing braces)
            if (prevToken != null &&
                prevToken.tokencode == '}' &&
                ret.tokencode == '}') {
                break;
            }

            prevToken = ret;
        }

        return ret;
    }

    TSourceToken getasourcetoken(boolean isignore){
      TSourceToken newst = null;
      int j;
      if (sourcetokenlist == null) return null;

        if (curtokenpos > sourcetokenlist.size() - 1) return null;
        for (j = curtokenpos; j < sourcetokenlist.size();j++)
        {
            newst = sourcetokenlist.get(j);
            if ((newst.tokencode == TBaseType.lexspace) && isignore)   continue;
            if ((newst.tokencode == TBaseType.lexnewline) && isignore)  continue;
            if ((newst.tokencode == TBaseType.cmtdoublehyphen) && isignore)  continue;
            if ((newst.tokencode == TBaseType.cmtslashstar) && isignore)  continue;
            if ((newst.tokenstatus == ETokenStatus.tsignorebyyacc))  continue;

            if (newst.tokenstatus != ETokenStatus.tsdeleted)  break;
        }
        if (j == sourcetokenlist.size()) return null;
        else
          curtokenpos = curtokenpos + (j-curtokenpos+1);

        // System.out.println("curtokenpos:"+curtokenpos+" "+newst);

//        pstr := '';
//        asqlstatement := TCustomSqlStatement(sqlstatement);
//
//        //check bind variable
//        // if (newst.TokenType = ttBindVar) and (dbvendor <> dbvmssql) and (newst.TokenStatus <> tsDeleted) then
//        if (newst.TokenType = ttBindVar) and  (newst.TokenStatus <> tsDeleted) then
//          begin
//            if assigned(onBindVar) then
//              begin
//                onBindVar(self,copy(newst.SourceCode,2,length(newst.SourceCode)-1),pstr);
//              end;
//            // newst.TokenType := ttIdentifier;
//            if assigned(asqlstatement) then
//              begin
//                lcValue := TLzValue.create(asqlstatement);
//                lcValue.ValueName := copy(newst.SourceCode,2,length(newst.SourceCode)-1);
//                lcValue.ValueStr := pstr;
//                lcValue.SourceToken := newst;
//                asqlstatement.params.add(lcValue);
//              end;
//            if length(pstr) <> 0 then
//              newst.SourceCode := pstr;
//          end;

//        //check  variable
//        // if (newst.TokenType = ttSqlVar) and (dbvendor <> dbvmssql) and (newst.TokenStatus <> tsDeleted) then
//        if (newst.TokenType = ttSqlVar)  and (newst.TokenStatus <> tsDeleted) then
//          begin
//            if assigned(onSqlVar) then
//              begin
//                onSqlVar(self,copy(newst.SourceCode,2,length(newst.SourceCode)-1),pstr);
//              end;
//            if dbvendor <> dbvmssql then
//              newst.TokenType := ttIdentifier;
//            if assigned(asqlstatement) then
//              begin
//                lcValue := TLzValue.create(asqlstatement);
//                lcValue.ValueName := copy(newst.SourceCode,2,length(newst.SourceCode)-1);
//                lcValue.ValueStr := pstr;
//                lcValue.SourceToken := newst;
//                asqlstatement.sqlvars.add(lcValue);
//              end;
//            if length(pstr) <> 0 then
//              newst.SourceCode := pstr;
//          end;
//
//         pstr := '';
//
//        try
//          if assigned(OnParserToken)
//            and (newst.CodeSource = csOriginal)
//            and (newst.TokenStatus <> tsDeleted)
//            and (newst.TokenType <> ttBindVar)
//          then OnParserToken(self,newst,Integer(DbVendor));
//        except
//         // paot := aotNone;
//        end;

//        if (newst.tokenstatus = tsDeleted) then
//          begin
//            if assigned(RecoverToken) then
//              begin
//                newst := RecoverToken;
//                RecoverToken := nil;
//              end
//            else
//              newst := GetASourceToken(IsIgnore);
//          end;

        return newst;
    }

    int dobefore_yyparse(){
        int ret = 10000;
        for (int i=0; i< sourcetokenlist.size();i++)
        {      // if there are no solid tokentext in list, return -1, don't parse anymore
            if( (sourcetokenlist.get(i).tokentype == ETokenType.ttwhitespace)
            || (sourcetokenlist.get(i).tokentype == ETokenType.ttreturn)
            || (sourcetokenlist.get(i).tokencode == TBaseType.cmtdoublehyphen)
            || (sourcetokenlist.get(i).tokencode == TBaseType.cmtslashstar) )
            {continue;}
            else
            {
                ret = 0;
                break;
            }
        }

        return ret;

    }

    //spFatalError yyparse stack overflow error 1010 ,CurrentSourceToken.lines,CurrentSourceToken.columns
    void onparseerrorhandle(EErrorType errortype,String pmsg,String token,long xposition,long yposition, int errorno){
        if (sql != null){
           sql.parseerrormessagehandle( new TSyntaxError(token,xposition,yposition,pmsg,errortype,errorno,null,-1));
        }else{
            System.out.println(pmsg);
        }
    }

    boolean yyact(int state,int sym,int[] act){
     return false;
    }

    boolean yygoto(int state, int sym,int[] nstate){
       return false;
    }

    /**
     * according to the input state and sym, get the new state from the goto table
     * return false if no state found (this will cause a parse error), otherwise return true, and the new state is stored in nstate[0]
     *
     * if method is called when a reduce action is performed.
     *
     * @param state
     * @param sym
     * @param nstate
     * @param p_yygl
     * @param p_yygh
     * @param p_yyg_sym
     * @param p_yyg_act
     * @return
     */
    boolean yygoto(int state, int sym,int[] nstate, int[] p_yygl, int[] p_yygh, int[] p_yyg_sym,  int[] p_yyg_act){
        boolean r;
        int k = p_yygl[state];
        while ((k<=p_yygh[state]) && (p_yyg_sym[k] != sym)) {k++;}
        if (k>p_yygh[state])
            r = false;
        else
        {
            nstate[0] = p_yyg_act[k];
            r = true;
        }
        return r;
    }

    /**
     * according to the input state and sym, get the action from the action table
     * return false if no action found (this will cause a parse error), otherwise return true, and the action is stored in act[0]
     * if act[0] > 0, it means shift, the value is the new state, can be used in yyact() method
     * if act[0] < 0, it means reduce, the value is the rule number, used in yyaction(-value) method
     * if act[0] = 0, it means parse completed successfully.
     *
     * @param state
     * @param sym
     * @param act
     * @param p_yyal
     * @param p_yyah
     * @param p_yya_sym
     * @param p_yya_act
     * @return
     */
    boolean yyact(int state,int sym,int[] act, int[] p_yyal, int[] p_yyah, int[] p_yya_sym, int[] p_yya_act){
        boolean r;
        int k = p_yyal[state];
        while ((k <= p_yyah[state]) && (p_yya_sym[k] != sym) ) {k++;}
        if (k>p_yyah[state])
            r = false;
        else {
            act[0]  = p_yya_act[k];
            r = true;
        }
        return r;
    }

    public int do_yyparse(int [] p_yyd,
                          int [] p_yyal, int [] p_yyah, int [] p_yya_sym, int[] p_yya_act,
                          int [] p_yygl, int [] p_yygh, int [] p_yyg_sym, int [] p_yyg_act,
                          int [] p_yyr_len,int [] p_yyr_sym,
                          Map<Integer, int[]> p_rollbackTokens
                          ){
        int lcprevyysp,lcyystate,lcyyn,yyn=0;
        // yys array is now an instance field, reused across parse calls for performance
        TDatabaseYYSType rollback_token = null;
        int lcAction;
        boolean lcrollbackstate ;
        int lcrollbacktokens;

        curtokenpos = 0;
        int lcRetries = dobefore_yyparse();//super.yyparse();
        if (lcRetries == -1)
        { // no solid tokentext in tokentext list
            return 0;
        }

        int rollback_mode = 0;
        int yystate = 0, yychar = -1, yynerrs = 0, yyerrflag = 0;
        yysp = 0;
        boolean lcIsError = false;
        boolean lcIsParse = false;
        boolean lcIsReduce= false;
        boolean lcIsShift = false;

        int rollback_state = yystate;
        int rollback_sp = yysp;

        boolean isBeginOfBatch = true; //used in mssql
        boolean lccanreduce; // used in mssql

        isbeginofbatch = true;

        while (true){ // the main loop for parsing

            // this is the point where parse started:

            yysp++;
            if (yysp > yymaxdepth)
            {
                // yyerror('yyparse stack overflow');
                onparseerrorhandle(EErrorType.spfatalerror, "yyparse stack overflow error 1010" , currentsourcetoken.getAstext(),currentsourcetoken.lineNo,currentsourcetoken.columnNo,10010);
                //goto abort;
//                if (dbvendor == EDbVendor.dbvmssql){
//                    onparseerrorhandle(EErrorType.spfatalabort,"abort !!! error 1001",currentsourcetoken.astext ,currentsourcetoken.lineNo,currentsourcetoken.columnNo,10011);
//                }

                return 10001;
            }

            yys[yysp] = yystate;
            yyv[yysp] = yyval;

            while (true){
                // this is the point where NEXT is started:
                // get next symbol

                if( (p_yyd[yystate] == 0) && (yychar == -1))
                //(* get next symbol *)
                {
                    do{
                        yychar = yylexwrap(true);//yyLexer.yylexwrap;
                        if (yychar<0) { yychar = 0;}
                        // ignore comments and blanks [ \n\t]
                        //if not( (yychar=_COMMENT) or (yychar=_BLANK) or
                        //        (yychar=_TAB) or (yychar=_NEWLINE) ) then break;
                        if (!( (yychar== TBaseType.cmtdoublehyphen)|| (yychar== TBaseType.cmtslashstar) ||
                                (yychar== TBaseType.lexspace) || (yychar== TBaseType.lexnewline) ||  (yychar== TBaseType.sqlpluscmd) ))
                        {
                            if (yychar == 0)
                            {
                                //System.out.println("error tokentext:"+yylval.yyTSourceToken+"c "+currentsourcetoken);
                                if ( ( sourcetokenlist.get(sourcetokenlist.size() - 1)).tokencode != 0)
                                {
                                    //System.out.println("yychar is 0, but tokencode is:"+ ( sourcetokenlist.get(sourcetokenlist.size() - 1)).tokencode);
                                    yylval.yyTSourceToken =  new TSourceToken(" ");
                                    //                                      NewSourceToken(yylval.yyTSourceToken,'',ttUnknown,wtNotAWord,eNotAComment,-1,-1);
                                    yylval.yyTSourceToken.container = sourcetokenlist;
                                    yylval.yyTSourceToken.tokencode = 0;
                                    //sourcetokenlist.add(yylval.yyTSourceToken);
                                    yylval.yyTSourceToken.posinlist = sourcetokenlist.size() - 1;
                                    curtokenpos = sourcetokenlist.size();
                                    //showmessage('end of input');
                                }
                                else
                                {
                                    yylval.yyTSourceToken =  sourcetokenlist.get(sourcetokenlist.size() - 1);
                                    // showmessage('end of input again');
                                }
                            }

                            currentsourcetoken = yylval.yyTSourceToken;
                            break;
                        }
                        else
                        {
                            //ignore non solid tokentext
                        }

                    } while (true);

                    // Proof-mode cutoff (design R4 commitment check). The token
                    // has been READ but not shifted, and no action has been
                    // looked up for it yet, so the stack here is exactly what
                    // the literal prefix committed to — uncontaminated by the
                    // unstable token. Stop by RETURNING rather than by falling
                    // into error handling: MSSQL recovery pops the stack looking
                    // for a state that shifts `error`, destroying the snapshot.
                    if (proofLrCutoffOffset >= 0 && proofLrConfiguration == null
                            && currentsourcetoken != null
                            && currentsourcetoken.offset >= proofLrCutoffOffset)
                    {
                        int[] stackCopy = new int[yysp];
                        for (int i = 1; i <= yysp; i++)
                        {
                            stackCopy[i - 1] = yys[i];
                        }
                        proofLrConfiguration = new ProofLrConfiguration(stackCopy,
                                currentsourcetoken.offset, yychar, proofLrReductions);
                        return PROOF_LR_STOPPED_AT_CUTOFF;
                    }
                } //(* get next symbol *)

                if  (!lcIsError)
                {
                    yyn = p_yyd[yystate];
                    if (yyn != 0)
                    {
                        //goto reduce; (* simple state *)
                        lcIsReduce = true;
                        break;
                    }

                    // (* no default action; search parse table *)
                    boolean foundAction = yyact(yystate, yychar, retvalue,p_yyal,p_yyah,p_yya_sym,p_yya_act);
                    if(foundAction) {yyn = retvalue[0];}
                    if (! foundAction)
                    { // no action found, here we do error handling
                        // Proof-mode observability (DynamicSqlProofHarness): every
                        // entry into error handling — keyword rollback included —
                        // is a recovery event. A parse that needed ANY recovery is
                        // not evidence for the dynamic-SQL publication proof, even
                        // when the rollback silently succeeds.
                        proofRecoveryEvents++;
                        // lcRestartPos :=   curtokenpos;

                        lcAction = aopAbort;
                        lcrollbackstate = false;
                        lcrollbacktokens = 0;

                        //if parse error occurs due to a keyword, then change this keyword to identifier
                        // and retry again,
                        // for example

                        // select a.wait from b
                        // wait is a keyword, can not be field name due to .y file,
                        // but it's a legal in mssql, use this procedure while during parsing,
                        // we can fix such problem which is very common
                        // we don't recover from FROM keyword

                        if ((yylval.yyTSourceToken.tokencode >= TBaseType.rrw_select )
                                && (yylval.yyTSourceToken.tokencode != TBaseType.rrw_from )
                                && (dbvendor != EDbVendor.dbvmssql?true:(yylval.yyTSourceToken.tokencode != TBaseType.rrw_where ))
                        )
                        {
                            proofKeywordRollbackEvents++;
                            // 如果一个token有多个侯备的其他token可以尝试，我们逐一尝试，如果没有成功的，将token类型改为ident进行最后尝试，还不成功，则报错。

                            int[] rollbackTokens = new int[1];
                            rollbackTokens[0] = TBaseType.ident;
                            if ((p_rollbackTokens!=null) && (p_rollbackTokens.containsKey(yylval.yyTSourceToken.tokencode))) {
                                rollbackTokens = p_rollbackTokens.get(yylval.yyTSourceToken.tokencode);
                            }

                            for(int i=0;i<rollbackTokens.length;i++)
                            {
                                yylval.yyTSourceToken.tokencode = rollbackTokens[i];
                                if (yyact(yystate, yylval.yyTSourceToken.tokencode, retvalue, p_yyal,p_yyah,p_yya_sym,p_yya_act))
                                {
                                    yyn = retvalue[0];
                                    if (yyn>0)
                                    {
                                        //goto shift;
                                        lcIsShift = true;
                                        break;
                                    }
                                    else if( yyn<0 )
                                    {
                                        // goto reduce
                                        lcIsReduce = true;
                                        break;
                                    }
                                    else
                                    {
                                        // goto accept;
                                        return 0;
                                    }
                                }
                            }

                            if (lcIsShift||lcIsReduce)
                            {
                                if (yylval.yyTSourceToken.tokencode == TBaseType.ident){
                                    yylval.yyTSourceToken.tokentype = ETokenType.ttidentifier;
                                }
                                yychar = yylval.yyTSourceToken.tokencode;
                                break;
                            }
                        }

                        // end of error recover

                        if (lcAction == aopAbort )
                        {
                            // goto error;
                            lcIsError = true;
                        }
                    }
                    else if (yyn>0)
                    {
                        //goto shift;
                        lcIsShift = true;
                        break;
                    }
                    else if( yyn<0 )
                    {
                        // goto reduce
                        lcIsReduce = true;
                        break;
                    }
                    else
                    {
                        // goto accept;
                        return 0;
                    }

                } // if not lcIsError

                if (lcIsError)
                {
                    lcIsError = false;

                    if ((dbvendor == EDbVendor.dbvmssql)||(dbvendor == EDbVendor.dbvsybase)||(dbvendor == EDbVendor.dbvsybasease || dbvendor == EDbVendor.dbvsqlanywhere || dbvendor == EDbVendor.dbvsybaseiq)){
                        if (yyerrflag<=2)                //  (* incomplete recovery; try again *)
                        {
                            yyerrflag = 3;
                            //(* uncover a state with shift action on error tokentext *)
                            //(* error; start error recovery: *)


                            lcprevyysp = yysp;
                            while ((yysp>0)
                                    &&  !( yyact(yys[yysp], _error, retvalue,p_yyal,p_yyah,p_yya_sym,p_yya_act)
                                    &&( (yyn = retvalue[0]) >0 )
                            )
                            )
                            {
                                yysp--;
                            }

                            if (lcprevyysp != yysp) // if error stmt is just the next state need, then it's a fake error, don't report
                                geterrormsg(yystate, yychar,10101);

                            if (yysp==0)
                            {
                                //assert(1=2,'Should be an error handle rule in y file, never goes to here!!!');
                                onparseerrorhandle(EErrorType.spfatalerror,"error recover failed error", currentsourcetoken.getAstext(),currentsourcetoken.lineNo,currentsourcetoken.columnNo,10012);
                                //goto abort; (* parser has fallen from stack; abort *)

                                onparseerrorhandle(EErrorType.spfatalabort,"abort !!! error 1001", currentsourcetoken.getAstext(),currentsourcetoken.lineNo,currentsourcetoken.columnNo,10013);

                                return 10003;
                            }


                            errorstmtstarttoken = null;


                            yystate = yyn; //           (* simulate shift on error *)
                            yychar = -1;
                            stmtendpos = curtokenpos-1;

                            //goto parse;
                            lcIsParse = true;
                            break;
                        }
                        else   //(yyerrflag<=2)                               (* no shift yet; discard symbol *)
                        {
                            if (yychar==0)
                            {

                                // goto abort; (* end of input; abort *)
                                onparseerrorhandle(EErrorType.spfatalabort, "abort !!! error 1001", currentsourcetoken.getAstext(),currentsourcetoken.lineNo,currentsourcetoken.columnNo,10013);

                                return  10004;
                            }

                            yychar = -1;
                            stmtendpos = curtokenpos-1;
                            sourcetokenlist.get(curtokenpos-1).tokenstatus = ETokenStatus.tssynataxerror;
                            //  showmessage('lookahead:'+inttostr(curtokenpos-1)+'->'+sourcetokenlist[curtokenpos-1].astext+'->yyd[yystate]:'+inttostr(yystate));
                            // goto next;     (* clear lookahead char and try again *)
                            continue;
                        }

                    }else{

                        // Enhanced parser to handle SQL statements that are missing a semicolon at the end. 
                        // When a statement without a semicolon is encountered, the parser will attempt to add a virtual semicolon and continue parsing rather than throwing an error. This improves parsing robustness for incomplete statements.

                        // 如果当前token是0 (end of input)，并且可以shift一个分号，则shift一个分号，否则报错
                        if (yychar == 0 && yyact(yystate, ';', retvalue, p_yyal,p_yyah,p_yya_sym,p_yya_act) && retvalue[0] > 0) {
                            yyn = retvalue[0];
                            lcIsShift = true;
                            break;
                        }
                        geterrormsg(yystate, yychar,10102);
                        return 10102;
                    }

                }// if lcIsError

            }  //next

            if (lcIsParse)
            {
                lcIsParse = false;
                continue;
            }

            if (lcIsShift)
            {
                // this is the point where SHIFT is started:

                lcIsShift = false;
                //(* go to new state, clear lookahead character: *)
                rollback_state = yystate;
                rollback_mode = 1;
                rollback_sp = yysp;
                rollback_token = yyval;
                if ((yyerrflag>0) && (yychar != _error ) )
                {
                    if ((dbvendor == EDbVendor.dbvmssql)||(dbvendor == EDbVendor.dbvsybase)||(dbvendor == EDbVendor.dbvsybasease || dbvendor == EDbVendor.dbvsqlanywhere || dbvendor == EDbVendor.dbvsybaseiq)){
                        nextstmtstartpos = curtokenpos - 1;
                    }
                    yyerrflag--;
                }
                yystate = yyn;
                yychar = -1;
                yyval = new TDatabaseYYSType();
                yyval.copy( yylval);

                if (lcRetries > 0) lcRetries--;

                if ((dbvendor == EDbVendor.dbvmssql)||(dbvendor == EDbVendor.dbvsybase)||(dbvendor == EDbVendor.dbvsybasease || dbvendor == EDbVendor.dbvsqlanywhere || dbvendor == EDbVendor.dbvsybaseiq)){
                    stmtendpos = curtokenpos - 1; // tokentext became part of stmt only after shift
                    acceptedtoken = currentsourcetoken;
                }

                // goto parse;
                continue;

            }//if lcIsShift

            if (lcIsReduce)
            {
                // this is the point where REDUCE is started:

                lcIsReduce = false;

                //(* execute action, pop rule from stack, and go to next state: *)
                // yyval.yyTLz_Parse_Tree_Node := nil;
                yyflag = yyfnone;
                yyval = new TDatabaseYYSType();
                yyaction(-yyn);

                // Proof-mode observation: record the reduction BEFORE the pop,
                // so the rule's extent on the stack is still visible. yychar is
                // -1 when this is a default reduction, i.e. one the prefix
                // determined without any lookahead.
                if (proofLrReductions != null && proofLrConfiguration == null)
                {
                    proofLrReductions.add(new ProofReduction(-yyn, p_yyr_len[-yyn],
                            p_yyr_sym[-yyn], yysp,
                            (yychar == -1 || currentsourcetoken == null)
                                    ? -1L : currentsourcetoken.offset));
                }

                rollback_mode = 2;
                yysp = yysp - p_yyr_len[-yyn];

                if (yygoto(yys[yysp], p_yyr_sym[-yyn], retvalue,p_yygl,p_yygh,p_yyg_sym,p_yyg_act))
                {
                    yyn = retvalue[0];
                    yystate = yyn;
                }

                //(* handle action calls to yyaccept, yyabort and yyerror: *)
                // goto parse;
                continue;

            } //if lcIsReduce

        }   // parse

    }


    void  geterrormsg(int state, int sym, int errorno){
        if (sql != null){
            String s;
           if (sym == 0){
               s = "end of input, state:"+state;
           }else{
               s = "syntax error, state:"+state;
           }
          //System.out.println(currentsourcetoken);
//          if (currentsourcetoken != null){
//              s = s+"toke code:"+currentsourcetoken.tokencode+" ,token type:"+currentsourcetoken.tokentype;
//          }

            sql.parseerrormessagehandle(new TSyntaxError(currentsourcetoken,s, EErrorType.spfatalerror,errorno,null));



        }else
          System.out.println("syntax error 10033,state:"+state);

    }
    


    void yyaction (int yyruleno){

    }
    
public int yyparse(){
    return -1;
}

}

class TDatabaseYYSType {
    String yylzString;
    TSourceToken yyTSourceToken;
    TParseTreeNodeList yyTParseTreeNodeList;
    TParseTreeNode yyTParseTreeNode;
    TSourceTokenList yyTSourceTokenList;
    ArrayList yyArrayList;
   // TStatementList yyTStatementList;
    
    public void copy(TDatabaseYYSType p){
       yyTSourceToken = p.yyTSourceToken;
       yyTParseTreeNodeList = p.yyTParseTreeNodeList;
       yyTParseTreeNode = p.yyTParseTreeNode;
        yyTSourceTokenList = p.yyTSourceTokenList;
        yyArrayList = p.yyArrayList;
    }
}

class TokenAndText{
    public TSourceToken lastToken;
    public String text;

    public TokenAndText(TSourceToken lastToken, String text) {
        this.lastToken = lastToken;
        this.text = text;
    }
}