windows-nt/Source/XPSP1/NT/multimedia/opengl/gls/lib/readtxt.c

/*
** Copyright 1995-2095, Silicon Graphics, Inc.
** All Rights Reserved.
** 
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
** the contents of this file may not be disclosed to third parties, copied or
** duplicated in any form, in whole or in part, without the prior written
** permission of Silicon Graphics, Inc.
** 
** RESTRICTED RIGHTS LEGEND:
** Use, duplication or disclosure by the Government is subject to restrictions
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
** rights reserved under the Copyright Laws of the United States.
*/

#include "glslib.h"
#include <ctype.h>
#include <errno.h>
#include <float.h>
#include <limits.h>
#include <locale.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

/******************************************************************************
Helpers
******************************************************************************/

#define __GLS_BEGIN_PARAM(inoutReader) \
    if ( \
        inoutReader->error || \
        inoutReader->paramCount++ && \
        !__glsReader_getChar_text(inoutReader, ',', GL_TRUE) \
    ) { \
        return GL_FALSE; \
    }

#define __GLS_GET_TEXT(inType, inBase) \
    __GLS_GET_TEXT_VAL(inType, inBase) \
    __GLS_GET_TEXT_VEC(inType, inBase)

#define __GLS_GET_TEXT_VAL(inType, inBase) \
GLboolean __glsReader_get##inType##_text( \
    __GLSreader *inoutReader, inType *outVal \
) { \
    __GLSstring token; \
    __glsString_init(&token); \
    __GLS_BEGIN_PARAM(inoutReader); \
    if ( \
        __glsReader_getToken_text(inoutReader, &token) && \
        __glsTokenTo##inBase(token.head, outVal) \
    ) { \
        __glsString_final(&token); \
        return GL_TRUE; \
    } else { \
        __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR); \
        __glsString_final(&token); \
        return GL_FALSE; \
    } \
}

#define __GLS_GET_TEXT_VEC(inType, inBase) \
GLboolean __glsReader_get##inType##v_text( \
    __GLSreader *inoutReader, GLuint inCount, inType *outVec \
) { \
    __GLSstring token; \
    __GLS_BEGIN_PARAM(inoutReader); \
    if (!__glsReader_getChar_text(inoutReader, '{', GL_TRUE)) { \
        return GL_FALSE; \
    } \
    __glsString_init(&token); \
    while (inCount-- > 0) if ( \
        !__glsReader_getToken_text(inoutReader, &token) || \
        !__glsTokenTo##inBase(token.head, outVec++) || \
        inCount > 0 && !__glsReader_getChar_text(inoutReader, ',', GL_TRUE) \
    ) { \
        __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR); \
        __glsString_final(&token); \
        return GL_FALSE; \
    } \
    __glsString_final(&token); \
    __glsReader_getChar_text(inoutReader, ',', GL_FALSE); \
    if (!__glsReader_getChar_text(inoutReader, '}', GL_TRUE)) { \
        return GL_FALSE; \
    } \
    return GL_TRUE; \
}

#define __GLS_READER_APPEND_CHAR(inoutReader, inoutString, inChar) \
    if (!__glsString_appendChar(inoutString, inChar)) { \
        __glsReader_raiseError(inoutReader, GLS_OUT_OF_MEMORY); \
        return GL_FALSE; \
    }

/******************************************************************************
Token converters
******************************************************************************/

__GLS_FORWARD static GLboolean __glsTokenToGLulong(
    const GLubyte *inToken, GLulong *outVal
);
__GLS_FORWARD static GLboolean __glsTokenToGLuint(
    const GLubyte *inToken, GLuint *outVal
);

static GLubyte __glsQuotedChar(const GLubyte *inToken, GLubyte **outPtr) {
    if (
        inToken[0] == '\''&&
        inToken[2] == '\'' &&
        !inToken[3] &&
        __GLS_CHAR_IS_GRAPHIC(inToken[1])
    ) {
        if (outPtr) *outPtr = (GLubyte *)inToken + 3;
        return inToken[1];
    } else {
        if (outPtr) *outPtr = (GLubyte *)inToken;
        return 0;
    }
}

