/** \file * This C source file was generated by $ANTLR version 3.2 debian-5 * * - From the grammar source file : DAAP.g * - On : 2011-09-11 15:48:50 * - for the lexer : DAAPLexerLexer * * Editing it, at least manually, is not wise. * * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws. * * */ // [The "BSD licence"] // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC // http://www.temporal-wave.com // http://www.linkedin.com/in/jimidle // // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions // are met: // 1. Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // 2. Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // 3. The name of the author may not be used to endorse or promote products // derived from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /* ----------------------------------------- * Include the ANTLR3 generated header file. */ #include "DAAPLexer.h" /* ----------------------------------------- */ /* MACROS that hide the C interface implementations from the * generated code, which makes it a little more understandable to the human eye. * I am very much against using C pre-processor macros for function calls and bits * of code as you cannot see what is happening when single stepping in debuggers * and so on. The exception (in my book at least) is for generated code, where you are * not maintaining it, but may wish to read and understand it. If you single step it, you know that input() * hides some indirect calls, but is always referring to the input stream. This is * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig * the runtime interfaces without changing the generated code too often, without * confusing the reader of the generated output, who may not wish to know the gory * details of the interface inheritance. */ #define CTX ctx /* Aids in accessing scopes for grammar programmers */ #undef SCOPE_TYPE #undef SCOPE_STACK #undef SCOPE_TOP #define SCOPE_TYPE(scope) pDAAPLexer_##scope##_SCOPE #define SCOPE_STACK(scope) pDAAPLexer_##scope##Stack #define SCOPE_TOP(scope) ctx->pDAAPLexer_##scope##Top #define SCOPE_SIZE(scope) ctx->pDAAPLexer_##scope##Stack_limit #define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i)) /* Macros for accessing things in a lexer */ #undef LEXER #undef RECOGNIZER #undef RULEMEMO #undef GETCHARINDEX #undef GETLINE #undef GETCHARPOSITIONINLINE #undef EMIT #undef EMITNEW #undef MATCHC #undef MATCHS #undef MATCHRANGE #undef LTOKEN #undef HASFAILED #undef FAILEDFLAG #undef INPUT #undef STRSTREAM #undef LA #undef HASEXCEPTION #undef EXCEPTION #undef CONSTRUCTEX #undef CONSUME #undef LRECOVER #undef MARK #undef REWIND #undef REWINDLAST #undef BACKTRACKING #undef MATCHANY #undef MEMOIZE #undef HAVEPARSEDRULE #undef GETTEXT #undef INDEX #undef SEEK #undef PUSHSTREAM #undef POPSTREAM #undef SETTEXT #undef SETTEXT8 #define LEXER ctx->pLexer #define RECOGNIZER LEXER->rec #define LEXSTATE RECOGNIZER->state #define TOKSOURCE LEXSTATE->tokSource #define GETCHARINDEX() LEXER->getCharIndex(LEXER) #define GETLINE() LEXER->getLine(LEXER) #define GETTEXT() LEXER->getText(LEXER) #define GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER) #define EMIT() LEXSTATE->type = _type; LEXER->emit(LEXER) #define EMITNEW(t) LEXER->emitNew(LEXER, t) #define MATCHC(c) LEXER->matchc(LEXER, c) #define MATCHS(s) LEXER->matchs(LEXER, s) #define MATCHRANGE(c1,c2) LEXER->matchRange(LEXER, c1, c2) #define MATCHANY() LEXER->matchAny(LEXER) #define LTOKEN LEXSTATE->token #define HASFAILED() (LEXSTATE->failed == ANTLR3_TRUE) #define BACKTRACKING LEXSTATE->backtracking #define FAILEDFLAG LEXSTATE->failed #define INPUT LEXER->input #define STRSTREAM INPUT #define ISTREAM INPUT->istream #define INDEX() ISTREAM->index(ISTREAM) #define SEEK(n) ISTREAM->seek(ISTREAM, n) #define EOF_TOKEN &(LEXSTATE->tokSource->eofToken) #define HASEXCEPTION() (LEXSTATE->error == ANTLR3_TRUE) #define EXCEPTION LEXSTATE->exception #define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER) #define LRECOVER() LEXER->recover(LEXER) #define MARK() ISTREAM->mark(ISTREAM) #define REWIND(m) ISTREAM->rewind(ISTREAM, m) #define REWINDLAST() ISTREAM->rewindLast(ISTREAM) #define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si) #define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r) #define PUSHSTREAM(str) LEXER->pushCharStream(LEXER, str) #define POPSTREAM() LEXER->popCharStream(LEXER) #define SETTEXT(str) LEXSTATE->text = str #define SKIP() LEXSTATE->token = &(TOKSOURCE->skipToken) #define USER1 LEXSTATE->user1 #define USER2 LEXSTATE->user2 #define USER3 LEXSTATE->user3 #define CUSTOM LEXSTATE->custom #define RULEMEMO LEXSTATE->ruleMemo #define DBG RECOGNIZER->debugger /* If we have been told we can rely on the standard 8 bit or 16 bit input * stream, then we can define our macros to use the direct pointers * in the input object, which is much faster than indirect calls. This * is really only significant to lexers with a lot of fragment rules (which * do not place LA(1) in a temporary at the moment) and even then * only if there is a lot of input (order of say 1M or so). */ #if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16) # ifdef ANTLR3_INLINE_INPUT_ASCII /* 8 bit "ASCII" (actually any 8 bit character set) */ # define NEXTCHAR ((pANTLR3_UINT8)(INPUT->nextChar)) # define DATAP ((pANTLR3_UINT8)(INPUT->data)) # else # define NEXTCHAR ((pANTLR3_UINT16)(INPUT->nextChar)) # define DATAP ((pANTLR3_UINT16)(INPUT->data)) # endif # define LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1))) # define CONSUME() \ { \ if (NEXTCHAR < (DATAP + INPUT->sizeBuf)) \ { \ INPUT->charPositionInLine++; \ if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar) \ { \ INPUT->line++; \ INPUT->charPositionInLine = 0; \ INPUT->currentLine = (void *)(NEXTCHAR + 1); \ } \ INPUT->nextChar = (void *)(NEXTCHAR + 1); \ } \ } #else // Pick up the input character by calling the input stream implementation. // #define CONSUME() INPUT->istream->consume(INPUT->istream) #define LA(n) INPUT->istream->_LA(INPUT->istream, n) #endif #define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt /* The 4 tokens defined below may well clash with your own #defines or token types. If so * then for the present you must use different names for your defines as these are hard coded * in the code generator. It would be better not to use such names internally, and maybe * we can change this in a forthcoming release. I deliberately do not #undef these * here as this will at least give you a redefined error somewhere if they clash. */ #define UP ANTLR3_TOKEN_UP #define DOWN ANTLR3_TOKEN_DOWN #define EOR ANTLR3_TOKEN_EOR #define INVALID ANTLR3_TOKEN_INVALID /* ============================================================================= * Functions to create and destroy scopes. First come the rule scopes, followed * by the global declared scopes. */ /* ============================================================================= */ /* ============================================================================= * Start of recognizer */ /* Forward declare the locally static matching functions we have generated and any predicate functions. */ static ANTLR3_INLINE void mQUOTE (pDAAPLexer ctx); static ANTLR3_INLINE void mLPAR (pDAAPLexer ctx); static ANTLR3_INLINE void mRPAR (pDAAPLexer ctx); static ANTLR3_INLINE void mOPAND (pDAAPLexer ctx); static ANTLR3_INLINE void mOPOR (pDAAPLexer ctx); static ANTLR3_INLINE void mNEWLINE (pDAAPLexer ctx); static ANTLR3_INLINE void mSTR (pDAAPLexer ctx); static ANTLR3_INLINE void mESCAPED (pDAAPLexer ctx); static ANTLR3_INLINE void mTokens (pDAAPLexer ctx); static void DAAPLexerFree(pDAAPLexer ctx); /* ========================================================================= * Lexer matching rules end. * ========================================================================= */ static void DAAPLexerFree (pDAAPLexer ctx) { LEXER->free(LEXER); ANTLR3_FREE(ctx); } /** \brief Name of the grammar file that generated this code */ static const char fileName[] = "DAAP.g"; /** \brief Return the name of the grammar file that generated this code. */ static const char * getGrammarFileName() { return fileName; } /** \brief Create a new lexer called DAAPLexer * * \param[in] instream Pointer to an initialized input stream * \return * - Success pDAAPLexer initialized for the lex start * - Fail NULL */ ANTLR3_API pDAAPLexer DAAPLexerNew (pANTLR3_INPUT_STREAM instream) { // See if we can create a new lexer with the standard constructor // return DAAPLexerNewSSD(instream, NULL); } /** \brief Create a new lexer called DAAPLexer * * \param[in] instream Pointer to an initialized input stream * \param[state] state Previously created shared recognizer stat * \return * - Success pDAAPLexer initialized for the lex start * - Fail NULL */ ANTLR3_API pDAAPLexer DAAPLexerNewSSD (pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state) { pDAAPLexer ctx; // Context structure we will build and return ctx = (pDAAPLexer) ANTLR3_CALLOC(1, sizeof(DAAPLexer)); if (ctx == NULL) { // Failed to allocate memory for lexer context return NULL; } /* ------------------------------------------------------------------- * Memory for basic structure is allocated, now to fill in * in base ANTLR3 structures. We initialize the function pointers * for the standard ANTLR3 lexer function set, but upon return * from here, the programmer may set the pointers to provide custom * implementations of each function. * * We don't use the macros defined in DAAPLexer.h here so you can get a sense * of what goes where. */ /* Create a base lexer, using the supplied input stream */ ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state); /* Check that we allocated the memory correctly */ if (ctx->pLexer == NULL) { ANTLR3_FREE(ctx); return NULL; } /* Install the implementation of our DAAPLexer interface */ ctx->mQUOTE = mQUOTE; ctx->mLPAR = mLPAR; ctx->mRPAR = mRPAR; ctx->mOPAND = mOPAND; ctx->mOPOR = mOPOR; ctx->mNEWLINE = mNEWLINE; ctx->mSTR = mSTR; ctx->mESCAPED = mESCAPED; ctx->mTokens = mTokens; /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE * it will call mTokens() in this generated code, and will pass it the ctx * pointer of this lexer, not the context of the base lexer, so store that now. */ ctx->pLexer->ctx = ctx; /**Install the token matching function */ ctx->pLexer->mTokens = (void (*) (void *))(mTokens); ctx->getGrammarFileName = getGrammarFileName; ctx->free = DAAPLexerFree; /* Return the newly built lexer to the caller */ return ctx; } /* ========================================================================= * Functions to match the lexer grammar defined tokens from the input stream */ // Comes from: 40:7: ( '\\'' ) /** \brief Lexer rule generated by ANTLR3 * * $ANTLR start QUOTE * * Looks to match the characters the constitute the token QUOTE * from the attached input stream. * * * \remark * - lexer->error == ANTLR3_TRUE if an exception was thrown. */ static ANTLR3_INLINE void mQUOTE(pDAAPLexer ctx) { ANTLR3_UINT32 _type; _type = QUOTE; // DAAP.g:40:7: ( '\\'' ) // DAAP.g:40:9: '\\'' { MATCHC('\''); if (HASEXCEPTION()) { goto ruleQUOTEEx; } } LEXSTATE->type = _type; // This is where rules clean up and exit // goto ruleQUOTEEx; /* Prevent compiler warnings */ ruleQUOTEEx: ; } // $ANTLR end QUOTE // Comes from: 41:6: ( '(' ) /** \brief Lexer rule generated by ANTLR3 * * $ANTLR start LPAR * * Looks to match the characters the constitute the token LPAR * from the attached input stream. * * * \remark * - lexer->error == ANTLR3_TRUE if an exception was thrown. */ static ANTLR3_INLINE void mLPAR(pDAAPLexer ctx) { ANTLR3_UINT32 _type; _type = LPAR; // DAAP.g:41:6: ( '(' ) // DAAP.g:41:8: '(' { MATCHC('('); if (HASEXCEPTION()) { goto ruleLPAREx; } } LEXSTATE->type = _type; // This is where rules clean up and exit // goto ruleLPAREx; /* Prevent compiler warnings */ ruleLPAREx: ; } // $ANTLR end LPAR // Comes from: 42:6: ( ')' ) /** \brief Lexer rule generated by ANTLR3 * * $ANTLR start RPAR * * Looks to match the characters the constitute the token RPAR * from the attached input stream. * * * \remark * - lexer->error == ANTLR3_TRUE if an exception was thrown. */ static ANTLR3_INLINE void mRPAR(pDAAPLexer ctx) { ANTLR3_UINT32 _type; _type = RPAR; // DAAP.g:42:6: ( ')' ) // DAAP.g:42:8: ')' { MATCHC(')'); if (HASEXCEPTION()) { goto ruleRPAREx; } } LEXSTATE->type = _type; // This is where rules clean up and exit // goto ruleRPAREx; /* Prevent compiler warnings */ ruleRPAREx: ; } // $ANTLR end RPAR // Comes from: 44:7: ( '+' ) /** \brief Lexer rule generated by ANTLR3 * * $ANTLR start OPAND * * Looks to match the characters the constitute the token OPAND * from the attached input stream. * * * \remark * - lexer->error == ANTLR3_TRUE if an exception was thrown. */ static ANTLR3_INLINE void mOPAND(pDAAPLexer ctx) { ANTLR3_UINT32 _type; _type = OPAND; // DAAP.g:44:7: ( '+' ) // DAAP.g:44:9: '+' { MATCHC('+'); if (HASEXCEPTION()) { goto ruleOPANDEx; } } LEXSTATE->type = _type; // This is where rules clean up and exit // goto ruleOPANDEx; /* Prevent compiler warnings */ ruleOPANDEx: ; } // $ANTLR end OPAND // Comes from: 45:6: ( ',' ) /** \brief Lexer rule generated by ANTLR3 * * $ANTLR start OPOR * * Looks to match the characters the constitute the token OPOR * from the attached input stream. * * * \remark * - lexer->error == ANTLR3_TRUE if an exception was thrown. */ static ANTLR3_INLINE void mOPOR(pDAAPLexer ctx) { ANTLR3_UINT32 _type; _type = OPOR; // DAAP.g:45:6: ( ',' ) // DAAP.g:45:8: ',' { MATCHC(','); if (HASEXCEPTION()) { goto ruleOPOREx; } } LEXSTATE->type = _type; // This is where rules clean up and exit // goto ruleOPOREx; /* Prevent compiler warnings */ ruleOPOREx: ; } // $ANTLR end OPOR // Comes from: 47:9: ( ( '\\r' )? '\\n' ) /** \brief Lexer rule generated by ANTLR3 * * $ANTLR start NEWLINE * * Looks to match the characters the constitute the token NEWLINE * from the attached input stream. * * * \remark * - lexer->error == ANTLR3_TRUE if an exception was thrown. */ static ANTLR3_INLINE void mNEWLINE(pDAAPLexer ctx) { ANTLR3_UINT32 _type; _type = NEWLINE; // DAAP.g:47:9: ( ( '\\r' )? '\\n' ) // DAAP.g:47:11: ( '\\r' )? '\\n' { // DAAP.g:47:11: ( '\\r' )? { int alt1=2; switch ( LA(1) ) { case '\r': { alt1=1; } break; } switch (alt1) { case 1: // DAAP.g:47:11: '\\r' { MATCHC('\r'); if (HASEXCEPTION()) { goto ruleNEWLINEEx; } } break; } } MATCHC('\n'); if (HASEXCEPTION()) { goto ruleNEWLINEEx; } } LEXSTATE->type = _type; // This is where rules clean up and exit // goto ruleNEWLINEEx; /* Prevent compiler warnings */ ruleNEWLINEEx: ; } // $ANTLR end NEWLINE // Comes from: 55:2: ( QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE ) /** \brief Lexer rule generated by ANTLR3 * * $ANTLR start STR * * Looks to match the characters the constitute the token STR * from the attached input stream. * * * \remark * - lexer->error == ANTLR3_TRUE if an exception was thrown. */ static ANTLR3_INLINE void mSTR(pDAAPLexer ctx) { ANTLR3_UINT32 _type; pANTLR3_COMMON_TOKEN esc; ANTLR3_UINT32 reg; esc = NULL; _type = STR; pANTLR3_STRING unesc = GETTEXT()->factory->newRaw(GETTEXT()->factory); // DAAP.g:55:2: ( QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE ) // DAAP.g:55:4: QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE { /* 55:4: QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE */ mQUOTE(ctx ); if (HASEXCEPTION()) { goto ruleSTREx; } // DAAP.g:55:10: (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ { int cnt2=0; for (;;) { int alt2=3; { /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) */ int LA2_0 = LA(1); if ( (((LA2_0 >= 0x0000) && (LA2_0 <= '&')) || ((LA2_0 >= '(') && (LA2_0 <= '[')) || ((LA2_0 >= ']') && (LA2_0 <= 0xFFFF))) ) { alt2=1; } else if ( (LA2_0 == '\\') ) { alt2=2; } } switch (alt2) { case 1: // DAAP.g:55:12: reg=~ ( '\\\\' | '\\'' ) { reg= LA(1); if ( ((LA(1) >= 0x0000) && (LA(1) <= '&')) || ((LA(1) >= '(') && (LA(1) <= '[')) || ((LA(1) >= ']') && (LA(1) <= 0xFFFF)) ) { CONSUME(); } else { CONSTRUCTEX(); EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; LRECOVER(); goto ruleSTREx; } { unesc->addc(unesc, reg); } } break; case 2: // DAAP.g:56:6: esc= ESCAPED { /* 56:6: esc= ESCAPED */ { ANTLR3_MARKER escStart114 = GETCHARINDEX(); mESCAPED(ctx ); if (HASEXCEPTION()) { goto ruleSTREx; } esc = LEXSTATE->tokFactory->newToken(LEXSTATE->tokFactory); esc->setType(esc, ANTLR3_TOKEN_INVALID); esc->setStartIndex(esc, escStart114); esc->setStopIndex(esc, GETCHARINDEX()-1); esc->input = INPUT; } { unesc->appendS(unesc, GETTEXT()); } } break; default: if ( cnt2 >= 1 ) { goto loop2; } /* mismatchedSetEx() */ CONSTRUCTEX(); EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; goto ruleSTREx; } cnt2++; } loop2: ; /* Jump to here if this rule does not match */ } /* 55:4: QUOTE (reg=~ ( '\\\\' | '\\'' ) | esc= ESCAPED )+ QUOTE */ mQUOTE(ctx ); if (HASEXCEPTION()) { goto ruleSTREx; } { SETTEXT(unesc); } } LEXSTATE->type = _type; // This is where rules clean up and exit // goto ruleSTREx; /* Prevent compiler warnings */ ruleSTREx: ; esc = NULL; } // $ANTLR end STR // Comes from: 59:9: ( '\\\\' ( '\\\\' | '\\'' ) ) /** \brief Lexer rule generated by ANTLR3 * * $ANTLR start ESCAPED * * Looks to match the characters the constitute the token ESCAPED * from the attached input stream. * * * \remark * - lexer->error == ANTLR3_TRUE if an exception was thrown. */ static ANTLR3_INLINE void mESCAPED(pDAAPLexer ctx) { ANTLR3_UINT32 _type; // DAAP.g:59:9: ( '\\\\' ( '\\\\' | '\\'' ) ) // DAAP.g:59:11: '\\\\' ( '\\\\' | '\\'' ) { MATCHC('\\'); if (HASEXCEPTION()) { goto ruleESCAPEDEx; } // DAAP.g:60:3: ( '\\\\' | '\\'' ) { int alt3=2; switch ( LA(1) ) { case '\\': { alt3=1; } break; case '\'': { alt3=2; } break; default: CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 3; EXCEPTION->state = 0; goto ruleESCAPEDEx; } switch (alt3) { case 1: // DAAP.g:60:5: '\\\\' { MATCHC('\\'); if (HASEXCEPTION()) { goto ruleESCAPEDEx; } { SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\\")); } } break; case 2: // DAAP.g:61:5: '\\'' { MATCHC('\''); if (HASEXCEPTION()) { goto ruleESCAPEDEx; } { SETTEXT(GETTEXT()->factory->newStr8(GETTEXT()->factory, (pANTLR3_UINT8)"\'")); } } break; } } } // This is where rules clean up and exit // goto ruleESCAPEDEx; /* Prevent compiler warnings */ ruleESCAPEDEx: ; } // $ANTLR end ESCAPED /** This is the entry point in to the lexer from an object that * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM */ static void mTokens(pDAAPLexer ctx) { { // DAAP.g:1:8: ( QUOTE | LPAR | RPAR | OPAND | OPOR | NEWLINE | STR ) ANTLR3_UINT32 alt4; alt4=7; switch ( LA(1) ) { case '\'': { { int LA4_1 = LA(2); if ( (((LA4_1 >= 0x0000) && (LA4_1 <= '&')) || ((LA4_1 >= '(') && (LA4_1 <= 0xFFFF))) ) { alt4=7; } else { alt4=1; } } } break; case '(': { alt4=2; } break; case ')': { alt4=3; } break; case '+': { alt4=4; } break; case ',': { alt4=5; } break; case '\n': case '\r': { alt4=6; } break; default: CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 4; EXCEPTION->state = 0; goto ruleTokensEx; } switch (alt4) { case 1: // DAAP.g:1:10: QUOTE { /* 1:10: QUOTE */ mQUOTE(ctx ); if (HASEXCEPTION()) { goto ruleTokensEx; } } break; case 2: // DAAP.g:1:16: LPAR { /* 1:16: LPAR */ mLPAR(ctx ); if (HASEXCEPTION()) { goto ruleTokensEx; } } break; case 3: // DAAP.g:1:21: RPAR { /* 1:21: RPAR */ mRPAR(ctx ); if (HASEXCEPTION()) { goto ruleTokensEx; } } break; case 4: // DAAP.g:1:26: OPAND { /* 1:26: OPAND */ mOPAND(ctx ); if (HASEXCEPTION()) { goto ruleTokensEx; } } break; case 5: // DAAP.g:1:32: OPOR { /* 1:32: OPOR */ mOPOR(ctx ); if (HASEXCEPTION()) { goto ruleTokensEx; } } break; case 6: // DAAP.g:1:37: NEWLINE { /* 1:37: NEWLINE */ mNEWLINE(ctx ); if (HASEXCEPTION()) { goto ruleTokensEx; } } break; case 7: // DAAP.g:1:45: STR { /* 1:45: STR */ mSTR(ctx ); if (HASEXCEPTION()) { goto ruleTokensEx; } } break; } } goto ruleTokensEx; /* Prevent compiler warnings */ ruleTokensEx: ; } /* ========================================================================= * Lexer matching rules end. * ========================================================================= */ /* End of Lexer code * ================================================ * ================================================ */ /* End of code * ============================================================================= */