/** \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 16:17:21
 *     -                 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
 * =============================================================================
 */