static GLboolean __glsTokenToGLboolean(
    const GLubyte *inToken, GLboolean *outVal
) {
    GLubyte *ptr;
    unsigned long val;
    
    if (!strcmp((const char *)inToken, "GL_FALSE")) {
        *outVal = GL_FALSE;
        return GL_TRUE;
    } else if (!strcmp((const char *)inToken, "GL_TRUE")) {
        *outVal = GL_TRUE;
        return GL_TRUE;
    }
    val = strtoul((const char *)inToken, (char **)&ptr, 0);
    *outVal = (GLboolean)val;
    return (GLboolean)(!*ptr && val <= UCHAR_MAX);
}

static GLboolean __glsTokenToGLbyte(const GLubyte *inToken, GLbyte *outVal) {
    GLubyte *ptr;
    long val;
    
    val = strtol((const char *)inToken, (char **)&ptr, 0);
    if (*ptr) val = __glsQuotedChar(inToken, &ptr);
    *outVal = (GLbyte)val;
    return (GLboolean)(!*ptr && val >= SCHAR_MIN && val <= SCHAR_MAX);
}

static GLboolean __glsTokenToGLdouble(
    const GLubyte *inToken, GLdouble *outVal
) {
    GLubyte *ptr;
    GLdouble sign;
    __GLS_C_LOCALE_DECLARE;

    __GLS_PUT_ERRNO(0);
    __GLS_C_LOCALE_BEGIN;
    *outVal = strtod((const char *)inToken, (char **)&ptr);
    __GLS_C_LOCALE_END;
    if (!*ptr) return (GLboolean)(__GLS_ERRNO != ERANGE);
    if (
        inToken[0] == '0' && __glsTokenToGLulong(inToken, (GLulong *)outVal)
    ) {
        return GL_TRUE;
    }
    if (!strcmp((const char *)inToken, "nan")) {
        *outVal = *(const GLdouble *)__glsQuietNaN;
        return GL_TRUE;
    }
    sign = 1.;
    if (*inToken == '-') {
        sign = -1.;
        ++inToken;
    } else if (*inToken == '+') {
        ++inToken;
    }
    if (!strcmp((const char *)inToken, "inf")) {
        *outVal = sign * HUGE_VAL;
        return GL_TRUE;
    }
    {
        GLint intVal;
        if (
            __glsStr2IntDict_find(__glsParser->glEnumDict, inToken, &intVal) ||
            __glsStr2IntDict_find(__glsParser->glsEnumDict, inToken, &intVal)
        ) {
            *outVal = (GLdouble)intVal;
            return GL_TRUE;
        }
    }
    return GL_FALSE;
}

static GLboolean __glsTokenToGLfloat(
    const GLubyte *inToken, GLfloat *outVal
) {
    GLdouble doubleVal;
    GLubyte *ptr;
    GLdouble sign;
    __GLS_C_LOCALE_DECLARE;

    __GLS_PUT_ERRNO(0);
    __GLS_C_LOCALE_BEGIN;
    doubleVal = strtod((const char *)inToken, (char **)&ptr);
    *outVal = (GLfloat)doubleVal;
    __GLS_C_LOCALE_END;
    if (doubleVal < 0.) doubleVal = -doubleVal;
    if (!*ptr) return (GLboolean)(
        __GLS_ERRNO != ERANGE &&
        (
            !doubleVal ||
            doubleVal >= (GLdouble)FLT_MIN && doubleVal <= (GLdouble)FLT_MAX
        )
    );
    if (
        inToken[0] == '0' && __glsTokenToGLuint(inToken, (GLuint *)outVal)
    ) {
        return GL_TRUE;
    }
    if (!strcmp((const char *)inToken, "nan")) {
        *outVal = *(const GLfloat *)__glsQuietNaN;
        return GL_TRUE;
    }
    sign = 1.;
    if (*inToken == '-') {
        sign = -1.;
        ++inToken;
    } else if (*inToken == '+') {
        ++inToken;
    }
    if (!strcmp((const char *)inToken, "inf")) {
        *outVal = (GLfloat)(sign * HUGE_VAL);
        return GL_TRUE;
    }
    {
        GLint intVal;
        if (
            __glsStr2IntDict_find(__glsParser->glEnumDict, inToken, &intVal) ||
            __glsStr2IntDict_find(__glsParser->glsEnumDict, inToken, &intVal)
        ) {
            *outVal = (GLfloat)intVal;
            return GL_TRUE;
        }
    }
    return GL_FALSE;
}

