// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: resolveExprStep
static int resolveExprStep(Walker *pWalker, Expr *pExpr){
  NameContext *pNC;
  Parse *pParse;

  pNC = pWalker->u.pNC;
  assert( pNC!=0 );
  pParse = pNC->pParse;
  assert( pParse==pWalker->pParse );

  if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return WRC_Prune;
  ExprSetProperty(pExpr, EP_Resolved);
#ifndef NDEBUG
  if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
    SrcList *pSrcList = pNC->pSrcList;
    int i;
    for(i=0; i<pNC->pSrcList->nSrc; i++){
      assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
    }
  }
#endif
  switch( pExpr->op ){

#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
    /* The special operator TK_ROW means use the rowid for the first
    ** column in the FROM clause.  This is used by the LIMIT and ORDER BY
    ** clause processing on UPDATE and DELETE statements.
    */
    case TK_ROW: {
      SrcList *pSrcList = pNC->pSrcList;
      struct SrcList_item *pItem;
      assert( pSrcList && pSrcList->nSrc==1 );
      pItem = pSrcList->a; 
      pExpr->op = TK_COLUMN;
      pExpr->pTab = pItem->pTab;
      pExpr->iTable = pItem->iCursor;
      pExpr->iColumn = -1;
      pExpr->affinity = SQLITE_AFF_INTEGER;
      break;
    }
#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */

    /* A lone identifier is the name of a column.
    */
    case TK_ID: {
      return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
    }
  
    /* A table name and column name:     ID.ID
    ** Or a database, table and column:  ID.ID.ID
    */
    case TK_DOT: {
      const char *zColumn;
      const char *zTable;
      const char *zDb;
      Expr *pRight;

      /* if( pSrcList==0 ) break; */
      pRight = pExpr->pRight;
      if( pRight->op==TK_ID ){
        zDb = 0;
        zTable = pExpr->pLeft->u.zToken;
        zColumn = pRight->u.zToken;
      }else{
        assert( pRight->op==TK_DOT );
        zDb = pExpr->pLeft->u.zToken;
        zTable = pRight->pLeft->u.zToken;
        zColumn = pRight->pRight->u.zToken;
      }
      return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
    }

    /* Resolve function names
    */
    case TK_CONST_FUNC:
    case TK_FUNCTION: {
      ExprList *pList = pExpr->x.pList;    /* The argument list */
      int n = pList ? pList->nExpr : 0;    /* Number of arguments */
      int no_such_func = 0;       /* True if no such function exists */
      int wrong_num_args = 0;     /* True if wrong number of arguments */
      int is_agg = 0;             /* True if is an aggregate function */
      int auth;                   /* Authorization to use the function */
      int nId;                    /* Number of characters in function name */
      const char *zId;            /* The function name. */
      FuncDef *pDef;              /* Information about the function */
      u8 enc = ENC(pParse->db);   /* The database encoding */

      testcase( pExpr->op==TK_CONST_FUNC );
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      notValidPartIdxWhere(pParse, pNC, "functions");
      zId = pExpr->u.zToken;
      nId = sqlite3Strlen30(zId);
      pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
      if( pDef==0 ){
        pDef = sqlite3FindFunction(pParse->db, zId, nId, -2, enc, 0);
        if( pDef==0 ){
          no_such_func = 1;
        }else{
          wrong_num_args = 1;
        }
      }else{
        is_agg = pDef->xFunc==0;
      }
#ifndef SQLITE_OMIT_AUTHORIZATION
      if( pDef ){
        auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
        if( auth!=SQLITE_OK ){
          if( auth==SQLITE_DENY ){
            sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
                                    pDef->zName);
            pNC->nErr++;
          }
          pExpr->op = TK_NULL;
          return WRC_Prune;
        }
      }
#endif
      if( is_agg && (pNC->ncFlags & NC_AllowAgg)==0 ){
        sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
        pNC->nErr++;
        is_agg = 0;
      }else if( no_such_func && pParse->db->init.busy==0 ){
        sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
        pNC->nErr++;
      }else if( wrong_num_args ){
        sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
             nId, zId);
        pNC->nErr++;
      }
      if( is_agg ) pNC->ncFlags &= ~NC_AllowAgg;
      sqlite3WalkExprList(pWalker, pList);
      if( is_agg ){
        NameContext *pNC2 = pNC;
        pExpr->op = TK_AGG_FUNCTION;
        pExpr->op2 = 0;
        while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){
          pExpr->op2++;
          pNC2 = pNC2->pNext;
        }
        if( pNC2 ) pNC2->ncFlags |= NC_HasAgg;
        pNC->ncFlags |= NC_AllowAgg;
      }
      /* FIX ME:  Compute pExpr->affinity based on the expected return
      ** type of the function 
      */
      return WRC_Prune;
    }
