static QCString getName(FT_Face face, int nid)
{
FT_SfntName name;
QCString str;
if(lookupName(face, nid, TT_PLATFORM_MICROSOFT, TT_MS_ID_UNICODE_CS, &name) || lookupName(face, nid, TT_PLATFORM_APPLE_UNICODE, -1, &name))
for(unsigned int i = 0; i < name.string_len / 2; i++)
str += 0 == name.string[2 * i] ? name.string[(2 * i) + 1] : '_';
else if(lookupName(face, nid, TT_PLATFORM_MACINTOSH, TT_MAC_ID_ROMAN, &name)) // Pretend that Apple Roman is ISO 8859-1
for(unsigned int i = 0; i < name.string_len; i++)
str += name.string[i];
return str;
}
int printMsg( char *msg )
{
if( video_srv == NULL_TID )
video_srv = lookupName("video", strlen("video"));
return deviceWrite( video_srv, 0, 0, strlen(msg), 1, msg );
}
void sgName(char *database, char *protDb, char *refPsl, char *outAssoc)
/* sgName - builds association table between knownPep and gene common name. */
{
struct sqlConnection *conn = sqlConnect(database);
//struct sqlConnection *conn2 = sqlConnect("swissProt");
char *words[1], **row;
FILE *f = mustOpen(outAssoc, "w");
struct lineFile *pslLf = pslFileOpen(refPsl);
int count = 0, found = 0;
char query[256];
struct psl *psl;
char *swiss = NULL;
while ((psl = pslNext(pslLf)) != NULL)
{
fprintf(f,"%s\t%s\t%s:%d-%d\t",psl->qName, lookupName(conn,psl->qName),
psl->tName, psl->tStart, psl->tEnd);
fprintf(f,"%s\n", swiss = getSwiss(conn, psl->qName));
}
/*
while (lineFileRow(lf, words))
{
fprintf(f,"%s\t%s\n",words[0], lookupName(conn,words[0])); //, getSwiss(conn, words[0]));
}
*/
hFreeConn(&conn);
}
int printChar( char c )
{
if( video_srv == NULL_TID )
video_srv = lookupName("video", strlen("video"));
return deviceWrite( video_srv, 0, 0, 1, 1, &c );
}
LLSpeaker::LLSpeaker(const LLUUID& id, const std::string& name, const ESpeakerType type) :
mStatus(LLSpeaker::STATUS_TEXT_ONLY),
mLastSpokeTime(0.f),
mSpeechVolume(0.f),
mHasSpoken(FALSE),
mDotColor(LLColor4::white),
mID(id),
mTyping(FALSE),
mSortIndex(0),
mType(type),
mIsModerator(FALSE),
mModeratorMutedVoice(FALSE),
mModeratorMutedText(FALSE)
{
if (name.empty() && type == SPEAKER_AGENT)
{
lookupName();
}
else
{
mDisplayName = name;
}
gVoiceClient->setUserVolume(id, LLMuteList::getInstance()->getSavedResidentVolume(id));
mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT);
}
static char *getName(char *in, SYMBOL *sp)
{
if (!sp)
{
strcpy(in, "????");
}
else
{
int i;
char buf[4096], *p;
p = mangleClasses(buf, sp->parentClass);
if (p != buf)
*p++ = '@';
if (sp->templateLevel && sp->templateParams)
{
p = mangleTemplate(p, sp, sp->templateParams);
}
else
{
strcpy(p, sp->name);
}
in = lookupName(in, buf);
}
in += strlen(in);
return in;
}
LLSpeaker::LLSpeaker(const LLUUID& id, const std::string& name, const ESpeakerType type) :
mStatus(LLSpeaker::STATUS_TEXT_ONLY),
mLastSpokeTime(0.f),
mSpeechVolume(0.f),
mHasSpoken(FALSE),
mDotColor(LLColor4::white),
mID(id),
mTyping(FALSE),
mSortIndex(0),
mType(type),
mIsModerator(FALSE),
mModeratorMutedVoice(FALSE),
mModeratorMutedText(FALSE)
{
// Make sure we also get the display name if SLIM or some other external
// voice client is used and not whatever is provided.
if ((name.empty() && type == SPEAKER_AGENT) || type == SPEAKER_EXTERNAL)
{
lookupName();
}
else
{
mDisplayName = name;
mLegacyName = name;
}
gVoiceClient->setUserVolume(id, LLMuteList::getInstance()->getSavedResidentVolume(id));
mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT);
}
int printStrN( char *str, size_t len )
{
if( video_srv == NULL_TID )
video_srv = lookupName("video", strlen("video"));
return deviceWrite( video_srv, 0, 0, len, 1, str );
}
uint8_t CONFcouple::getCouple(char *myname,double *val)
{
int32_t index=lookupName(myname);
assert(index!=-1);
assert(index<(int)nb);
sscanf(value[index],"%lf",val);;
return 1;
}
uint8_t CONFcouple::getCouple(char *myname,char **val)
{
int32_t index=lookupName(myname);
assert(index!=-1);
assert(index<(int)nb);
*val=value[index];
return 1;
}
const char *getName(const char *c)
{
std::string name = lookupName(c);
if (name.empty())
return "Anonymous";
return name.c_str();
}
char kbGetRawChar( void )
{
char kbChar;
if( kb_srv == NULL_TID )
kb_srv = lookupName("keyboard", strlen("keyboard"));
if( _deviceRead( kb_srv, 0, 0, 1, 1, &kbChar ) < 0 )
return '\0';
else
return kbChar;
}
// Spins forever waiting for connections. For each one that comes
// in, create a thread to handle it and go back to waiting for
// connections
DWORD serverListenThread(LPVOID arg) {
SOCKET serverSocket = (SOCKET) arg;
sockaddr_in sinRemote;
int nAddrSize = sizeof(sinRemote);
char host[256];
SOCKET socket;
struct socketDescriptor * serverSd;
struct socketDescriptor sd = DEFAULT_SOCKET_DESCRIPTOR;
sd.description = "client sd";
while (1) {
socket = accept(serverSocket, (sockaddr*)&sinRemote, &nAddrSize);
if (serverListenSd.exit) {
CloseHandle(serverListenSd.hThread);
serverListenSd.hThread=NULL;
printq("serverListenThread thread exit\n");
ExitThread(0);
}
if (socket==INVALID_SOCKET) {
if (WSAGetLastError()==WSAEINTR) {
// WSAEINTR is normal when process ends
CloseHandle(serverListenSd.hThread);
serverListenSd.hThread=NULL;
printq("serverListenThread WSAEINTR thread exit\n");
ExitThread(0);
}
printq("serverListenThread: accept failed from %s:%u errno %u\n",
inet_ntoa(sinRemote.sin_addr),
ntohs(sinRemote.sin_port),
WSAGetLastError());
}
else {
HANDLE hThread;
printq("\rServer accepted connection from %s on socket %d\n",
lookupName(inet_ntoa(sinRemote.sin_addr), host, sizeof(host)),
socket);
sd.port = ntohs(sinRemote.sin_port);
sd.socket = socket;
sd.connected = TRUE;
serverSd = allocateServerSocketDescriptor(&sd);
singleThreadSd = serverSd;
if ( !(serverSd->hThread=CreateThread(0, 0,
(LPTHREAD_START_ROUTINE) &rxServerThread,
(LPVOID) serverSd,
0, NULL)) ) {
printErrorMsg("serverListenThread: create rxServerThread");
}
}
}
}
// establish a client side connection
int establishConnection(struct socketDescriptor * sd) {
// create a stream socket
if (!sd->description) sd->description = "";
sd->socket = socket(AF_INET, SOCK_STREAM, 0);
sockaddr_in sinRemote;
sinRemote.sin_family = AF_INET;
if ((sinRemote.sin_addr.s_addr = lookupAddress(sd->host)) == INADDR_NONE)
return FALSE;
sinRemote.sin_port = htons(sd->port);
char hostname[256];
lookupName(inet_ntoa(sinRemote.sin_addr), hostname, sizeof(hostname));
if (sd->socket==INVALID_SOCKET ||
connect(sd->socket, (sockaddr*)&sinRemote, sizeof(sockaddr_in))==SOCKET_ERROR) {
if (sd->lastError != WSAGetLastError()) {
sd->lastError = WSAGetLastError();
if (sd->lastError == WSAECONNREFUSED)
printq("establishConnection %s: server %s refused connection request\n", szTime(), hostname);
else if (sd->lastError == WSAETIMEDOUT)
printq("establishConnection %s: server %s connection request timed out\n", szTime(), hostname);
else if (!sd->exit)
printErrorMsg("establishConnection");
}
if (sd->socket != INVALID_SOCKET) {
closesocket(sd->socket);
sd->socket = INVALID_SOCKET;
}
sd->connected=FALSE;
return FALSE;
} else {
sd->lastError = NO_ERROR;
}
printq("Client established connection to %s on socket %d\n",
hostname,
sd->socket);
processServerConnect(sd->host);
if (sd->reconnectMsg)
sendMsg(sd, sd->reconnectMsg, sd->debugMsg);
singleThreadSd = sd;
sd->connected=TRUE;
return TRUE;
}
int
QmcContext::lookup(pmID pmid, QString **namePtr, QmcDesc **descPtr, QmcIndom **indomPtr)
{
uint_t indom;
int sts;
if ((sts = lookupName(pmid, namePtr)) < 0)
return sts;
if ((sts = lookupDesc(pmid, descPtr)) < 0)
return sts;
if ((sts = lookupInDom(pmid, indom)) < 0)
return sts;
*indomPtr = (indom == UINT_MAX) ? NULL : my.indoms[indom];
return 0;
}
int main(void)
{
BST* contactBST; //NOT sure if these are right
char userInput;
int inputStatus;
int quitStatus = 0;
contactBST = createBST(compareWord);
readFileBST(contactBST);
while(quitStatus == 0){
inputStatus = 0;
while(inputStatus == 0){ //Looping until choice is entered correctly
fflush(stdin);
printf("\nPlease select: (a) add, (d) delete, (l) lookup, or (q) quit: ");
scanf("%c",&userInput);
if(userInput == 'a' || userInput == 'd' || userInput == 'l' || userInput == 'q'){
inputStatus = 1;
}
}
printf("Choice: %c\n",userInput);
if(userInput == 'q'){ //User Quits
quitStatus = 1;
}
else{
if(userInput == 'a'){
addName(contactBST);
}
else if(userInput == 'd'){
deleteName(contactBST);
}
else if(userInput == 'l'){
lookupName(contactBST);
}
}
}
contactBST = destroyBST(contactBST); //Not working
return 0;
}//end main
void doMiddle()
/* Print middle parts of web page. Get database and transcript
* ID from CGI, and print info about that transcript. */
{
char *transId = cgiString("transId");
char *db = cgiString("db");
struct knownInfo *ki, *kiList = NULL;
struct sqlConnection *conn = sqlConnect(db);
struct sqlResult *sr;
char **row;
char query[256];
/* Get a list of all that have that ID. */
sqlSafef(query, sizeof query, "select * from knownInfo where transId = '%s'", transId);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
ki = knownInfoLoad(row);
slAddHead(&kiList, ki);
}
sqlFreeResult(&sr);
slReverse(&kiList);
/* Print title that says how many match. */
printf("<H2>Transcript %s - %d match</H2>\n", transId, slCount(kiList));
/* Print some info for each match */
for (ki = kiList; ki != NULL; ki = ki->next)
{
printf("<B>geneId</B>: %s<BR>\n", ki->geneId);
printf("<B>geneName</B>: %s<BR>\n",
lookupName(conn, "geneName", ki->geneName));
/* ~~~ Todo: fill in other info. ~~~ */
}
knownInfoFreeList(&kiList);
sqlDisconnect(&conn);
}
LLSpeaker::LLSpeaker(const LLUUID& id, const std::string& name, const ESpeakerType type) :
mStatus(LLSpeaker::STATUS_TEXT_ONLY),
mLastSpokeTime(0.f),
mSpeechVolume(0.f),
mHasSpoken(FALSE),
mHasLeftCurrentCall(FALSE),
mDotColor(LLColor4::white),
mID(id),
mTyping(FALSE),
mSortIndex(0),
mType(type),
mIsModerator(FALSE),
mModeratorMutedVoice(FALSE),
mModeratorMutedText(FALSE)
{
if (name.empty() && type == SPEAKER_AGENT)
{
lookupName();
}
else
{
mDisplayName = name;
}
}
/*
** This routine walks an expression tree and resolves references to
** table columns. Nodes of the form ID.ID or ID resolve into an
** index to the table in the table list and a column offset. The
** Expr.opcode for such nodes is changed to TK_COLUMN. The Expr.iTable
** value is changed to the index of the referenced table in pTabList
** plus the "base" value. The base value will ultimately become the
** VDBE cursor number for a cursor that is pointing into the referenced
** table. The Expr.iColumn value is changed to the index of the column
** of the referenced table. The Expr.iColumn value for the special
** ROWID column is -1. Any INTEGER PRIMARY KEY column is tried as an
** alias for ROWID.
**
** We also check for instances of the IN operator. IN comes in two
** forms:
**
** expr IN (exprlist)
** and
** expr IN (SELECT ...)
**
** The first form is handled by creating a set holding the list
** of allowed values. The second form causes the SELECT to generate
** a temporary table.
**
** This routine also looks for scalar SELECTs that are part of an expression.
** If it finds any, it generates code to write the value of that select
** into a memory cell.
**
** Unknown columns or tables provoke an error. The function returns
** the number of errors seen and leaves an error message on pParse->zErrMsg.
*/
int sqliteExprResolveIds(
Parse *pParse, /* The parser context */
SrcList *pSrcList, /* List of tables used to resolve column names */
ExprList *pEList, /* List of expressions used to resolve "AS" */
Expr *pExpr /* The expression to be analyzed. */
){
int i;
if( pExpr==0 || pSrcList==0 ) return 0;
for(i=0; i<pSrcList->nSrc; i++){
assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab );
}
switch( pExpr->op ){
/* Double-quoted strings (ex: "abc") are used as identifiers if
** possible. Otherwise they remain as strings. Single-quoted
** strings (ex: 'abc') are always string literals.
*/
case TK_STRING: {
if( pExpr->token.z[0]=='\'' ) break;
/* Fall thru into the TK_ID case if this is a double-quoted string */
}
/* A lone identifier is the name of a columnd.
*/
case TK_ID: {
if( lookupName(pParse, 0, 0, &pExpr->token, pSrcList, pEList, pExpr) ){
return 1;
}
break;
}
/* A table name and column name: ID.ID
** Or a database, table and column: ID.ID.ID
*/
case TK_DOT: {
Token *pColumn;
Token *pTable;
Token *pDb;
Expr *pRight;
pRight = pExpr->pRight;
if( pRight->op==TK_ID ){
pDb = 0;
pTable = &pExpr->pLeft->token;
pColumn = &pRight->token;
}else{
assert( pRight->op==TK_DOT );
pDb = &pExpr->pLeft->token;
pTable = &pRight->pLeft->token;
pColumn = &pRight->pRight->token;
}
if( lookupName(pParse, pDb, pTable, pColumn, pSrcList, 0, pExpr) ){
return 1;
}
break;
}
case TK_IN: {
Vdbe *v = sqliteGetVdbe(pParse);
if( v==0 ) return 1;
if( sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){
return 1;
}
if( pExpr->pSelect ){
/* Case 1: expr IN (SELECT ...)
**
** Generate code to write the results of the select into a temporary
** table. The cursor number of the temporary table has already
** been put in iTable by sqliteExprResolveInSelect().
*/
pExpr->iTable = pParse->nTab++;
sqliteVdbeAddOp(v, OP_OpenTemp, pExpr->iTable, 1);
sqliteSelect(pParse, pExpr->pSelect, SRT_Set, pExpr->iTable, 0,0,0);
}else if( pExpr->pList ){
/* Case 2: expr IN (exprlist)
**
** Create a set to put the exprlist values in. The Set id is stored
** in iTable.
*/
int i, iSet;
for(i=0; i<pExpr->pList->nExpr; i++){
Expr *pE2 = pExpr->pList->a[i].pExpr;
if( !sqliteExprIsConstant(pE2) ){
sqliteErrorMsg(pParse,
"right-hand side of IN operator must be constant");
return 1;
}
if( sqliteExprCheck(pParse, pE2, 0, 0) ){
return 1;
}
}
iSet = pExpr->iTable = pParse->nSet++;
for(i=0; i<pExpr->pList->nExpr; i++){
Expr *pE2 = pExpr->pList->a[i].pExpr;
switch( pE2->op ){
case TK_FLOAT:
case TK_INTEGER:
case TK_STRING: {
int addr;
assert( pE2->token.z );
addr = sqliteVdbeOp3(v, OP_SetInsert, iSet, 0,
pE2->token.z, pE2->token.n);
sqliteVdbeDequoteP3(v, addr);
break;
}
default: {
sqliteExprCode(pParse, pE2);
sqliteVdbeAddOp(v, OP_SetInsert, iSet, 0);
break;
}
}
}
}
break;
}
case TK_SELECT: {
/* This has to be a scalar SELECT. Generate code to put the
** value of this select in a memory cell and record the number
** of the memory cell in iColumn.
*/
pExpr->iColumn = pParse->nMem++;
if( sqliteSelect(pParse, pExpr->pSelect, SRT_Mem, pExpr->iColumn,0,0,0) ){
return 1;
}
break;
}
/* For all else, just recursively walk the tree */
default: {
if( pExpr->pLeft
&& sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){
return 1;
}
if( pExpr->pRight
&& sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pRight) ){
return 1;
}
if( pExpr->pList ){
int i;
ExprList *pList = pExpr->pList;
for(i=0; i<pList->nExpr; i++){
Expr *pArg = pList->a[i].pExpr;
if( sqliteExprResolveIds(pParse, pSrcList, pEList, pArg) ){
return 1;
}
}
}
}
}
return 0;
}
/*
** This routine is callback for sqlite3WalkExpr().
**
** Resolve symbolic names into TK_COLUMN operators for the current
** node in the expression tree. Return 0 to continue the search down
** the tree or 2 to abort the tree walk.
**
** This routine also does error checking and name resolution for
** function names. The operator for aggregate functions is changed
** to TK_AGG_FUNCTION.
*/
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 ){
/* A lone identifier is the name of a column.
*/
case TK_ID: {
lookupName(pParse, 0, 0, &pExpr->token, pNC, pExpr);
return WRC_Prune;
}
/* A table name and column name: ID.ID
** Or a database, table and column: ID.ID.ID
*/
case TK_DOT: {
Token *pColumn;
Token *pTable;
Token *pDb;
Expr *pRight;
/* if( pSrcList==0 ) break; */
pRight = pExpr->pRight;
if( pRight->op==TK_ID ){
pDb = 0;
pTable = &pExpr->pLeft->token;
pColumn = &pRight->token;
}else{
assert( pRight->op==TK_DOT );
pDb = &pExpr->pLeft->token;
pTable = &pRight->pLeft->token;
pColumn = &pRight->pRight->token;
}
lookupName(pParse, pDb, pTable, pColumn, pNC, pExpr);
return WRC_Prune;
}
/* Resolve function names
*/
case TK_CONST_FUNC:
case TK_FUNCTION: {
ExprList *pList = pExpr->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 */
int enc = ENC(pParse->db); /* The database encoding */
zId = (char*)pExpr->token.z;
nId = pExpr->token.n;
pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
if( pDef==0 ){
pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, 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->allowAgg ){
sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
pNC->nErr++;
is_agg = 0;
}else if( no_such_func ){
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 ){
pExpr->op = TK_AGG_FUNCTION;
pNC->hasAgg = 1;
}
if( is_agg ) pNC->allowAgg = 0;
sqlite3WalkExprList(pWalker, pList);
if( is_agg ) pNC->allowAgg = 1;
/* 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:
#endif
case TK_IN: {
if( pExpr->pSelect ){
int nRef = pNC->nRef;
#ifndef SQLITE_OMIT_CHECK
if( pNC->isCheck ){
sqlite3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints");
}
#endif
sqlite3WalkSelect(pWalker, pExpr->pSelect);
assert( pNC->nRef>=nRef );
if( nRef!=pNC->nRef ){
ExprSetProperty(pExpr, EP_VarSelect);
}
}
break;
}
#ifndef SQLITE_OMIT_CHECK
case TK_VARIABLE: {
if( pNC->isCheck ){
sqlite3ErrorMsg(pParse,"parameters prohibited in CHECK constraints");
}
break;
}
#endif
}
return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
}
/*
** This routine is callback for sqlite3WalkExpr().
**
** Resolve symbolic names into TK_COLUMN operators for the current
** node in the expression tree. Return 0 to continue the search down
** the tree or 2 to abort the tree walk.
**
** This routine also does error checking and name resolution for
** function names. The operator for aggregate functions is changed
** to TK_AGG_FUNCTION.
*/
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) );
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, -1, 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->allowAgg ){
sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
pNC->nErr++;
is_agg = 0;
}else if( no_such_func ){
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 ){
pExpr->op = TK_AGG_FUNCTION;
pNC->hasAgg = 1;
}
if( is_agg ) pNC->allowAgg = 0;
sqlite3WalkExprList(pWalker, pList);
if( is_agg ) pNC->allowAgg = 1;
/* 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;
#ifndef SQLITE_OMIT_CHECK
if( pNC->isCheck ){
sqlite3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints");
}
#endif
sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
assert( pNC->nRef>=nRef );
if( nRef!=pNC->nRef ){
ExprSetProperty(pExpr, EP_VarSelect);
}
}
break;
}
#ifndef SQLITE_OMIT_CHECK
case TK_VARIABLE: {
if( pNC->isCheck ){
sqlite3ErrorMsg(pParse,"parameters prohibited in CHECK constraints");
}
break;
}
#endif
}
return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
}
static char * mangleExpressionInternal (char *buf, EXPRESSION *exp)
{
while (castvalue(exp))
exp = exp->left;
if (isintconst(exp))
{
if (exp->type == en_const)
{
sprintf(buf, "%lld&", exp->v.sp->value.i);
}
else
{
sprintf(buf, "%lld&", exp->v.i);
}
if (buf[0] == '-')
buf[0] = '_';
}
else
{
BOOLEAN nonpointer = FALSE;
while (lvalue(exp))
{
nonpointer = TRUE;
exp = exp->left;
}
switch (exp->type)
{
case en_nullptr:
*buf++ = 'n';
*buf = 0;
break;
case en_arrayadd:
case en_structadd:
case en_add:
*buf++ = 'p';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_sub:
*buf++ = 's';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_mul:
case en_umul:
case en_arraymul:
*buf++ = 'm';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_umod:
case en_mod:
*buf++ = 'o';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_div:
case en_udiv:
case en_arraydiv:
*buf++ = 'd';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_lsh:
case en_arraylsh:
*buf++ = 'h';
*buf++ = 'l';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_rsh:
case en_ursh:
*buf++ = 'h';
*buf++ = 'r';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_cond:
*buf++ = 'C';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right->left);
buf = mangleExpressionInternal(buf, exp->right->right);
*buf = 0;
break;
case en_assign:
*buf++ = 'a';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_eq:
*buf++ = 'c';
*buf++ = 'e';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_ne:
*buf++ = 'c';
*buf++ = 'n';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_uminus:
*buf++ = 'u';
buf = mangleExpressionInternal(buf, exp->left);
break;
case en_not:
*buf++ = 'l';
*buf++ = 'n';
buf = mangleExpressionInternal(buf, exp->left);
break;
case en_compl:
*buf++ = 'b';
*buf++ = 'n';
buf = mangleExpressionInternal(buf, exp->left);
*buf = 0;
break;
case en_ascompl:
*buf++ = 'a';
*buf++ = 'n';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_ult:
case en_lt:
*buf++ = 'c';
*buf++ = 'l';
*buf++ = 't';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_ule:
case en_le:
*buf++ = 'c';
*buf++ = 'l';
*buf++ = 'e';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_ugt:
case en_gt:
*buf++ = 'c';
*buf++ = 'g';
*buf++ = 't';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_uge:
case en_ge:
*buf++ = 'c';
*buf++ = 'g';
*buf++ = 'e';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_and:
*buf++ = 'b';
*buf++ = 'a';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_land:
*buf++ = 'l';
*buf++ = 'a';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_or:
*buf++ = 'b';
*buf++ = 'o';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_lor:
*buf++ = 'l';
*buf++ = 'o';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_xor:
*buf++ = 'b';
*buf++ = 'x';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_autoinc:
*buf++ = 'i';
*buf++ = 'p';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_autodec:
*buf++ = 'i';
*buf++ = 's';
buf = mangleExpressionInternal(buf, exp->left);
buf = mangleExpressionInternal(buf, exp->right);
*buf = 0;
break;
case en_templateselector:
{
TEMPLATESELECTOR *tsl = exp->v.templateSelector, *find = tsl->next->next;
SYMBOL *ts = tsl->next->sym;
*buf++ = 't';
*buf++ = 's';
if (tsl->next->isTemplate && tsl->next->templateParams) // may be an empty variadic
{
buf = mangleTemplate(buf, ts, tsl->next->templateParams);
}
while (find)
{
*buf++ = 't';
buf = lookupName(buf, find->name);
find = find->next;
}
*buf = 0;
break;
}
case en_templateparam:
*buf++ = 't';
*buf++ = 'p';
buf = lookupName(buf,exp->v.sp->name);
*buf = 0;
break;
case en_funcret:
buf = mangleExpressionInternal(buf, exp->left);
*buf = 0;
break;
case en_func:
if (exp->v.func->ascall)
{
INITLIST *args = exp->v.func->arguments;
*buf++ = 'f';
buf = lookupName(buf, exp->v.func->sp->name);
while(args)
{
*buf++='f';
buf = mangleExpressionInternal(buf, args->exp);
args = args->next;
}
}
else
{
*buf++ = 'e';
*buf++ = '&';
strcpy(buf, exp->v.func->sp->name);
buf += strlen(buf);
*buf++ = '$';
buf = mangleType( buf, exp->v.func->sp->tp, TRUE);
}
break;
case en_pc:
case en_global:
case en_label:
case en_const:
if (isfunction(exp->v.sp->tp))
{
*buf++ = 'e';
*buf++ = '&';
strcpy(buf, exp->v.sp->name);
buf += strlen(buf);
*buf++ = '$';
buf = mangleType( buf, exp->v.sp->tp, TRUE);
}
else
{
*buf++ = 'g';
if (!nonpointer)
*buf++ = '&';
strcpy(buf, exp->v.sp->name);
*buf++ = '$';
*buf = 0;
}
break;
default:
*buf = 0;
break;
}
}
buf += strlen(buf);
return buf;
}
char *mangleType (char *in, TYPE *tp, BOOLEAN first)
{
char nm[4096];
int i;
HASHREC *hr ;
if(!tp)
{
sprintf(in, "%d%s", strlen("initializer-list"), "initializer-list");
in += strlen(in);
}
else if (tp->type == bt_typedef)
{
in = mangleType(in, tp->btp, FALSE);
}
else if (isstructured(tp) && basetype(tp)->sp->templateLevel)
{
{
if (isconst(tp))
*in++ = 'x';
if (isvolatile(tp))
*in++ = 'y';
if (islrqual(tp))
*in++ = 'r';
if (isrrqual(tp))
*in++ = 'R';
}
in = mangleTemplate(in, basetype(tp)->sp, basetype(tp)->sp->templateParams);
}
else
{
// if (ispointer(tp) || isref(tp))
// {
// if (basetype(tp)->btp)
// {
// if (isconst(basetype(tp)->btp))
// *in++ = 'x';
// if (isvolatile(basetype(tp)->btp))
// *in++ = 'y';
// }
// }
// if (isfunction(tp))
{
if (isconst(tp))
*in++ = 'x';
if (isvolatile(tp))
*in++ = 'y';
if (islrqual(tp))
*in++ = 'r';
if (isrrqual(tp))
*in++ = 'R';
}
tp = basetype(tp);
switch (tp->type)
{
/*
case bt_templateplaceholder:
tplPlaceholder(nm, tp->lst.head->name, tp->lst.tail);
sprintf(buf, "%d%s", strlen(nm), nm);
buf += strlen(buf);
break;
*/
case bt_func:
case bt_ifunc:
if (basetype(tp)->sp && basetype(tp)->sp->parentClass && !first)
{
*in++ = 'M';
in = getName(in, tp->sp->parentClass);
in += strlen(in);
}
*in++ = 'q';
hr = tp->syms->table[0];
while (hr)
{
SYMBOL *sp = (SYMBOL *)hr->p;
if (!sp->thisPtr)
in = mangleType(in, sp->tp, TRUE);
hr = hr->next ;
}
*in++ = '$';
// return value
in = mangleType(in, tp->btp, TRUE);
break;
case bt_memberptr:
*in++ = 'M';
in = getName(in, tp->sp);
if (isfunction(tp->btp))
{
*in++ = 'q';
hr = basetype(tp->btp)->syms->table[0];
while (hr)
{
SYMBOL *sp = (SYMBOL *)hr->p;
if (!sp->thisPtr)
in = mangleType(in, sp->tp, TRUE);
hr = hr->next ;
}
*in++ = '$';
in = mangleType (in, tp->btp->btp, TRUE);
}
else
{
*in++ = '$';
in = mangleType (in, basetype(tp)->btp, TRUE);
}
break;
case bt_enum:
case bt_struct:
case bt_union:
case bt_class:
in = getName(in, tp->sp);
break;
case bt_bool:
in = lookupName(in, "bool");
in += strlen(in);
break;
case bt_unsigned_short:
*in++ = 'u';
case bt_short:
*in++ = 's';
break;
case bt_unsigned:
*in++ = 'u';
case bt_int:
*in++ = 'i';
break;
case bt_char16_t:
*in++ = 'h';
break;
case bt_char32_t:
*in++ = 'H';
break;
case bt_unsigned_long:
*in++ = 'u';
case bt_long:
*in++ = 'l';
break;
case bt_unsigned_long_long:
*in++ = 'u';
case bt_long_long:
*in++ = 'L';
break;
case bt_unsigned_char:
*in++ = 'u';
case bt_char:
*in++ = 'c';
break;
case bt_signed_char:
*in++ = 'S';
*in++ = 'c';
break;
case bt_wchar_t:
*in++ = 'C';
break;
case bt_float_complex:
*in++ = 'F';
break;
case bt_double_complex:
*in++ = 'D';
break;
case bt_long_double_complex:
*in++ = 'G';
break;
case bt_float:
*in++ = 'f';
break;
case bt_double:
*in++ = 'd';
break;
case bt_long_double:
*in++ = 'g';
break;
case bt_pointer:
if (tp->nullptrType)
{
in = lookupName(in, "nullptr_t");
in += strlen(in);
}
else
{
if (first|| !tp->array)
{
*in++ = 'p';
}
else
{
sprintf(in,"A%ld",tp->btp->size ? tp->size / tp->btp->size : 0);
in += strlen(in);
}
in = mangleType(in, tp->btp, FALSE);
}
break;
case bt_far:
*in++ = 'P';
in = mangleType(in, tp->btp, FALSE);
break;
case bt_lref:
*in++ = 'r';
in = mangleType(in, tp->btp, FALSE);
break;
case bt_rref:
*in++ = 'R';
in = mangleType(in, tp->btp, FALSE);
break;
case bt_ellipse:
*in++ = 'e';
break;
case bt_void:
case bt_any:
*in++ = 'v';
break;
case bt_templateparam:
in = getName(in, tp->templateParam->p->sym);
break;
case bt_templateselector:
{
TEMPLATESELECTOR *s = tp->sp->templateSelector;
char *p;
s = s->next;
if (s->isTemplate)
p = mangleTemplate(nm, s->sym, s->templateParams);
else
p = getName(nm, s->sym);
p[0] =0;
if (strlen(nm) > sizeof(nm))
p = mangleTemplate(nm, s->sym, s->templateParams);
s = s->next ;
while (s)
{
strcat(nm , "@");
strcat(nm , s->name);
s= s->next;
}
p = nm;
while (isdigit(*p))
p++;
sprintf(in, "%d%s", strlen(p), p);
in += strlen(in);
}
break;
case bt_templatedecltype:
// the index is being used to make names unique so two decltypes won't collide when storing them
// in a symbol table...
declTypeIndex = (declTypeIndex + 1) %1000;
*in++ = 'E';
sprintf(in, "%03d", declTypeIndex);
in += 3;
break;
case bt_aggregate:
in = getName(in, tp->sp);
break;
default:
diag("mangleType: unknown type");
break;
}
}
*in= 0;
return in;
}
/*
* Send to an instance of Vim via the X display.
* Returns 0 for OK, negative for an error.
*/
int serverSendToVim(VimRemotingClient *client, const char *name, const char *cmd, apr_size_t cmd_len, char **result)
{
Window w;
char *property;
int length;
int res;
int n;
VimRemotingClient_PendingCommand pending;
if (result != NULL)
*result = NULL;
prologue(client);
/*
* Bind the server name to a communication window.
*
* Find any survivor with a serialno attached to the name if the
* original registrant of the wanted name is no longer present.
*
* Delete any lingering names from dead editors.
*/
do {
w = lookupName(client, name);
/* Check that the window is hot */
} while (w != None && !isWindowValid(client, w));
if (w == None) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, client->server_rec, "Failed to connect the server %s", name);
epilogue(client);
return -1;
}
/*
* Send the command to target interpreter by appending it to the
* comm window in the communication window.
* Length must be computed exactly!
*/
#ifdef FEAT_MBYTE
length = strlen(name) + strlen(p_enc) + cmd_len + 14;
#else
length = strlen(name) + cmd_len + 10;
#endif
property = (char *)malloc((unsigned)length + 30);
#ifdef FEAT_MBYTE
n = sprintf((char *)property, "%c%c%c-n %s%c-E %s%c-s ",
0, result ? 'c' : 'k', 0, name, 0, p_enc, 0);
#else
n = sprintf((char *)property, "%c%c%c-n %s%c-s ",
0, result ? 'c' : 'k', 0, name, 0);
#endif
{
memcpy(property + n, cmd, cmd_len);
property[n + cmd_len] = '\0';
}
/* Add a back reference to our comm window */
client->serial++;
sprintf((char *)property + length, "%c-r %x %d",
0, (unsigned int)client->window, client->serial);
/* Add length of what "-r %x %d" resulted in, skipping the NUL. */
length += strlen(property + length + 1) + 1;
res = appendPropCarefully(client, w, client->commProperty, property, length + 1);
free(property);
if (res < 0) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, client->server_rec, "Failed to send command to the destination program");
epilogue(client);
return -1;
}
if (!result) {
/* There is no answer for this - Keys are sent async */
epilogue(client);
return client->got_x_error;
}
/*
* Register the fact that we're waiting for a command to
* complete (this is needed by SendEventProc and by
* AppendErrorProc to pass back the command's results).
*/
pending.serial = client->serial;
pending.code = 0;
pending.result = NULL;
pending.nextPtr = client->pendingCommands;
client->pendingCommands = &pending;
serverWait(client, w, waitForPend, &pending, 600);
/*
* Unregister the information about the pending command
* and return the result.
*/
if (client->pendingCommands == &pending) {
client->pendingCommands = pending.nextPtr;
} else {
VimRemotingClient_PendingCommand *pcPtr;
for (pcPtr = client->pendingCommands; pcPtr; pcPtr = pcPtr->nextPtr) {
if (pcPtr->nextPtr == &pending) {
pcPtr->nextPtr = pending.nextPtr;
break;
}
}
}
if (result)
*result = pending.result;
else
free(pending.result);
epilogue(client);
return pending.code == 0 ? 0 : -1;
}
/*
** This routine is callback for sqlite3WalkExpr().
**
** Resolve symbolic names into TK_COLUMN operators for the current
** node in the expression tree. Return 0 to continue the search down
** the tree or 2 to abort the tree walk.
**
** This routine also does error checking and name resolution for
** function names. The operator for aggregate functions is changed
** to TK_AGG_FUNCTION.
*/
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( ExprHasProperty(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_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 */
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;
if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
ExprSetProperty(pExpr, EP_Unlikely|EP_Skip);
if( n==2 ){
pExpr->iTable = exprProbability(pList->a[1].pExpr);
if( pExpr->iTable<0 ){
sqlite3ErrorMsg(pParse, "second argument to likelihood() must be a "
"constant between 0.0 and 1.0");
pNC->nErr++;
}
}else{
/* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is equivalent to
** likelihood(X, 0.0625).
** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is short-hand for
** likelihood(X,0.0625). */
pExpr->iTable = 62; /* TUNING: Default 2nd arg to unlikely() is 0.0625 */
}
}
}
#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;
}
if( pDef->funcFlags & SQLITE_FUNC_CONSTANT ) ExprSetProperty(pExpr,EP_Constant);
}
#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;
}