static GLboolean __glsTokenToGLint(const GLubyte *inToken, GLint *outVal) {
    GLubyte *ptr;
    long val;
    
    __GLS_PUT_ERRNO(0);
    val = strtol((const char *)inToken, (char **)&ptr, 0);
    if (*ptr) {
        __GLS_PUT_ERRNO(0);
        val = __glsQuotedChar(inToken, &ptr);
    }
    if (!*ptr) {
        *outVal = (GLint)val;
        return (GLboolean)(
            __GLS_ERRNO != ERANGE && val >= INT_MIN && val <= INT_MAX
        );
    }
    return (GLboolean)(
        __glsStr2IntDict_find(__glsParser->glEnumDict, inToken, outVal) ||
        __glsStr2IntDict_find(__glsParser->glsEnumDict, inToken, outVal)
    );
}

#if defined(__GLS_STR_TO_INT64)

static GLboolean __glsTokenToGLlong(const GLubyte *inToken, GLlong *outVal) {
    GLint intVal;
    GLubyte *ptr;
    
    __GLS_PUT_ERRNO(0);
    *outVal = __GLS_STR_TO_INT64((const char *)inToken, (char **)&ptr, 0);
    if (*ptr) {
        __GLS_PUT_ERRNO(0);
        *outVal = __glsQuotedChar(inToken, &ptr);
    }
    if (!*ptr) return (GLboolean)(__GLS_ERRNO != ERANGE);
    if (
        __glsStr2IntDict_find(__glsParser->glEnumDict, inToken, &intVal) ||
        __glsStr2IntDict_find(__glsParser->glsEnumDict, inToken, &intVal)
    ) {
        *outVal = intVal;
        return GL_TRUE;
    }
    return GL_FALSE;
}

#else /* !defined(__GLS_STR_TO_INT64) */

static GLboolean __glsTokenToGLlong(const GLubyte *inToken, GLlong *outVal) {
    GLubyte *ptr;
    GLint intVal;
    long val;
    
    if (
        inToken[0] == '0' &&
        (inToken[1] == 'x' || inToken[1] == 'X') &&
        strlen((const char *)inToken) == 18
    ) {
        GLint high;
        GLuint low;
        __GLSstringBuf strBuf;

        strcpy((char *)strBuf, (const char *)inToken);
        strBuf[10] = 0;
        high = (GLint)strtol((const char *)strBuf, (char **)&ptr, 0);
        if (*ptr) return GL_FALSE;
        strcpy((char *)(strBuf + 2), (const char *)(inToken + 10));
        low = (GLuint)strtoul((const char *)strBuf, (char **)&ptr, 0);
        *outVal = glsLong(high, low);
        return !*ptr;
    }
    __GLS_PUT_ERRNO(0);
    val = strtol((const char *)inToken, (char **)&ptr, 0);
    if (!*ptr) {
        *outVal = glsLong((val & 0x80000000) ? -1 : 0, (GLuint)val);
        return __GLS_ERRNO != ERANGE && val >= INT_MIN && val <= INT_MAX;
    }
    if (
        __glsStr2IntDict_find(__glsParser->glEnumDict, inToken, &intVal) ||
        __glsStr2IntDict_find(__glsParser->glsEnumDict, inToken, &intVal)
    ) {
        *outVal = glsLong(0, intVal);
        return GL_TRUE;
    }
    *outVal = glsLong(0, __glsQuotedChar(inToken, &ptr));
    return !*ptr;
}

#endif /* defined(__GLS_STR_TO_INT64) */

static GLboolean __glsTokenToGLshort(const GLubyte *inToken, GLshort *outVal) {
    GLubyte *ptr;
    long val;
    
    val = strtol((const char *)inToken, (char **)&ptr, 0);
    if (*ptr) val = __glsQuotedChar(inToken, &ptr);
    *outVal = (GLshort)val;
    return (GLboolean)(!*ptr && val >= SHRT_MIN && val <= SHRT_MAX);
}

static GLboolean __glsTokenToGLubyte(const GLubyte *inToken, GLubyte *outVal) {
    GLubyte *ptr;
    unsigned long val;
    
    val = strtoul((const char *)inToken, (char **)&ptr, 0);
    if (*ptr) val = __glsQuotedChar(inToken, &ptr);
    *outVal = (GLubyte)val;
    return (GLboolean)(!*ptr && val <= UCHAR_MAX);
}