#ifndef SQLITE_OMIT_SUBQUERY
    case TK_SELECT:
    case TK_EXISTS:  testcase( pExpr->op==TK_EXISTS );
#endif
    case TK_IN: {
      testcase( pExpr->op==TK_IN );
      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        int nRef = pNC->nRef;
        notValidCheckConstraint(pParse, pNC, "subqueries");
        notValidPartIdxWhere(pParse, pNC, "subqueries");
        sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
        assert( pNC->nRef>=nRef );
        if( nRef!=pNC->nRef ){
          ExprSetProperty(pExpr, EP_VarSelect);
        }
      }
      break;
    }
    case TK_VARIABLE: {
      notValidCheckConstraint(pParse, pNC, "parameters");
      notValidPartIdxWhere(pParse, pNC, "parameters");
      break;
    }
  }
  return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5f7b6
movl $0x1, -0x4(%rbp)
jmp 0x5fcfb
movq -0x18(%rbp), %rax
movw 0x2(%rax), %cx
orw $0x4, %cx
movw %cx, 0x2(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x90(%rbp)
subl $0x14, %eax
je 0x5fc16
jmp 0x5f7de
movl -0x90(%rbp), %eax
subl $0x1a, %eax
je 0x5f856
jmp 0x5f7eb
movl -0x90(%rbp), %eax
subl $0x48, %eax
je 0x5fc18
jmp 0x5f7fc
movl -0x90(%rbp), %eax
subl $0x74, %eax
je 0x5fc16
jmp 0x5f80d
movl -0x90(%rbp), %eax
subl $0x76, %eax
je 0x5f87e
jmp 0x5f81a
movl -0x90(%rbp), %eax
subl $0x85, %eax
je 0x5fc94
jmp 0x5f82d
movl -0x90(%rbp), %eax
subl $0x97, %eax
je 0x5f911
jmp 0x5f840
movl -0x90(%rbp), %eax
subl $0x9b, %eax
je 0x5f911
jmp 0x5fcbc
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %r8
movq -0x18(%rbp), %r9
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x603b0
movl %eax, -0x4(%rbp)
jmp 0x5fcfb
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1a, %eax
jne 0x5f8bc
movq $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5f8ec
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x18(%rbp), %r9
callq 0x603b0
movl %eax, -0x4(%rbp)
jmp 0x5fcfb
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x5f932
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x94(%rbp)
jmp 0x5f93c
xorl %eax, %eax
movl %eax, -0x94(%rbp)
jmp 0x5f93c
movl -0x94(%rbp), %eax
movl %eax, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movb 0x71(%rax), %al
movb %al, -0x79(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x50075(%rip), %rdx     # 0xaf9f3
callq 0x60e20
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x92f0
movl %eax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x70(%rbp), %rsi
movl -0x68(%rbp), %edx
movl -0x54(%rbp), %ecx
xorl %r9d, %r9d
movzbl -0x79(%rbp), %r8d
callq 0x18d90
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
jne 0x5fa01
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x70(%rbp), %rsi
movl -0x68(%rbp), %edx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
xorl %r9d, %r9d
movzbl -0x79(%rbp), %r8d
callq 0x18d90
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
jne 0x5f9f8
movl $0x1, -0x58(%rbp)
jmp 0x5f9ff
movl $0x1, -0x5c(%rbp)
jmp 0x5fa15
movq -0x78(%rbp), %rax
cmpq $0x0, 0x18(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x60(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x5fa85
movq -0x28(%rbp), %rdi
movq -0x78(%rbp), %rax
movq 0x30(%rax), %rcx
movl $0x1f, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
callq 0x5e720
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
je 0x5fa83
cmpl $0x1, -0x64(%rbp)
jne 0x5fa70
movq -0x28(%rbp), %rdi
movq -0x78(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0x4ffa1(%rip), %rsi     # 0xaf9fd
movb $0x0, %al
callq 0x136f0
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq -0x18(%rbp), %rax
movb $0x62, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5fcfb
jmp 0x5fa85
cmpl $0x0, -0x60(%rbp)
je 0x5faca
movq -0x20(%rbp), %rax
movzbl 0x30(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x5faca
movq -0x28(%rbp), %rdi
movl -0x68(%rbp), %edx
movq -0x70(%rbp), %rcx
leaq 0x4ff73(%rip), %rsi     # 0xafa20
movb $0x0, %al
callq 0x136f0
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movl $0x0, -0x60(%rbp)
jmp 0x5fb3b
cmpl $0x0, -0x58(%rbp)
je 0x5fb0b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movzbl 0x99(%rax), %eax
cmpl $0x0, %eax
jne 0x5fb0b
movq -0x28(%rbp), %rdi
movl -0x68(%rbp), %edx
movq -0x70(%rbp), %rcx
leaq 0x4ff4f(%rip), %rsi     # 0xafa44
movb $0x0, %al
callq 0x136f0
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x5fb39
cmpl $0x0, -0x5c(%rbp)
je 0x5fb37
movq -0x28(%rbp), %rdi
movl -0x68(%rbp), %edx
movq -0x70(%rbp), %rcx
leaq 0x4ff38(%rip), %rsi     # 0xafa5b
movb $0x0, %al
callq 0x136f0
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x5fb39
jmp 0x5fb3b
cmpl $0x0, -0x60(%rbp)
je 0x5fb4f
movq -0x20(%rbp), %rax
movzbl 0x30(%rax), %ecx
andl $-0x2, %ecx
movb %cl, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x60e60
cmpl $0x0, -0x60(%rbp)
je 0x5fc0a
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movb $-0x67, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x37(%rax)
xorl %eax, %eax
cmpq $0x0, -0x88(%rbp)
movb %al, -0x95(%rbp)
je 0x5fbb4
movq -0x18(%rbp), %rdi
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x60ee0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x95(%rbp)
movb -0x95(%rbp), %al
testb $0x1, %al
jne 0x5fbc0
jmp 0x5fbe1
movq -0x18(%rbp), %rax
movb 0x37(%rax), %cl
addb $0x1, %cl
movb %cl, 0x37(%rax)
movq -0x88(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x88(%rbp)
jmp 0x5fb80
cmpq $0x0, -0x88(%rbp)
je 0x5fbfc
movq -0x88(%rbp), %rax
movzbl 0x30(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x30(%rax)
movq -0x20(%rbp), %rax
movzbl 0x30(%rax), %ecx
orl $0x1, %ecx
movb %cl, 0x30(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5fcfb
jmp 0x5fc18
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x800, %eax            # imm = 0x800
jne 0x5fc92
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x8c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4fe40(%rip), %rdx     # 0xafa88
callq 0x60f60
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4fe2c(%rip), %rdx     # 0xafa88
callq 0x60e20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x60fa0
movl -0x8c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x28(%rcx), %eax
je 0x5fc90
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %ecx
orl $0x20, %ecx
movw %cx, 0x2(%rax)
jmp 0x5fc92
jmp 0x5fcbc
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4fdf0(%rip), %rdx     # 0xafa93
callq 0x60f60
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4fddc(%rip), %rdx     # 0xafa93
callq 0x60e20
movq -0x28(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x50(%rcx)
movb %al, -0x96(%rbp)
jne 0x5fce5
movq -0x28(%rbp), %rax
movq (%rax), %rax
movzbl 0x50(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x96(%rbp)
movb -0x96(%rbp), %dl
xorl %eax, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)