able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/opengl/gls/lib/writetxt.c

898 lines
29 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
** 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 <limits.h>
#include <locale.h>
#include <math.h>
#include <string.h>
/******************************************************************************
Helpers
******************************************************************************/
#define __GLS_ALLOC(inoutWriter, inReturn) \
if ( \
inoutWriter->bufPtr >= inoutWriter->bufTail && \
!__glsWriter_flush(inoutWriter) \
) { \
return inReturn; \
}
#define __GLS_PARAM_SEP(inoutWriter) \
if (inoutWriter->paramCount++) { \
__GLS_PUT_CHAR(inoutWriter, ','); \
__GLS_PUT_CHAR(inoutWriter, ' '); \
}
#define __GLS_PARAM_SETUP(inoutWriter) \
__GLS_ALLOC(inoutWriter, __GLS_NULL); \
__GLS_PARAM_SEP(inoutWriter);
#define __GLS_PUT_BOOLEAN(inoutWriter, inVal) \
if (!__glsWriter_putGLbooleanVal_text(inoutWriter, inVal)) { \
__GLS_PUT_INT(inoutWriter, inVal); \
}
#define __GLS_PUT_CHAR(inoutWriter, inChar) \
*inoutWriter->bufPtr++ = inChar;
#define __GLS_PUT_DOUBLE(inoutWriter, inVal) \
if (__GLS_FINITE(inVal)) { \
__GLS_C_LOCALE_DECLARE; \
__GLS_C_LOCALE_BEGIN; \
__GLS_PUT_NUM(inoutWriter, "%.16g", inVal); \
__GLS_C_LOCALE_END; \
} else { \
__GLS_PUT_HEX16(inoutWriter, *(const GLulong *)&(inVal)); \
}
#define __GLS_PUT_DOUBLE17(inoutWriter, inVal) \
if (__GLS_FINITE(inVal)) { \
__GLS_C_LOCALE_DECLARE; \
__GLS_C_LOCALE_BEGIN; \
__GLS_PUT_NUM(inoutWriter, "%-17.16g", inVal); \
__GLS_C_LOCALE_END; \
} else { \
__GLS_PUT_HEX16(inoutWriter, *(const GLulong *)&(inVal)); \
}
#define __GLS_PUT_FLOAT(inoutWriter, inVal) \
if (__GLS_FINITE((GLdouble)inVal)) { \
__GLS_C_LOCALE_DECLARE; \
__GLS_C_LOCALE_BEGIN; \
__GLS_PUT_NUM(inoutWriter, "%.7g", inVal); \
__GLS_C_LOCALE_END; \
} else { \
__GLS_PUT_HEX8(inoutWriter, *(const GLuint *)&(inVal)); \
}
#define __GLS_PUT_FLOAT11(inoutWriter, inVal) \
if (__GLS_FINITE((GLdouble)inVal)) { \
__GLS_C_LOCALE_DECLARE; \
__GLS_C_LOCALE_BEGIN; \
__GLS_PUT_NUM(inoutWriter, "%-11.7g", inVal); \
__GLS_C_LOCALE_END; \
} else { \
__GLS_PUT_HEX8(inoutWriter, *(const GLuint *)&(inVal)); \
}
#define __GLS_PUT_HEX2(inoutWriter, inVal) \
__GLS_PUT_NUM(inoutWriter, "0x%.2x", inVal);
#define __GLS_PUT_HEX4(inoutWriter, inVal) \
__GLS_PUT_NUM(inoutWriter, "0x%.4x", inVal);
#define __GLS_PUT_HEX8(inoutWriter, inVal) \
__GLS_PUT_NUM(inoutWriter, "0x%.8x", inVal);
#if __GLS_SPRINTF_INT64
#define __GLS_PUT_HEX16(inoutWriter, inVal) \
__GLS_PUT_NUM(inoutWriter, __GLS_OUT_FORMAT_INT64HEX, inVal);
#else /* !__GLS_SPRINTF_INT64 */
#define __GLS_PUT_HEX16(inoutWriter, inVal) \
__GLS_PUT_NUM( \
inoutWriter, "0x%.8x", glsULongHigh(*(const GLulong *)&(inVal)) \
); \
__GLS_PUT_NUM( \
inoutWriter, "%.8x", glsULongLow(*(const GLulong *)&(inVal)) \
);
#endif /* __GLS_SPRINTF_INT64 */
#define __GLS_PUT_INT(inoutWriter, inVal) \
__GLS_PUT_NUM(inoutWriter, "%d", inVal);
#if __GLS_SPRINTF_INT64
#define __GLS_PUT_LONG(inoutWriter, inVal) \
__GLS_PUT_NUM(inoutWriter, __GLS_OUT_FORMAT_INT64, inVal);
#elif defined(__GLS_INT64_TO_STR)
#define __GLS_PUT_LONG(inoutWriter, inVal) \
inoutWriter->bufPtr += \
strlen(__GLS_INT64_TO_STR(inVal, (char *)inoutWriter->bufPtr));
#else /* !__GLS_SPRINTF_INT64 && !defined(__GLS_INT64_TO_STR) */
#define __GLS_PUT_LONG(inoutWriter, inVal) \
__GLS_PUT_HEX16(inoutWriter, inVal);
#endif /* __GLS_SPRINTF_INT64 */
#define __GLS_PUT_NUM(inoutWriter, inFormat, inVal) \
inoutWriter->bufPtr += sprintf( \
(char *)inoutWriter->bufPtr, (const char *)(inFormat), inVal \
);
#define __GLS_PUT_STRING(inoutWriter, inString) { \
size_t __count = strlen((const char *)inString); \
const GLubyte *ptr = glsCSTR(inString); \
while (__count-- > 0) { \
if (*ptr == '\\' || *ptr == '\"') *inoutWriter->bufPtr++ = '\\'; \
*inoutWriter->bufPtr++ = *ptr++; \
} \
}
#define __GLS_PUT_TEXT(inType, inSize, inCategory) \
__GLS_PUT_TEXT_VAL(inType, inSize, inCategory) \
__GLS_PUT_TEXT_VEC(inType, inSize, inCategory) \
__GLS_PUT_TEXT_VECSTRIDE(inType, inSize, inCategory)
#define __GLS_PUT_TEXT_ENUM(inType, inEnum, inCategory) \
__GLS_PUT_TEXT_ENUM_VAL(inType, inEnum, inCategory) \
__GLS_PUT_TEXT_ENUM_VEC(inType, inEnum, inCategory)
#define __GLS_PUT_TEXT_ENUM_VAL(inType, inEnum, inCategory) \
static void __glsWriter_put##inType##Or##inEnum##_text( \
__GLSwriter *inoutWriter, \
GLenum inParam, \
inType inVal \
) { \
__GLS_PARAM_SETUP(inoutWriter); \
if ( \
!__GLS_FINITE((GLdouble)inVal) || \
floor((GLdouble)inVal) != (GLdouble)inVal || \
(GLdouble)inVal < 0. || \
(GLdouble)inVal > (GLdouble)UINT_MAX || \
!__glsWriter_put##inEnum##ParamVal_text( \
inoutWriter, inParam, (inEnum)inVal \
) \
) { \
__GLS_PUT_##inCategory(inoutWriter, inVal); \
} \
}
#define __GLS_PUT_TEXT_ENUM_VEC(inType, inEnum, inCategory) \
static void __glsWriter_put##inType##Or##inEnum##v_text( \
__GLSwriter *inoutWriter, \
GLenum inParam, \
GLuint inCount, \
const inType *inVec \
) { \
GLuint i; \
const GLboolean multiLine = (GLboolean)(inCount > 4); \
__GLS_PARAM_SETUP(inoutWriter); \
__GLS_PUT_CHAR(inoutWriter, '{'); \
for (i = 0 ; i < inCount ; ++i) { \
__GLS_ALLOC(inoutWriter, __GLS_NULL); \
if (i) __GLS_PUT_CHAR(inoutWriter, ','); \
if (multiLine && !(i & 7)) { \
__GLS_PUT_STRING(inoutWriter, "\n "); \
} else if (i) { \
__GLS_PUT_CHAR(inoutWriter, ' '); \
} \
if ( \
!__GLS_FINITE((GLdouble)inVec[i]) || \
floor((GLdouble)inVec[i]) != (GLdouble)inVec[i] || \
(GLdouble)inVec[i] < 0. || \
(GLdouble)inVec[i] > (GLdouble)UINT_MAX || \
!__glsWriter_put##inEnum##ParamVal_text( \
inoutWriter, inParam, (inEnum)inVec[i] \
) \
) { \
__GLS_PUT_##inCategory(inoutWriter, inVec[i]); \
} \
} \
if (multiLine) __GLS_PUT_CHAR(inoutWriter, '\n'); \
__GLS_PUT_CHAR(inoutWriter, '}'); \
}
#define __GLS_PUT_TEXT_MAT(inType, inCategory) \
static void __glsWriter_put##inType##m_text( \
__GLSwriter *inoutWriter, \
const inType *inMat \
) { \
GLuint i, j; \
__GLS_PARAM_SETUP(inoutWriter); \
__GLS_PUT_CHAR(inoutWriter, '{'); \
for (i = 0 ; i < 4 ; ++i) { \
__GLS_ALLOC(inoutWriter, __GLS_NULL); \
if (i) __GLS_PUT_CHAR(inoutWriter, ','); \
__GLS_PUT_STRING(inoutWriter, "\n "); \
for (j = 0 ; j < 4 ; ++j) { \
if (j) __GLS_PUT_STRING(inoutWriter, ", "); \
__GLS_PUT_##inCategory(inoutWriter, inMat[i * 4 + j]); \
} \
} \
__GLS_PUT_STRING(inoutWriter, "\n}"); \
}
#define __GLS_PUT_TEXT_VAL(inType, inSize, inCategory) \
static void __glsWriter_put##inType##_text( \
__GLSwriter *inoutWriter, inType inVal \
) { \
__GLS_PARAM_SETUP(inoutWriter); \
__GLS_PUT_##inCategory(inoutWriter, inVal); \
}
#define __GLS_PUT_TEXT_VEC(inType, inSize, inCategory) \
static void __glsWriter_put##inType##v_text( \
__GLSwriter *inoutWriter, \
GLuint inCount, \
const inType *inVec \
) { \
GLuint i; \
const GLboolean multiLine = (GLboolean)(inCount > 4); \
__GLS_PARAM_SETUP(inoutWriter); \
__GLS_PUT_CHAR(inoutWriter, '{'); \
for (i = 0 ; i < inCount ; ++i) { \
__GLS_ALLOC(inoutWriter, __GLS_NULL); \
if (i) __GLS_PUT_CHAR(inoutWriter, ','); \
if (multiLine && !(i & 7)) { \
__GLS_PUT_STRING(inoutWriter, "\n "); \
} else if (i) { \
__GLS_PUT_CHAR(inoutWriter, ' '); \
} \
__GLS_PUT_##inCategory(inoutWriter, inVec[i]); \
} \
if (multiLine) __GLS_PUT_CHAR(inoutWriter, '\n'); \
__GLS_PUT_CHAR(inoutWriter, '}'); \
}
#define __GLS_PUT_TEXT_VECSTRIDE(inType, inSize, inCategory) \
static void __glsWriter_put##inType##vs_text( \
__GLSwriter *inoutWriter, \
GLboolean inItemSwap, \
GLint inStride1DataItems, \
GLint inStride1PadBytes, \
GLint inStride1Count, \
GLint inStride2PadBytes, \
GLint inStride2Count, \
const inType *inVec \
) { \
GLint i, j, param = 0; \
const GLboolean multiLine = (GLboolean)( \
inStride1DataItems * inStride1Count * inStride2Count > 4 \
); \
__GLS_PARAM_SETUP(inoutWriter); \
__GLS_PUT_CHAR(inoutWriter, '{'); \
if (inItemSwap) while (inStride2Count-- > 0) { \
for ( \
i = 0 ; \
i < inStride1Count ; \
++i, \
inVec = \
(const inType *)((const GLubyte *)inVec + inStride1PadBytes) \
) { \
for (j = 0 ; j < inStride1DataItems ; ++j, ++param) { \
inType val = *inVec++; \
__GLS_ALLOC(inoutWriter, __GLS_NULL); \
if (param) __GLS_PUT_CHAR(inoutWriter, ','); \
if (multiLine && !(param & 7)) { \
__GLS_PUT_STRING(inoutWriter, "\n "); \
} else if (param) { \
__GLS_PUT_CHAR(inoutWriter, ' '); \
} \
__glsSwap##inSize(&val); \
__GLS_PUT_##inCategory(inoutWriter, val); \
} \
} \
inVec = (const inType *)((const GLubyte *)inVec + inStride2PadBytes); \
} else while (inStride2Count-- > 0) { \
for ( \
i = 0 ; \
i < inStride1Count ; \
++i, \
inVec = \
(const inType *)((const GLubyte *)inVec + inStride1PadBytes) \
) { \
for (j = 0 ; j < inStride1DataItems ; ++j, ++param) { \
inType val = *inVec++; \
__GLS_ALLOC(inoutWriter, __GLS_NULL); \
if (param) __GLS_PUT_CHAR(inoutWriter, ','); \
if (multiLine && !(param & 7)) { \
__GLS_PUT_STRING(inoutWriter, "\n "); \
} else if (param) { \
__GLS_PUT_CHAR(inoutWriter, ' '); \
} \
__GLS_PUT_##inCategory(inoutWriter, val); \
} \
} \
inVec = (const inType *)((const GLubyte *)inVec + inStride2PadBytes); \
} \
if (multiLine) __GLS_PUT_CHAR(inoutWriter, '\n'); \
__GLS_PUT_CHAR(inoutWriter, '}'); \
}
#define __GLS_PUT_UNSIGNED_INT(inoutWriter, inVal) \
__GLS_PUT_NUM(inoutWriter, "%u", inVal);
#if __GLS_SPRINTF_INT64
#define __GLS_PUT_UNSIGNED_LONG(inoutWriter, inVal) \
__GLS_PUT_NUM(inoutWriter, __GLS_OUT_FORMAT_INT64U, inVal);
#elif defined(__GLS_INT64U_TO_STR)
#define __GLS_PUT_UNSIGNED_LONG(inoutWriter, inVal) \
inoutWriter->bufPtr += \
strlen(__GLS_INT64U_TO_STR(inVal, (char *)inoutWriter->bufPtr));
#else /* !__GLS_SPRINTF_INT64 && !defined(__GLS_INT64U_TO_STR) */
#define __GLS_PUT_UNSIGNED_LONG(inoutWriter, inVal) \
__GLS_PUT_HEX16(inoutWriter, inVal);
#endif /* __GLS_SPRINTF_INT64 */
__GLS_FORWARD static GLboolean __glsWriter_putGLbooleanVal_text(
__GLSwriter *inoutWriter, GLboolean inVal
);
__GLS_FORWARD static GLboolean __glsWriter_putGLenumVal_text(
__GLSwriter *inoutWriter, GLenum inVal
);
__GLS_FORWARD static GLboolean __glsWriter_putGLstencilOpVal_text(
__GLSwriter *inoutWriter, GLenum inVal
);
__GLS_FORWARD static GLboolean __glsWriter_putGLtextureComponentCountVal_text(
__GLSwriter *inoutWriter, GLint inVal
);
static void __glsWriter_putBitfield_text(
__GLSwriter *inoutWriter,
GLbitfield inBits,
GLint inCount,
const GLubyte *const inString[],
const GLbitfield inVal[]
) {
GLint i, putCount;
__GLS_PARAM_SETUP(inoutWriter);
for (i = 0 ; i < inCount ; ++i) {
if (inBits == inVal[i]) {
__GLS_PUT_STRING(inoutWriter, inString[i]);
return;
}
}
for (putCount = i = 0 ; i < inCount ; ++i) {
if (inBits & inVal[i]) {
inBits &= ~inVal[i];
__GLS_ALLOC(inoutWriter, __GLS_NULL);
if (putCount++) __GLS_PUT_STRING(inoutWriter, " | ");
__GLS_PUT_STRING(inoutWriter, inString[i]);
}
}
if (inBits) {
__GLS_ALLOC(inoutWriter, __GLS_NULL);
if (putCount) __GLS_PUT_STRING(inoutWriter, " | ");
__GLS_PUT_HEX8(inoutWriter, inBits);
}
}
static GLboolean __glsWriter_putGLSenumVal_text(
__GLSwriter *inoutWriter, GLSenum inVal
) {
const GLint page = __GLS_ENUM_PAGE(inVal);
const GLint offset = __GLS_ENUM_OFFSET(inVal);
if (
page < __GLS_ENUM_PAGE_COUNT &&
offset < __glsEnumStringCount[page] &&
__glsEnumString[page][offset]
) {
__GLS_PUT_STRING(inoutWriter, __glsEnumString[page][offset]);
return GL_TRUE;
} else {
return GL_FALSE;
}
}
static GLboolean __glsWriter_putGLSenumParamVal_text(
__GLSwriter *inoutWriter, GLSenum inParam, GLSenum inVal
) {
switch (inParam) {
case GLS_DISPLAY_FORMAT:
return __glsWriter_putGLSenumVal_text(inoutWriter, inVal);
case GLS_DOUBLEBUFFER:
case GLS_INVISIBLE:
case GLS_STEREO:
case GLS_TILEABLE:
case GLS_TRANSPARENT:
return (
__glsWriter_putGLbooleanVal_text(inoutWriter, (GLboolean)inVal)
);
default:
return GL_FALSE;
}
}
static GLboolean __glsWriter_putGLblendingFactorVal_text(
__GLSwriter *inoutWriter, GLenum inVal
) {
switch (inVal) {
case GL_ZERO:
__GLS_PUT_STRING(inoutWriter, "GL_ZERO");
return GL_TRUE;
case GL_ONE:
__GLS_PUT_STRING(inoutWriter, "GL_ONE");
return GL_TRUE;
default:
return __glsWriter_putGLenumVal_text(inoutWriter, inVal);
}
}
static GLboolean __glsWriter_putGLbooleanVal_text(
__GLSwriter *inoutWriter, GLboolean inVal
) {
switch (inVal) {
case GL_FALSE:
__GLS_PUT_STRING(inoutWriter, "GL_FALSE");
return GL_TRUE;
case GL_TRUE:
__GLS_PUT_STRING(inoutWriter, "GL_TRUE");
return GL_TRUE;
default:
return GL_FALSE;
}
}
static GLboolean __glsWriter_putGLdrawBufferModeVal_text(
__GLSwriter *inoutWriter, GLenum inVal
) {
if (inVal) {
return __glsWriter_putGLenumVal_text(inoutWriter, inVal);
} else {
__GLS_PUT_STRING(inoutWriter, "GL_NONE");
return GL_TRUE;
}
}
static GLboolean __glsWriter_putGLenumParamVal_text(
__GLSwriter *inoutWriter, GLenum inParam, GLenum inVal
) {
switch (inParam) {
case GL_FOG_MODE:
case GL_TEXTURE_ENV_MODE:
case GL_TEXTURE_GEN_MODE:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
#if __GL_EXT_convolution
case GL_CONVOLUTION_BORDER_MODE_EXT:
#endif /* __GL_EXT_convolution */
#if __GL_EXT_texture3D
case GL_TEXTURE_WRAP_R_EXT:
#endif /* __GL_EXT_texture3D */
#if __GL_SGIS_component_select
case GL_TEXTURE_SS_SELECT_SGIS:
case GL_TEXTURE_SSSS_SELECT_SGIS:
#endif /* __GL_SGIS_component_select */
#if __GL_SGIS_detail_texture
case GL_DETAIL_TEXTURE_MODE_SGIS:
#endif /* __GL_SGIS_detail_texture */
#if __GL_SGIS_texture4D
case GL_TEXTURE_WRAP_Q_SGIS:
#endif /* __GL_SGIS_texture4D */
#if __GL_SGIX_sprite
case GL_SPRITE_MODE_SGIX:
#endif /* __GL_SGIX_sprite */
return __glsWriter_putGLenumVal_text(inoutWriter, inVal);
case GL_LIGHT_MODEL_LOCAL_VIEWER:
case GL_LIGHT_MODEL_TWO_SIDE:
case GL_MAP_COLOR:
case GL_MAP_STENCIL:
case GL_PACK_LSB_FIRST:
case GL_PACK_SWAP_BYTES:
case GL_UNPACK_LSB_FIRST:
case GL_UNPACK_SWAP_BYTES:
return (
__glsWriter_putGLbooleanVal_text(inoutWriter, (GLboolean)inVal)
);
default:
return GL_FALSE;
}
}
static GLboolean __glsWriter_putGLenumVal_text(
__GLSwriter *inoutWriter, GLenum inVal
) {
const GLint page = __GL_ENUM_PAGE(inVal);
const GLint offset = __GL_ENUM_OFFSET(inVal);
if (
page < __GL_ENUM_PAGE_COUNT &&
offset < __glEnumStringCount[page] &&
__glEnumString[page][offset]
) {
__GLS_PUT_STRING(inoutWriter, __glEnumString[page][offset]);
return GL_TRUE;
} else {
return GL_FALSE;
}
}
static GLboolean __glsWriter_putGLstencilOpVal_text(
__GLSwriter *inoutWriter, GLenum inVal
) {
if (inVal) {
return __glsWriter_putGLenumVal_text(inoutWriter, inVal);
} else {
__GLS_PUT_STRING(inoutWriter, "GL_ZERO");
return GL_TRUE;
}
}
static GLboolean __glsWriter_putGLtextureComponentCountVal_text(
__GLSwriter *inoutWriter, GLint inVal
) {
if (inVal > 4) {
return __glsWriter_putGLenumVal_text(inoutWriter, inVal);
} else {
return GL_FALSE;
}
}
typedef GLuint GLuinthex;
typedef GLulong GLulonghex;
typedef GLushort GLushorthex;
__GLS_PUT_TEXT(GLbyte, 1, INT)
__GLS_PUT_TEXT(GLubyte, 1, UNSIGNED_INT)
__GLS_PUT_TEXT(GLshort, 2, INT)
__GLS_PUT_TEXT(GLushort, 2, UNSIGNED_INT)
__GLS_PUT_TEXT(GLint, 4, INT)
__GLS_PUT_TEXT(GLuint, 4, UNSIGNED_INT)
__GLS_PUT_TEXT(GLfloat, 4, FLOAT)
__GLS_PUT_TEXT(GLdouble, 8, DOUBLE)
__GLS_PUT_TEXT_ENUM(GLfloat, GLenum, FLOAT)
__GLS_PUT_TEXT_ENUM(GLdouble, GLenum, DOUBLE)
__GLS_PUT_TEXT_ENUM(GLint, GLenum, INT)
__GLS_PUT_TEXT_ENUM_VAL(GLint, GLSenum, INT)
__GLS_PUT_TEXT_MAT(GLfloat, FLOAT11)
__GLS_PUT_TEXT_MAT(GLdouble, DOUBLE17)
__GLS_PUT_TEXT_VAL(GLlong, 8, LONG)
__GLS_PUT_TEXT_VAL(GLuinthex, 4, HEX8)
__GLS_PUT_TEXT_VAL(GLulong, 8, UNSIGNED_LONG)
__GLS_PUT_TEXT_VAL(GLulonghex, 8, HEX16)
__GLS_PUT_TEXT_VAL(GLushorthex, 2, HEX4)
__GLS_PUT_TEXT_VEC(GLboolean, 1, BOOLEAN)
__GLS_PUT_TEXT_VEC(GLlong, 8, LONG)
__GLS_PUT_TEXT_VEC(GLulong, 8, UNSIGNED_LONG)
__GLS_PUT_TEXT_VECSTRIDE(GLboolean, 1, BOOLEAN)
/******************************************************************************
Writers
******************************************************************************/
static GLboolean __glsWriter_beginCommand_text(
__GLSwriter *inoutWriter, GLSopcode inOpcode, size_t inByteCount
) {
if (!inoutWriter || inoutWriter->error) return GL_FALSE;
__GLS_ALLOC(inoutWriter, GL_FALSE);
inoutWriter->commandOpcode = inOpcode;
inoutWriter->paramCount = 0;
__GLS_PUT_STRING(inoutWriter, __glsOpcodeString[__glsMapOpcode(inOpcode)]);
__GLS_PUT_CHAR(inoutWriter, '(');
return GL_TRUE;
}
static void __glsWriter_endCommand_text(__GLSwriter *inoutWriter) {
__GLS_ALLOC(inoutWriter, __GLS_NULL);
__GLS_PUT_CHAR(inoutWriter, ')');
__GLS_PUT_CHAR(inoutWriter, ';');
__GLS_PUT_CHAR(inoutWriter, '\n');
}
static void __glsWriter_nextList_text(__GLSwriter *inoutWriter) {
__GLS_ALLOC(inoutWriter, __GLS_NULL);
__GLS_PUT_STRING(inoutWriter, ")(");
inoutWriter->paramCount = 0;
}
static GLboolean __glsWriter_padWordCount_text(
__GLSwriter *inoutWriter, GLboolean inCountMod2
) {
return GL_TRUE;
}
static void __glsWriter_putGLSenum_text(
__GLSwriter *inoutWriter, GLSenum inVal
) {
__GLS_PARAM_SETUP(inoutWriter);
if (!__glsWriter_putGLSenumVal_text(inoutWriter, inVal)) {
__GLS_PUT_INT(inoutWriter, inVal);
}
}
static void __glsWriter_putGLSimageFlags_text(
__GLSwriter *inoutWriter, GLbitfield inVal
) {
__glsWriter_putBitfield_text(
inoutWriter,
inVal,
__GLS_IMAGE_FLAGS_COUNT,
__glsImageFlagsString,
__glsImageFlagsVal
);
}
static void __glsWriter_putGLSopcode_text(
__GLSwriter *inoutWriter, GLSopcode inVal
) {
const GLSopcode opcode = __glsMapOpcode(inVal);
__GLS_PARAM_SETUP(inoutWriter);
if (
opcode >= __GLS_OPCODES_PER_PAGE &&
opcode < __GLS_OPCODE_COUNT &&
__glsOpcodeString[opcode]
) {
__GLS_PUT_STRING(inoutWriter, "GLS_OP_");
__GLS_PUT_STRING(inoutWriter, __glsOpcodeString[opcode]);
} else {
__GLS_PUT_INT(inoutWriter, inVal);
}
}
static void __glsWriter_putGLattribMask_text(
__GLSwriter *inoutWriter, GLbitfield inVal
) {
__glsWriter_putBitfield_text(
inoutWriter,
inVal,
__GL_ATTRIB_MASK_COUNT,
__glAttribMaskString,
__glAttribMaskVal
);
}
static void __glsWriter_putGLbitvs_text(
__GLSwriter *inoutWriter,
GLboolean inItemSwap,
GLint inItemLeftShift,
GLint inStrideDataItems,
GLint inStridePadItems,
GLint inStrideCount,
const GLubyte *inVec
) {
GLint i, param = 0;
const GLboolean multiLine = (GLboolean)(
inStrideDataItems * inStrideCount / 8 > 4
);
const GLint highShift = inItemLeftShift;
const GLint lowShift = 8 - inItemLeftShift;
GLubyte lastMask = 0xffu;
if (inStrideDataItems & 7) lastMask <<= 8 - (inStrideDataItems & 7);
inStrideDataItems = (inStrideDataItems + 7) >> 3;
inStridePadItems >>= 3;
__GLS_PARAM_SETUP(inoutWriter);
__GLS_PUT_CHAR(inoutWriter, '{');
while (inStrideCount-- > 0) {
GLubyte val;
i = inStrideDataItems;
while (i-- > 0) {
if (inItemSwap) {
val = __glsBitReverse[*inVec++];
if (inItemLeftShift) {
if (i) {
val <<= highShift;
val |= __glsBitReverse[*inVec] >> lowShift;
} else {
val = (GLubyte)((val & lastMask) << highShift);
}
} else if (!i) {
val &= lastMask;
}
} else {
val = *inVec++;
if (inItemLeftShift) {
if (i) {
val = (GLubyte)(val << highShift | *inVec >> lowShift);
} else {
val = (GLubyte)((val & lastMask) << highShift);
}
} else if (!i) {
val &= lastMask;
}
}
__GLS_ALLOC(inoutWriter, __GLS_NULL);
if (param) __GLS_PUT_CHAR(inoutWriter, ',');
if (multiLine && !(param & 7)) {
__GLS_PUT_STRING(inoutWriter, "\n ");
} else if (param) {
__GLS_PUT_CHAR(inoutWriter, ' ');
}
__GLS_PUT_HEX2(inoutWriter, val);
++param;
}
inVec += inStridePadItems;
}
if (multiLine) __GLS_PUT_CHAR(inoutWriter, '\n');
__GLS_PUT_CHAR(inoutWriter, '}');
}
static void __glsWriter_putGLblendingFactor_text(
__GLSwriter *inoutWriter, GLenum inVal
) {
__GLS_PARAM_SETUP(inoutWriter);
if (!__glsWriter_putGLblendingFactorVal_text(inoutWriter, inVal)) {
__GLS_PUT_INT(inoutWriter, inVal);
}
}
static void __glsWriter_putGLboolean_text(
__GLSwriter *inoutWriter, GLboolean inVal
) {
__GLS_PARAM_SETUP(inoutWriter);
if (!__glsWriter_putGLbooleanVal_text(inoutWriter, inVal)) {
__GLS_PUT_INT(inoutWriter, inVal);
}
}
static void __glsWriter_putGLcharv_text(
__GLSwriter *inoutWriter, GLuint inCount, const GLubyte *inString
) {
size_t count = strlen((const char *)inString);
const GLubyte *ptr = inString;
__GLS_PARAM_SETUP(inoutWriter);
__GLS_PUT_CHAR(inoutWriter, '"');
while (count-- > 0) {
__GLS_ALLOC(inoutWriter, __GLS_NULL);
if (__GLS_CHAR_IS_GRAPHIC(*ptr)) {
if (*ptr == '\\' || *ptr == '\"') *inoutWriter->bufPtr++ = '\\';
*inoutWriter->bufPtr++ = *ptr++;
} else {
__GLS_PUT_NUM(inoutWriter, "\\x%.2x", *ptr++);
}
}
__GLS_PUT_CHAR(inoutWriter, '"');
}
static void __glsWriter_putGLclearBufferMask_text(
__GLSwriter *inoutWriter, GLbitfield inVal
) {
__glsWriter_putGLattribMask_text(inoutWriter, inVal);
}
static void __glsWriter_putGLdrawBufferMode_text(
__GLSwriter *inoutWriter, GLenum inVal
) {
__GLS_PARAM_SETUP(inoutWriter);
if (!__glsWriter_putGLdrawBufferModeVal_text(inoutWriter, inVal)) {
__GLS_PUT_INT(inoutWriter, inVal);
}
}
static void __glsWriter_putGLenum_text(
__GLSwriter *inoutWriter, GLenum inVal
) {
__GLS_PARAM_SETUP(inoutWriter);
if (!__glsWriter_putGLenumVal_text(inoutWriter, inVal)) {
__GLS_PUT_INT(inoutWriter, inVal);
}
}
static void __glsWriter_putGLoutArg_text(
__GLSwriter *inoutWriter, GLuint inIndex, const GLvoid *inVal
) {
__GLScontext *const ctx = __GLS_CONTEXT;
__glsWriter_putGLulonghex_text(
inoutWriter,
(
ctx->callNesting &&
!ctx->commandFuncs[__glsMapOpcode(inoutWriter->commandOpcode)]
) ?
ctx->outArgs.vals[inIndex] :
__glsPtrToULong(inVal)
);
}
static void __glsWriter_putGLstencilOp_text(
__GLSwriter *inoutWriter, GLenum inVal
) {
__GLS_PARAM_SETUP(inoutWriter);
if (!__glsWriter_putGLstencilOpVal_text(inoutWriter, inVal)) {
__GLS_PUT_INT(inoutWriter, inVal);
}
}
static void __glsWriter_putGLtextureComponentCount_text(
__GLSwriter *inoutWriter, GLint inVal
) {
__GLS_PARAM_SETUP(inoutWriter);
if (!__glsWriter_putGLtextureComponentCountVal_text(inoutWriter, inVal)) {
__GLS_PUT_INT(inoutWriter, inVal);
}
}
/******************************************************************************
Dispatch setup
******************************************************************************/
#define __GLS_INIT_PUT_TEXT(inType) \
inoutWriter->put##inType = __glsWriter_put##inType##_text
void __glsWriter_initDispatch_text(__GLSwriter *inoutWriter) {
inoutWriter->beginCommand = __glsWriter_beginCommand_text;
inoutWriter->endCommand = __glsWriter_endCommand_text;
inoutWriter->nextList = __glsWriter_nextList_text;
inoutWriter->padWordCount = __glsWriter_padWordCount_text;
__GLS_INIT_PUT_TEXT(GLSenum);
__GLS_INIT_PUT_TEXT(GLSimageFlags);
__GLS_INIT_PUT_TEXT(GLSopcode);
__GLS_INIT_PUT_TEXT(GLattribMask);
__GLS_INIT_PUT_TEXT(GLbitvs);
__GLS_INIT_PUT_TEXT(GLblendingFactor);
__GLS_INIT_PUT_TEXT(GLboolean);
__GLS_INIT_PUT_TEXT(GLbooleanv);
__GLS_INIT_PUT_TEXT(GLbooleanvs);
__GLS_INIT_PUT_TEXT(GLbyte);
__GLS_INIT_PUT_TEXT(GLbytev);
__GLS_INIT_PUT_TEXT(GLbytevs);
__GLS_INIT_PUT_TEXT(GLcharv);
__GLS_INIT_PUT_TEXT(GLclearBufferMask);
__GLS_INIT_PUT_TEXT(GLdouble);
__GLS_INIT_PUT_TEXT(GLdoubleOrGLenum);
__GLS_INIT_PUT_TEXT(GLdoubleOrGLenumv);
__GLS_INIT_PUT_TEXT(GLdoublem);
__GLS_INIT_PUT_TEXT(GLdoublev);
__GLS_INIT_PUT_TEXT(GLdoublevs);
__GLS_INIT_PUT_TEXT(GLdrawBufferMode);
__GLS_INIT_PUT_TEXT(GLenum);
__GLS_INIT_PUT_TEXT(GLfloat);
__GLS_INIT_PUT_TEXT(GLfloatOrGLenum);
__GLS_INIT_PUT_TEXT(GLfloatOrGLenumv);
__GLS_INIT_PUT_TEXT(GLfloatm);
__GLS_INIT_PUT_TEXT(GLfloatv);
__GLS_INIT_PUT_TEXT(GLfloatvs);
__GLS_INIT_PUT_TEXT(GLint);
__GLS_INIT_PUT_TEXT(GLintOrGLSenum);
__GLS_INIT_PUT_TEXT(GLintOrGLenum);
__GLS_INIT_PUT_TEXT(GLintOrGLenumv);
__GLS_INIT_PUT_TEXT(GLintv);
__GLS_INIT_PUT_TEXT(GLintvs);
__GLS_INIT_PUT_TEXT(GLlong);
__GLS_INIT_PUT_TEXT(GLlongv);
__GLS_INIT_PUT_TEXT(GLoutArg);
__GLS_INIT_PUT_TEXT(GLshort);
__GLS_INIT_PUT_TEXT(GLshortv);
__GLS_INIT_PUT_TEXT(GLshortvs);
__GLS_INIT_PUT_TEXT(GLstencilOp);
__GLS_INIT_PUT_TEXT(GLtextureComponentCount);
__GLS_INIT_PUT_TEXT(GLubyte);
__GLS_INIT_PUT_TEXT(GLubytev);
__GLS_INIT_PUT_TEXT(GLubytevs);
__GLS_INIT_PUT_TEXT(GLuint);
__GLS_INIT_PUT_TEXT(GLuinthex);
__GLS_INIT_PUT_TEXT(GLuintv);
__GLS_INIT_PUT_TEXT(GLuintvs);
__GLS_INIT_PUT_TEXT(GLulong);
__GLS_INIT_PUT_TEXT(GLulonghex);
__GLS_INIT_PUT_TEXT(GLulongv);
__GLS_INIT_PUT_TEXT(GLushort);
__GLS_INIT_PUT_TEXT(GLushorthex);
__GLS_INIT_PUT_TEXT(GLushortv);
__GLS_INIT_PUT_TEXT(GLushortvs);
}
Reference in a new issue Copy permalink