static GLboolean __glsTokenToGLuint(const GLubyte *inToken, GLuint *outVal) {
    GLubyte *ptr;
    unsigned long val;
    
    __GLS_PUT_ERRNO(0);
    val = strtoul((const char *)inToken, (char **)&ptr, 0);
    if (*ptr) {
        __GLS_PUT_ERRNO(0);
        val = __glsQuotedChar(inToken, &ptr);
    }
    if (!*ptr) {
        *outVal = (GLuint)val;
        return (GLboolean)(__GLS_ERRNO != ERANGE && val <= UINT_MAX);
    }
    return (GLboolean)(
        __glsStr2IntDict_find(
            __glsParser->glEnumDict, inToken, (GLint *)outVal
        ) ||
        __glsStr2IntDict_find(
            __glsParser->glsEnumDict, inToken, (GLint *)outVal
        )
    );
}

#if defined(__GLS_STR_TO_INT64U)

static GLboolean __glsTokenToGLulong(
    const GLubyte *inToken, GLulong *outVal
) {
    GLint intVal;
    GLubyte *ptr;
    
    __GLS_PUT_ERRNO(0);
    *outVal = __GLS_STR_TO_INT64U((const char *)inToken, (char **)&ptr, 0);
    if (*ptr) {
        __GLS_PUT_ERRNO(0);
        *outVal = __glsQuotedChar(inToken, &ptr);
    }
    if (!*ptr) return (GLboolean)(__GLS_ERRNO != ERANGE);
    if (
        __glsStr2IntDict_find(__glsParser->glEnumDict, inToken, &intVal) ||
        __glsStr2IntDict_find(__glsParser->glsEnumDict, inToken, &intVal)
    ) {
        *outVal = intVal;
        return GL_TRUE;
    }
    return GL_FALSE;
}

#else /* !defined(__GLS_STR_TO_INT64U) */

static GLboolean __glsTokenToGLulong(const GLubyte *inToken, GLulong *outVal) {
    GLubyte *ptr;
    GLint intVal;
    unsigned long val;
    
    if (
        inToken[0] == '0' &&
        (inToken[1] == 'x' || inToken[1] == 'X') &&
        strlen((const char *)inToken) == 18
    ) {
        GLuint high, low;
        __GLSstringBuf strBuf;

        strcpy((char *)strBuf, (const char *)inToken);
        strBuf[10] = 0;
        high = (GLuint)strtoul((const char *)strBuf, (char **)&ptr, 0);
        if (*ptr) return GL_FALSE;
        strcpy((char *)(strBuf + 2), (const char *)(inToken + 10));
        low = (GLuint)strtoul((const char *)strBuf, (char **)&ptr, 0);
        *outVal = glsULong(high, low);
        return !*ptr;
    }
    __GLS_PUT_ERRNO(0);
    val = strtoul((const char *)inToken, (char **)&ptr, 0);
    if (!*ptr) {
        *outVal = glsULong(0, (GLuint)val);
        return __GLS_ERRNO != ERANGE && val <= UINT_MAX;
    }
    if (
        __glsStr2IntDict_find(__glsParser->glEnumDict, inToken, &intVal) ||
        __glsStr2IntDict_find(__glsParser->glsEnumDict, inToken, &intVal)
    ) {
        *outVal = glsULong(0, intVal);
        return GL_TRUE;
    }
    *outVal = glsULong(0, __glsQuotedChar(inToken, &ptr));
    return !*ptr;
}

#endif /* defined(__GLS_STR_TO_INT64U) */

static GLboolean __glsTokenToGLushort(
    const GLubyte *inToken, GLushort *outVal
) {
    GLubyte *ptr;
    unsigned long val;
    
    val = strtoul((const char *)inToken, (char **)&ptr, 0);
    if (*ptr) val = __glsQuotedChar(inToken, &ptr);
    *outVal = (GLushort)val;
    return (GLboolean)(!*ptr && val <= USHRT_MAX);
}

/******************************************************************************
Private readers
******************************************************************************/

__GLS_FORWARD static GLboolean __glsReader_getChar_text(
    __GLSreader *inoutReader, GLubyte inChar, GLboolean inRequired
);

__GLS_FORWARD static GLboolean __glsReader_getToken_text(
    __GLSreader *inoutReader, __GLSstring *outToken
);

static GLboolean __glsReader_getBitfield_text(
    __GLSreader *inoutReader, const __GLSdict *inDict, GLbitfield *outBits
) {
    __GLSstring token;
    GLbitfield val = 0;

    __glsString_init(&token);
    __GLS_BEGIN_PARAM(inoutReader);
    *outBits = GLS_NONE;
    while (__glsReader_getToken_text(inoutReader, &token)) {
        if (
            __glsStr2IntDict_find(inDict, token.head, (GLint *)&val) ||
            __glsTokenToGLuint(token.head, &val)
        ) {
            *outBits |= val;
        } else {
            __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
            __glsString_final(&token);
            return GL_FALSE;
        }
        if (!__glsReader_getChar_text(inoutReader, '|', GL_FALSE)) {
            __glsString_final(&token);
            return GL_TRUE;
        }
    }
    __glsString_final(&token);
    return GL_FALSE;
}

static GLboolean __glsReader_getChar_text(
    __GLSreader *inoutReader, GLubyte inChar, GLboolean inRequired
) {
    GLubyte readChar;

    __GLS_GET_SPACE(inoutReader);
    __GLS_READ_CHAR(inoutReader, readChar);
    if (readChar != inChar) {
        __GLS_UNREAD_CHAR(inoutReader);
        if (inRequired) __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
    }
    return (GLboolean)(readChar == inChar);
}

static GLboolean __glsReader_getEnum_text(
    __GLSreader *inoutReader, const __GLSdict *inDict, GLuint *outVal
) {
    __GLSstring token;

    __glsString_init(&token);
    __GLS_BEGIN_PARAM(inoutReader);
    if (
        __glsReader_getToken_text(inoutReader, &token) &&
        (
            __glsStr2IntDict_find(inDict, token.head, (GLint *)outVal) ||
            __glsTokenToGLuint(token.head, outVal)
        )
    ) {
        __glsString_final(&token);
        return GL_TRUE;
    } else {
        __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
        __glsString_final(&token);
        return GL_FALSE;
    }
}

static GLboolean __glsReader_getIntOrEnum_text(
    __GLSreader *inoutReader, const __GLSdict *inDict, GLint *outVal
) {
    __GLSstring token;

    __glsString_init(&token);
    __GLS_BEGIN_PARAM(inoutReader);
    if (
        __glsReader_getToken_text(inoutReader, &token) &&
        (
            __glsTokenToGLint(token.head, outVal) ||
            __glsStr2IntDict_find(inDict, token.head, outVal)
        )
    ) {
        __glsString_final(&token);
        return GL_TRUE;
    } else {
        __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
        __glsString_final(&token);
        return GL_FALSE;
    }
}

static GLboolean __glsReader_getToken_text(
    __GLSreader *inoutReader, __GLSstring *outToken
) {
    GLint count = 0;
    GLubyte readChar;

    __GLS_GET_SPACE(inoutReader);
    __glsString_reset(outToken);
    for (;;) {
        __GLS_READ_CHAR(inoutReader, readChar);
        if (__GLS_CHAR_IS_TOKEN(readChar)) {
            __GLS_READER_APPEND_CHAR(inoutReader, outToken, readChar);
            ++count;
        } else if (!count && readChar == '\'') {
            __GLS_READER_APPEND_CHAR(inoutReader, outToken, readChar);
            __GLS_READ_CHAR(inoutReader, readChar);
            if (__GLS_CHAR_IS_GRAPHIC(readChar)) {
                __GLS_READER_APPEND_CHAR(inoutReader, outToken, readChar);
            } else {
                __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
                break;
            }
            __GLS_READ_CHAR(inoutReader, readChar);
            if (readChar == '\'') {
                __GLS_READER_APPEND_CHAR(inoutReader, outToken, readChar);
                return GL_TRUE;
            } else {
                __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
                break;
            }
        } else {
            __GLS_UNREAD_CHAR(inoutReader);
            if (count && count < __GLS_STRING_BUF_BYTES - 1) {
                return GL_TRUE;
            } else {
                __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
                break;
            }
        }
    }
    return GL_FALSE;
}

/******************************************************************************
Public functions
******************************************************************************/

GLboolean __glsReader_abortCommand_text(__GLSreader *inoutReader) {
    GLubyte prevChar = 0;
    GLubyte readChar;
    GLboolean string = GL_FALSE;

    for (;;) {
        if (
            inoutReader->readPtr >= inoutReader->readTail &&
            !__glsReader_fillBuf(inoutReader, 1, GL_FALSE)
        ) {
            break;
        }
        readChar = *inoutReader->readPtr++;
        if (readChar == '"') {
            if (string) {
                if (prevChar != '\\') string = GL_FALSE;
            } else {
                string = GL_TRUE;
            }
        }
        if (readChar == ';' && !string) return GL_TRUE;
        prevChar = readChar;
    }
    return GL_FALSE;
}

GLboolean __glsReader_beginCommand_text(
    __GLSreader *inoutReader, __GLSstring *outCommand
) {
    inoutReader->error = GLS_NONE;
    inoutReader->paramCount = 0;
    return (GLboolean)(
        __glsReader_getToken_text(inoutReader, outCommand) &&
        __glsReader_getChar_text(inoutReader, '(', GL_TRUE)
    );
}

GLboolean __glsReader_call_text(__GLSreader *inoutReader) {
    __GLSstring command;
    GLSopcode opcode;

    if (!__glsParser) {
        __glsBeginCriticalSection();
        if (!__glsParser) __glsParser = __glsParser_create();
        __glsEndCriticalSection();
        if (!__glsParser) {
            __GLS_RAISE_ERROR(GLS_OUT_OF_MEMORY);
            return GL_FALSE;
        }
    }
    __glsString_init(&command);
    for (;;) {
        if (__GLS_CONTEXT->abortMode) {
            __glsString_final(&command);
            break;
        }
        if (__glsReader_beginCommand_text(inoutReader, &command)) {
            if (__glsParser_findCommand(__glsParser, command.head, &opcode)) {
                if (opcode == GLS_OP_glsEndGLS) {
                    if (__glsReader_endCommand_text(inoutReader)) {
                        __glsString_final(&command);
                        return GL_TRUE;
                    } else {
                        __GLS_CALL_ERROR(__GLS_CONTEXT, opcode, GLS_DECODE_ERROR);
                        __glsString_final(&command);
                        return __glsReader_abortCommand_text(inoutReader);
                    }
                }
#ifndef __GLS_PLATFORM_WIN32
                // DrewB
                __glsDispatchDecode_text[__glsMapOpcode(opcode)](inoutReader);
#else
                __glsDispatchDecode_text[__glsMapOpcode(opcode)](__GLS_CONTEXT,
                                                                 inoutReader);
#endif
                __glsReader_endCommand_text(inoutReader);
                if (inoutReader->error) {
                    __GLS_CALL_ERROR(__GLS_CONTEXT, opcode, inoutReader->error);
                    if (!__glsReader_abortCommand_text(inoutReader)) {
                        __glsString_final(&command);
                        break;
                    }
                }
            } else {
                if (!__glsReader_abortCommand_text(inoutReader)) {
                    __glsString_final(&command);
                    break;
                }
            }
        } else {
            __GLS_CALL_UNSUPPORTED_COMMAND(__GLS_CONTEXT);
            if (!__glsReader_abortCommand_text(inoutReader)) {
                __glsString_final(&command);
                break;
            }
        }
    }
    return GL_FALSE;
}

GLboolean __glsReader_endCommand_text(__GLSreader *inoutReader) {
    return (GLboolean)(
        !inoutReader->error &&
        __glsReader_getChar_text(inoutReader, ')', GL_TRUE) &&
        __glsReader_getChar_text(inoutReader, ';', GL_TRUE)
    );
}

GLboolean __glsReader_getGLSenum_text(
    __GLSreader *inoutReader, GLSenum *outVal
) {
    return __glsReader_getEnum_text(
        inoutReader, __glsParser->glsEnumDict, outVal
    );
}

GLboolean __glsReader_getGLSimageFlags_text(
    __GLSreader *inoutReader, GLbitfield *outVal
) {
    return __glsReader_getBitfield_text(
        inoutReader, __glsParser->glsImageFlagsDict, outVal
    );
}

GLboolean __glsReader_getGLSopcode_text(
    __GLSreader *inoutReader, GLSopcode *outVal
) {
    __GLSstring token;

    __glsString_init(&token);
    __GLS_BEGIN_PARAM(inoutReader);
    if (
        __glsReader_getToken_text(inoutReader, &token) &&
        (
            !strncmp((const char *)token.head, "GLS_OP_", 7) &&
            __glsStr2IntDict_find(
                __glsParser->glsOpDict,
                token.head + 7,
                (GLint *)outVal
            ) ||
            __glsTokenToGLuint(token.head, outVal)
        )
    ) {
        __glsString_final(&token);
        return GL_TRUE;
    } else {
        __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
        __glsString_final(&token);
        return GL_FALSE;
    }
}

GLboolean __glsReader_getGLattribMask_text(
    __GLSreader *inoutReader, GLbitfield *outVal
) {
    return __glsReader_getBitfield_text(
        inoutReader, __glsParser->glAttribMaskDict, outVal
    );
}

GLboolean __glsReader_getGLblendingFactor_text(
    __GLSreader *inoutReader, GLenum *outVal
) {
    return __glsReader_getEnum_text(
        inoutReader, __glsParser->glEnumDict, outVal
    );
}

__GLS_GET_TEXT(GLboolean, GLboolean)
__GLS_GET_TEXT(GLbyte, GLbyte)

GLboolean __glsReader_getGLcharv_text(
    __GLSreader *inoutReader, __GLSstring *outString
) {
    GLint hexCount = -1;
    GLboolean outVal = GL_TRUE;
    GLubyte prevChar = 0;
    GLubyte readChar;

    __GLS_BEGIN_PARAM(inoutReader);
    if (!__glsReader_getChar_text(inoutReader, '"', GL_TRUE)) return GL_FALSE;
    __glsString_reset(outString);
    for (;;) {
        __GLS_READ_CHAR(inoutReader, readChar);
        if (!readChar) {
            __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
            break;
        } else if (hexCount >= 0) {
            if (!isxdigit(readChar)) {
                __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
                outVal = GL_FALSE;
                hexCount = -1;
            } else if (++hexCount == 2) {
                GLubyte buf[3];

                buf[0] = prevChar;
                buf[1] = readChar;
                buf[2] = 0;
                readChar = (GLubyte)strtoul((const char *)buf, GLS_NONE, 16);
                __GLS_READER_APPEND_CHAR(inoutReader, outString, readChar);
                hexCount = -1;
            }
        } else if (readChar == '\\') {
            if (prevChar == '\\') {
                __GLS_READER_APPEND_CHAR(inoutReader, outString, readChar);
                readChar = 0;
            }
        } else if (readChar == '"') {
            if (prevChar == '\\') {
                __GLS_READER_APPEND_CHAR(inoutReader, outString, readChar);
            } else if (__glsReader_getChar_text(inoutReader, '"', GL_FALSE)) {
                continue;
            } else {
                if (outVal && !glsIsUTF8String(outString->head)) {
                    __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
                    outVal = GL_FALSE;
                }
                return outVal;
            }
        } else if (readChar == 'x' && prevChar == '\\') {
            hexCount = 0;
        } else if (!__GLS_CHAR_IS_GRAPHIC(readChar) || prevChar == '\\') {
            __glsReader_raiseError(inoutReader, GLS_DECODE_ERROR);
            outVal = GL_FALSE;
        } else {
            __GLS_READER_APPEND_CHAR(inoutReader, outString, readChar);
        }
        prevChar = readChar;
    }
    return GL_FALSE;
}

GLboolean __glsReader_getGLclearBufferMask_text(
    __GLSreader *inoutReader, GLbitfield *outVal
) {
    return __glsReader_getBitfield_text(
        inoutReader, __glsParser->glAttribMaskDict, outVal
    );
}

GLboolean __glsReader_getGLcompv_text(
    __GLSreader *inoutReader, GLenum inType, GLuint inBytes, GLvoid *outVec
) {
    switch (inType) {
        case __GLS_BOOLEAN:
            return __glsReader_getGLbooleanv_text(
                inoutReader, inBytes, (GLboolean *)outVec
            );
        case GL_BITMAP:
            return __glsReader_getGLubytev_text(
                inoutReader, (inBytes + 7) / 8, (GLubyte *)outVec
            );
        case GL_BYTE:
            return __glsReader_getGLbytev_text(
                inoutReader, inBytes, (GLbyte *)outVec
            );
        case GL_FLOAT:
            return __glsReader_getGLfloatv_text(
                inoutReader, inBytes / 4, (GLfloat *)outVec
            );
        case GL_INT:
            return __glsReader_getGLintv_text(
                inoutReader, inBytes / 4, (GLint *)outVec
            );
        case GL_SHORT:
            return __glsReader_getGLshortv_text(
                inoutReader, inBytes / 2, (GLshort *)outVec
            );
        case GL_2_BYTES:
        case GL_3_BYTES:
        case GL_4_BYTES:
        case GL_UNSIGNED_BYTE:
        #if __GL_EXT_packed_pixels
            case GL_UNSIGNED_BYTE_3_3_2_EXT:
        #endif /* __GL_EXT_packed_pixels */
            return __glsReader_getGLubytev_text(
                inoutReader, inBytes, (GLubyte *)outVec
            );
        case GL_UNSIGNED_INT:
        #if __GL_EXT_packed_pixels
            case GL_UNSIGNED_INT_8_8_8_8_EXT:
            case GL_UNSIGNED_INT_10_10_10_2_EXT:
        #endif /* __GL_EXT_packed_pixels */
            return __glsReader_getGLuintv_text(
                inoutReader, inBytes / 4, (GLuint *)outVec
            );
        case GL_UNSIGNED_SHORT:
        #if __GL_EXT_packed_pixels
            case GL_UNSIGNED_SHORT_4_4_4_4_EXT:
            case GL_UNSIGNED_SHORT_5_5_5_1_EXT:
        #endif /* __GL_EXT_packed_pixels */
            return __glsReader_getGLushortv_text(
                inoutReader, inBytes / 2, (GLushort *)outVec
            );
        #if __GL_EXT_vertex_array
            case GL_DOUBLE_EXT:
                return __glsReader_getGLdoublev_text(
                    inoutReader, inBytes / 8, (GLdouble *)outVec
                );
        #endif /* __GL_EXT_vertex_array */
        default:
            return __glsReader_getGLbytev_text(inoutReader, 0, GLS_NONE);
    }
}

__GLS_GET_TEXT(GLdouble, GLdouble)

GLboolean __glsReader_getGLdrawBufferMode_text(
    __GLSreader *inoutReader, GLenum *outVal
) {
    return __glsReader_getEnum_text(
        inoutReader, __glsParser->glEnumDict, outVal
    );
}

GLboolean __glsReader_getGLenum_text(
    __GLSreader *inoutReader, GLenum *outVal
) {
    return __glsReader_getEnum_text(
        inoutReader, __glsParser->glEnumDict, outVal
    );
}

__GLS_GET_TEXT(GLfloat, GLfloat)
__GLS_GET_TEXT(GLint, GLint)
__GLS_GET_TEXT(GLlong, GLlong)
__GLS_GET_TEXT(GLshort, GLshort)

GLboolean __glsReader_getGLstencilOp_text(
    __GLSreader *inoutReader, GLenum *outVal
) {
    return __glsReader_getEnum_text(
        inoutReader, __glsParser->glEnumDict, outVal
    );
}

GLboolean __glsReader_getGLtextureComponentCount_text(
    __GLSreader *inoutReader, GLint *outVal
) {
    return __glsReader_getIntOrEnum_text(
        inoutReader, __glsParser->glEnumDict, outVal
    );
}

__GLS_GET_TEXT(GLubyte, GLubyte)
__GLS_GET_TEXT(GLuint, GLuint)
__GLS_GET_TEXT(GLulong, GLulong)
__GLS_GET_TEXT(GLushort, GLushort)

GLboolean __glsReader_nextList_text(__GLSreader *inoutReader) {
    inoutReader->paramCount = 0;
    return (GLboolean)(
        !inoutReader->error &&
        __glsReader_getChar_text(inoutReader, ')', GL_TRUE) &&
        __glsReader_getChar_text(inoutReader, '(', GL_TRUE)
    );
}

GLSenum __glsReader_readBeginGLS_text(
    __GLSreader *inoutReader, __GLSversion *outVersion
) {
    __GLSstring beginGLS;
    __GLSversion version;

    __glsString_init(&beginGLS);
    if (
        __glsReader_beginCommand_text(inoutReader, &beginGLS) &&
        !strcmp((const char *)beginGLS.head, "glsBeginGLS") &&
        __glsReader_getGLint_text(inoutReader, &version.major) &&
        __glsReader_getGLint_text(inoutReader, &version.minor) &&
        __glsReader_endCommand_text(inoutReader) &&
        (!version.major || version.major == __GLS_VERSION_MAJOR)
    ) {
        __glsString_final(&beginGLS);
        *outVersion = version;
        return GLS_TEXT;
    } else {
        __glsString_final(&beginGLS);
        return GLS_NONE;
    }
}