/*
** Copyright 1992, 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 <windows.h>
#include <stdarg.h>
#include <GL/gl.h>
#include "conform.h"
#include "pathdata.h"
#include "path.h"
#include "util.h"
#include "utils.h"


struct _enumInfoRec {
    char name[40];
    long value;
} enumInfo[] = {
    {
	"GL_2_BYTES", GL_2_BYTES
    },
    {
	"GL_3_BYTES", GL_3_BYTES
    },
    {
	"GL_4_BYTES", GL_4_BYTES
    },
    {
	"GL_2D", GL_2D
    },
    {
	"GL_3D", GL_3D
    },
    {
	"GL_3D_COLOR", GL_3D_COLOR
    },
    {
	"GL_3D_COLOR_TEXTURE", GL_3D_COLOR_TEXTURE
    },
    {
	"GL_4D_COLOR_TEXTURE", GL_4D_COLOR_TEXTURE
    },
    {
	"GL_ACCUM", GL_ACCUM
    },
    {
	"GL_ACCUM_ALPHA_BITS", GL_ACCUM_ALPHA_BITS
    },
    {
	"GL_ACCUM_BLUE_BITS", GL_ACCUM_BLUE_BITS
    },
    {
	"GL_ACCUM_CLEAR_VALUE", GL_ACCUM_CLEAR_VALUE
    },
    {
	"GL_ACCUM_GREEN_BITS", GL_ACCUM_GREEN_BITS
    },
    {
	"GL_ACCUM_RED_BITS", GL_ACCUM_RED_BITS
    },
    {
	"GL_ADD", GL_ADD
    },
    {
	"GL_ALL_ATTRIB_BITS", GL_ALL_ATTRIB_BITS
    },
    {
	"GL_ALPHA", GL_ALPHA
    },
    {
	"GL_ALPHA_BIAS", GL_ALPHA_BIAS
    },
    {
	"GL_ALPHA_BITS", GL_ALPHA_BITS
    },
    {
	"GL_ALPHA_SCALE", GL_ALPHA_SCALE
    },
    {
	"GL_ALPHA_TEST", GL_ALPHA_TEST
    },
    {
	"GL_ALPHA_TEST_FUNC", GL_ALPHA_TEST_FUNC
    },
    {
	"GL_ALPHA_TEST_REF", GL_ALPHA_TEST_REF
    },
    {
	"GL_ALWAYS", GL_ALWAYS
    },
    {
	"GL_AMBIENT", GL_AMBIENT
    },
    {
	"GL_AMBIENT_AND_DIFFUSE", GL_AMBIENT_AND_DIFFUSE
    },
    {
	"GL_AND", GL_AND
    },
    {
	"GL_AND_INVERTED", GL_AND_INVERTED
    },
    {
	"GL_AND_REVERSE", GL_AND_REVERSE
    },
    {
	"GL_ATTRIB_STACK_DEPTH", GL_ATTRIB_STACK_DEPTH
    },
    {
	"GL_AUTO_NORMAL", GL_AUTO_NORMAL
    },
    {
	"GL_AUX_BUFFERS", GL_AUX_BUFFERS
    },
    {
	"GL_AUX0", GL_AUX0
    },
    {
	"GL_AUX1", GL_AUX1
    },
    {
	"GL_AUX2", GL_AUX2
    },
    {
	"GL_AUX3", GL_AUX3
    },
    {
	"GL_BACK", GL_BACK
    },
    {
	"GL_BACK_LEFT", GL_BACK_LEFT
    },
    {
	"GL_BACK_RIGHT", GL_BACK_RIGHT
    },
    {
	"GL_BITMAP", GL_BITMAP
    },
    {
	"GL_BITMAP_TOKEN", GL_BITMAP_TOKEN
    },
    {
	"GL_BLEND", GL_BLEND
    },
    {
	"GL_BLEND_DST", GL_BLEND_DST
    },
    {
	"GL_BLEND_SRC", GL_BLEND_SRC
    },
    {
	"GL_BLUE", GL_BLUE
    },
    {
	"GL_BLUE_BIAS", GL_BLUE_BIAS
    },
    {
	"GL_BLUE_BITS", GL_BLUE_BITS
    },
    {
	"GL_BLUE_SCALE", GL_BLUE_SCALE
    },
    {
	"GL_BYTE", GL_BYTE
    },
    {
	"GL_CCW", GL_CCW
    },
    {
	"GL_CLAMP", GL_CLAMP
    },
    {
	"GL_CLEAR", GL_CLEAR
    },
    {
	"GL_CLIP_PLANE0", GL_CLIP_PLANE0
    },
    {
	"GL_CLIP_PLANE1", GL_CLIP_PLANE1
    },
    {
	"GL_CLIP_PLANE2", GL_CLIP_PLANE2
    },
    {
	"GL_CLIP_PLANE3", GL_CLIP_PLANE3
    },
    {
	"GL_CLIP_PLANE4", GL_CLIP_PLANE4
    },
    {
	"GL_CLIP_PLANE5", GL_CLIP_PLANE5
    },
    {
	"GL_COEFF", GL_COEFF
    },
    {
	"GL_COLOR", GL_COLOR
    },
    {
	"GL_COLOR_CLEAR_VALUE", GL_COLOR_CLEAR_VALUE
    },
    {
	"GL_COLOR_INDEX", GL_COLOR_INDEX
    },
    {
	"GL_COLOR_INDEXES", GL_COLOR_INDEXES
    },
    {
	"GL_COLOR_MATERIAL", GL_COLOR_MATERIAL
    },
    {
	"GL_COLOR_MATERIAL_FACE", GL_COLOR_MATERIAL_FACE
    },
    {
	"GL_COLOR_MATERIAL_PARAMETER", GL_COLOR_MATERIAL_PARAMETER
    },
    {
	"GL_COLOR_WRITEMASK", GL_COLOR_WRITEMASK
    },
    {
	"GL_COMPILE", GL_COMPILE
    },
    {
	"GL_COMPILE_AND_EXECUTE", GL_COMPILE_AND_EXECUTE
    },
    {
	"GL_CONSTANT_ATTENUATION", GL_CONSTANT_ATTENUATION
    },
    {
	"GL_COPY", GL_COPY
    },
    {
	"GL_COPY_INVERTED", GL_COPY_INVERTED
    },
    {
	"GL_COPY_PIXEL_TOKEN", GL_COPY_PIXEL_TOKEN
    },
    {
	"GL_CULL_FACE", GL_CULL_FACE
    },
    {
	"GL_CULL_FACE_MODE", GL_CULL_FACE_MODE
    },
    {
	"GL_CURRENT_COLOR", GL_CURRENT_COLOR
    },
    {
	"GL_CURRENT_INDEX", GL_CURRENT_INDEX
    },
    {
	"GL_CURRENT_NORMAL", GL_CURRENT_NORMAL
    },
    {
	"GL_CURRENT_RASTER_COLOR", GL_CURRENT_RASTER_COLOR
    },
    {
	"GL_CURRENT_RASTER_INDEX", GL_CURRENT_RASTER_INDEX
    },
    {
	"GL_CURRENT_RASTER_POSITION", GL_CURRENT_RASTER_POSITION
    },
    {
	"GL_CURRENT_RASTER_POSITION_VALID", GL_CURRENT_RASTER_POSITION_VALID
    },
    {
	"GL_CURRENT_RASTER_TEXTURE_COORDS", GL_CURRENT_RASTER_TEXTURE_COORDS
    },
    {
	"GL_CURRENT_TEXTURE_COORDS", GL_CURRENT_TEXTURE_COORDS
    },
    {
	"GL_CW", GL_CW
    },
    {
	"GL_DECAL", GL_DECAL
    },
    {
	"GL_DECR", GL_DECR
    },
    {
	"GL_DEPTH", GL_DEPTH
    },
    {
	"GL_DEPTH_BIAS", GL_DEPTH_BIAS
    },
    {
	"GL_DEPTH_BITS", GL_DEPTH_BITS
    },
    {
	"GL_DEPTH_CLEAR_VALUE", GL_DEPTH_CLEAR_VALUE
    },
    {
	"GL_DEPTH_COMPONENT", GL_DEPTH_COMPONENT
    },
    {
	"GL_DEPTH_FUNC", GL_DEPTH_FUNC
    },
    {
	"GL_DEPTH_RANGE", GL_DEPTH_RANGE
    },
    {
	"GL_DEPTH_SCALE", GL_DEPTH_SCALE
    },
    {
	"GL_DEPTH_TEST", GL_DEPTH_TEST
    },
    {
	"GL_DEPTH_WRITEMASK", GL_DEPTH_WRITEMASK
    },
    {
	"GL_DIFFUSE", GL_DIFFUSE
    },
    {
	"GL_DITHER", GL_DITHER
    },
    {
	"GL_DOMAIN", GL_DOMAIN
    },
    {
	"GL_DONT_CARE", GL_DONT_CARE
    },
    {
	"GL_DOUBLEBUFFER", GL_DOUBLEBUFFER
    },
    {
	"GL_DRAW_BUFFER", GL_DRAW_BUFFER
    },
    {
	"GL_DRAW_PIXEL_TOKEN", GL_DRAW_PIXEL_TOKEN
    },
    {
	"GL_DST_ALPHA", GL_DST_ALPHA
    },
    {
	"GL_DST_COLOR", GL_DST_COLOR
    },
    {
	"GL_EDGE_FLAG", GL_EDGE_FLAG
    },
    {
	"GL_EMISSION", GL_EMISSION
    },
    {
	"GL_EQUAL", GL_EQUAL
    },
    {
	"GL_EQUIV", GL_EQUIV
    },
    {
	"GL_EXP", GL_EXP
    },
    {
	"GL_EXP2", GL_EXP2
    },
    {
	"GL_EXTENSIONS", GL_EXTENSIONS
    },
    {
	"GL_EYE_LINEAR", GL_EYE_LINEAR
    },
    {
	"GL_EYE_PLANE", GL_EYE_PLANE
    },
    {
	"GL_FASTEST", GL_FASTEST
    },
    {
	"GL_FEEDBACK", GL_FEEDBACK
    },
    {
	"GL_FILL", GL_FILL
    },
    {
	"GL_FLAT", GL_FLAT
    },
    {
	"GL_FLOAT", GL_FLOAT
    },
    {
	"GL_FOG", GL_FOG
    },
    {
	"GL_FOG_COLOR", GL_FOG_COLOR
    },
    {
	"GL_FOG_DENSITY", GL_FOG_DENSITY
    },
    {
	"GL_FOG_END", GL_FOG_END
    },
    {
	"GL_FOG_HINT", GL_FOG_HINT
    },
    {
	"GL_FOG_INDEX", GL_FOG_INDEX
    },
    {
	"GL_FOG_MODE", GL_FOG_MODE
    },
    {
	"GL_FOG_START", GL_FOG_START
    },
    {
	"GL_FRONT", GL_FRONT
    },
    {
	"GL_FRONT_AND_BACK", GL_FRONT_AND_BACK
    },
    {
	"GL_FRONT_FACE", GL_FRONT_FACE
    },
    {
	"GL_FRONT_LEFT", GL_FRONT_LEFT
    },
    {
	"GL_FRONT_RIGHT", GL_FRONT_RIGHT
    },
    {
	"GL_GEQUAL", GL_GEQUAL
    },
    {
	"GL_GREATER", GL_GREATER
    },
    {
	"GL_GREEN", GL_GREEN
    },
    {
	"GL_GREEN_BIAS", GL_GREEN_BIAS
    },
    {
	"GL_GREEN_BITS", GL_GREEN_BITS
    },
    {
	"GL_GREEN_SCALE", GL_GREEN_SCALE
    },
    {
	"GL_INCR", GL_INCR
    },
    {
	"GL_INDEX_BITS", GL_INDEX_BITS
    },
    {
	"GL_INDEX_CLEAR_VALUE", GL_INDEX_CLEAR_VALUE
    },
    {
	"GL_INDEX_MODE", GL_INDEX_MODE
    },
    {
	"GL_INDEX_OFFSET", GL_INDEX_OFFSET
    },
    {
	"GL_INDEX_SHIFT", GL_INDEX_SHIFT
    },
    {
	"GL_INDEX_WRITEMASK", GL_INDEX_WRITEMASK
    },
    {
	"GL_INT", GL_INT
    },
    {
	"GL_INVALID_ENUM", GL_INVALID_ENUM
    },
    {
	"GL_INVALID_OPERATION", GL_INVALID_OPERATION
    },
    {
	"GL_INVALID_VALUE", GL_INVALID_VALUE
    },
    {
	"GL_INVERT", GL_INVERT
    },
    {
	"GL_KEEP", GL_KEEP
    },
    {
	"GL_LEFT", GL_LEFT
    },
    {
	"GL_LEQUAL", GL_LEQUAL
    },
    {
	"GL_LESS", GL_LESS
    },
    {
	"GL_LIGHT_MODEL_AMBIENT", GL_LIGHT_MODEL_AMBIENT
    },
    {
	"GL_LIGHT_MODEL_LOCAL_VIEWER", GL_LIGHT_MODEL_LOCAL_VIEWER
    },
    {
	"GL_LIGHT_MODEL_TWO_SIDE", GL_LIGHT_MODEL_TWO_SIDE
    },
    {
	"GL_LIGHT0", GL_LIGHT0
    },
    {
	"GL_LIGHT1", GL_LIGHT1
    },
    {
	"GL_LIGHT2", GL_LIGHT2
    },
    {
	"GL_LIGHT3", GL_LIGHT3
    },
    {
	"GL_LIGHT4", GL_LIGHT4
    },
    {
	"GL_LIGHT5", GL_LIGHT5
    },
    {
	"GL_LIGHT6", GL_LIGHT6
    },
    {
	"GL_LIGHT7", GL_LIGHT7
    },
    {
	"GL_LIGHTING", GL_LIGHTING
    },
    {
	"GL_LINE", GL_LINE
    },
    {
	"GL_LINE_LOOP", GL_LINE_LOOP
    },
    {
	"GL_LINE_RESET_TOKEN", GL_LINE_RESET_TOKEN
    },
    {
	"GL_LINE_SMOOTH", GL_LINE_SMOOTH
    },
    {
	"GL_LINE_SMOOTH_HINT", GL_LINE_SMOOTH_HINT
    },
    {
	"GL_LINE_STIPPLE", GL_LINE_STIPPLE
    },
    {
	"GL_LINE_STIPPLE_PATTERN", GL_LINE_STIPPLE_PATTERN
    },
    {
	"GL_LINE_STIPPLE_REPEAT", GL_LINE_STIPPLE_REPEAT
    },
    {
	"GL_LINE_STRIP", GL_LINE_STRIP
    },
    {
	"GL_LINE_TOKEN", GL_LINE_TOKEN
    },
    {
	"GL_LINE_WIDTH", GL_LINE_WIDTH
    },
    {
	"GL_LINE_WIDTH_GRANULARITY", GL_LINE_WIDTH_GRANULARITY
    },
    {
	"GL_LINE_WIDTH_RANGE", GL_LINE_WIDTH_RANGE
    },
    {
	"GL_LINEAR", GL_LINEAR
    },
    {
	"GL_LINEAR_ATTENUATION", GL_LINEAR_ATTENUATION
    },
    {
	"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST
    },
    {
	"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR
    },
    {
	"GL_LINES", GL_LINES
    },
    {
	"GL_LIST_BASE", GL_LIST_BASE
    },
    {
	"GL_LIST_INDEX", GL_LIST_INDEX
    },
    {
	"GL_LIST_MODE", GL_LIST_MODE
    },
    {
	"GL_LOAD", GL_LOAD
    },
    {
	"GL_LOGIC_OP", GL_LOGIC_OP
    },
    {
	"GL_LOGIC_OP_MODE", GL_LOGIC_OP_MODE
    },
    {
	"GL_LUMINANCE", GL_LUMINANCE
    },
    {
	"GL_LUMINANCE_ALPHA", GL_LUMINANCE_ALPHA
    },
    {
	"GL_MAP_COLOR", GL_MAP_COLOR
    },
    {
	"GL_MAP_STENCIL", GL_MAP_STENCIL
    },
    {
	"GL_MAP1_COLOR_4", GL_MAP1_COLOR_4
    },
    {
	"GL_MAP1_GRID_DOMAIN", GL_MAP1_GRID_DOMAIN
    },
    {
	"GL_MAP1_GRID_SEGMENTS", GL_MAP1_GRID_SEGMENTS
    },
    {
	"GL_MAP1_INDEX", GL_MAP1_INDEX
    },
    {
	"GL_MAP1_NORMAL", GL_MAP1_NORMAL
    },
    {
	"GL_MAP1_TEXTURE_COORD_1", GL_MAP1_TEXTURE_COORD_1
    },
    {
	"GL_MAP1_TEXTURE_COORD_2", GL_MAP1_TEXTURE_COORD_2
    },
    {
	"GL_MAP1_TEXTURE_COORD_3", GL_MAP1_TEXTURE_COORD_3
    },
    {
	"GL_MAP1_TEXTURE_COORD_4", GL_MAP1_TEXTURE_COORD_4
    },
    {
	"GL_MAP1_VERTEX_3", GL_MAP1_VERTEX_3
    },
    {
	"GL_MAP1_VERTEX_4", GL_MAP1_VERTEX_4
    },
    {
	"GL_MAP2_COLOR_4", GL_MAP2_COLOR_4
    },
    {
	"GL_MAP2_GRID_DOMAIN", GL_MAP2_GRID_DOMAIN
    },
    {
	"GL_MAP2_GRID_SEGMENTS", GL_MAP2_GRID_SEGMENTS
    },
    {
	"GL_MAP2_INDEX", GL_MAP2_INDEX
    },
    {
	"GL_MAP2_NORMAL", GL_MAP2_NORMAL
    },
    {
	"GL_MAP2_TEXTURE_COORD_1", GL_MAP2_TEXTURE_COORD_1
    },
    {
	"GL_MAP2_TEXTURE_COORD_2", GL_MAP2_TEXTURE_COORD_2
    },
    {
	"GL_MAP2_TEXTURE_COORD_3", GL_MAP2_TEXTURE_COORD_3
    },
    {
	"GL_MAP2_TEXTURE_COORD_4", GL_MAP2_TEXTURE_COORD_4
    },
    {
	"GL_MAP2_VERTEX_3", GL_MAP2_VERTEX_3
    },
    {
	"GL_MAP2_VERTEX_4", GL_MAP2_VERTEX_4
    },
    {
	"GL_MATRIX_MODE", GL_MATRIX_MODE
    },
    {
	"GL_MAX_ATTRIB_STACK_DEPTH", GL_MAX_ATTRIB_STACK_DEPTH
    },
    {
	"GL_MAX_CLIP_PLANES", GL_MAX_CLIP_PLANES
    },
    {
	"GL_MAX_EVAL_ORDER", GL_MAX_EVAL_ORDER
    },
    {
	"GL_MAX_LIGHTS", GL_MAX_LIGHTS
    },
    {
	"GL_MAX_LIST_NESTING", GL_MAX_LIST_NESTING
    },
    {
	"GL_MAX_MODELVIEW_STACK_DEPTH", GL_MAX_MODELVIEW_STACK_DEPTH
    },
    {
	"GL_MAX_NAME_STACK_DEPTH", GL_MAX_NAME_STACK_DEPTH
    },
    {
	"GL_MAX_PIXEL_MAP_TABLE", GL_MAX_PIXEL_MAP_TABLE
    },
    {
	"GL_MAX_PROJECTION_STACK_DEPTH", GL_MAX_PROJECTION_STACK_DEPTH
    },
    {
	"GL_MAX_TEXTURE_SIZE", GL_MAX_TEXTURE_SIZE
    },
    {
	"GL_MAX_TEXTURE_STACK_DEPTH", GL_MAX_TEXTURE_STACK_DEPTH
    },
    {
	"GL_MAX_VIEWPORT_DIMS", GL_MAX_VIEWPORT_DIMS
    },
    {
	"GL_MODELVIEW", GL_MODELVIEW
    },
    {
	"GL_MODELVIEW_MATRIX", GL_MODELVIEW_MATRIX
    },
    {
	"GL_MODELVIEW_STACK_DEPTH", GL_MODELVIEW_STACK_DEPTH
    },
    {
	"GL_MODULATE", GL_MODULATE
    },
    {
	"GL_MULT", GL_MULT
    },
    {
	"GL_NAME_STACK_DEPTH", GL_NAME_STACK_DEPTH
    },
    {
	"GL_NAND", GL_NAND
    },
    {
	"GL_NEAREST", GL_NEAREST
    },
    {
	"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR
    },
    {
	"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST
    },
    {
	"GL_NEVER", GL_NEVER
    },
    {
	"GL_NICEST", GL_NICEST
    },
    {
	"GL_NONE", GL_NONE
    },
    {
	"GL_NOOP", GL_NOOP
    },
    {
	"GL_NOR", GL_NOR
    },
    {
	"GL_NORMALIZE", GL_NORMALIZE
    },
    {
	"GL_NOTEQUAL", GL_NOTEQUAL
    },
    {
	"GL_OBJECT_LINEAR", GL_OBJECT_LINEAR
    },
    {
	"GL_OBJECT_PLANE", GL_OBJECT_PLANE
    },
    {
	"GL_ONE", GL_ONE
    },
    {
	"GL_ONE_MINUS_DST_ALPHA", GL_ONE_MINUS_DST_ALPHA
    },
    {
	"GL_ONE_MINUS_DST_COLOR", GL_ONE_MINUS_DST_COLOR
    },
    {
	"GL_ONE_MINUS_SRC_ALPHA", GL_ONE_MINUS_SRC_ALPHA
    },
    {
	"GL_ONE_MINUS_SRC_COLOR", GL_ONE_MINUS_SRC_COLOR
    },
    {
	"GL_OR", GL_OR
    },
    {
	"GL_OR_INVERTED", GL_OR_INVERTED
    },
    {
	"GL_OR_REVERSE", GL_OR_REVERSE
    },
    {
	"GL_ORDER", GL_ORDER
    },
    {
	"GL_OUT_OF_MEMORY", GL_OUT_OF_MEMORY
    },
    {
	"GL_PACK_ALIGNMENT", GL_PACK_ALIGNMENT
    },
    {
	"GL_PACK_LSB_FIRST", GL_PACK_LSB_FIRST
    },
    {
	"GL_PACK_ROW_LENGTH", GL_PACK_ROW_LENGTH
    },
    {
	"GL_PACK_SKIP_PIXELS", GL_PACK_SKIP_PIXELS
    },
    {
	"GL_PACK_SKIP_ROWS", GL_PACK_SKIP_ROWS
    },
    {
	"GL_PACK_SWAP_BYTES", GL_PACK_SWAP_BYTES
    },
    {
	"GL_PASS_THROUGH_TOKEN", GL_PASS_THROUGH_TOKEN
    },
    {
	"GL_PERSPECTIVE_CORRECTION_HINT", GL_PERSPECTIVE_CORRECTION_HINT
    },
    {
	"GL_PIXEL_MAP_A_TO_A", GL_PIXEL_MAP_A_TO_A
    },
    {
	"GL_PIXEL_MAP_A_TO_A_SIZE", GL_PIXEL_MAP_A_TO_A_SIZE
    },
    {
	"GL_PIXEL_MAP_B_TO_B", GL_PIXEL_MAP_B_TO_B
    },
    {
	"GL_PIXEL_MAP_B_TO_B_SIZE", GL_PIXEL_MAP_B_TO_B_SIZE
    },
    {
	"GL_PIXEL_MAP_G_TO_G", GL_PIXEL_MAP_G_TO_G
    },
    {
	"GL_PIXEL_MAP_G_TO_G_SIZE", GL_PIXEL_MAP_G_TO_G_SIZE
    },
    {
	"GL_PIXEL_MAP_I_TO_A", GL_PIXEL_MAP_I_TO_A
    },
    {
	"GL_PIXEL_MAP_I_TO_A_SIZE", GL_PIXEL_MAP_I_TO_A_SIZE
    },
    {
	"GL_PIXEL_MAP_I_TO_B", GL_PIXEL_MAP_I_TO_B
    },
    {
	"GL_PIXEL_MAP_I_TO_B_SIZE", GL_PIXEL_MAP_I_TO_B_SIZE
    },
    {
	"GL_PIXEL_MAP_I_TO_G", GL_PIXEL_MAP_I_TO_G
    },
    {
	"GL_PIXEL_MAP_I_TO_G_SIZE", GL_PIXEL_MAP_I_TO_G_SIZE
    },
    {
	"GL_PIXEL_MAP_I_TO_I", GL_PIXEL_MAP_I_TO_I
    },
    {
	"GL_PIXEL_MAP_I_TO_I_SIZE", GL_PIXEL_MAP_I_TO_I_SIZE
    },
    {
	"GL_PIXEL_MAP_I_TO_R", GL_PIXEL_MAP_I_TO_R
    },
    {
	"GL_PIXEL_MAP_I_TO_R_SIZE", GL_PIXEL_MAP_I_TO_R_SIZE
    },
    {
	"GL_PIXEL_MAP_R_TO_R", GL_PIXEL_MAP_R_TO_R
    },
    {
	"GL_PIXEL_MAP_R_TO_R_SIZE", GL_PIXEL_MAP_R_TO_R_SIZE
    },
    {
	"GL_PIXEL_MAP_S_TO_S", GL_PIXEL_MAP_S_TO_S
    },
    {
	"GL_PIXEL_MAP_S_TO_S_SIZE", GL_PIXEL_MAP_S_TO_S_SIZE
    },
    {
	"GL_POINT", GL_POINT
    },
    {
	"GL_POINT_SIZE", GL_POINT_SIZE
    },
    {
	"GL_POINT_SIZE_GRANULARITY", GL_POINT_SIZE_GRANULARITY
    },
    {
	"GL_POINT_SIZE_RANGE", GL_POINT_SIZE_RANGE
    },
    {
	"GL_POINT_SMOOTH", GL_POINT_SMOOTH
    },
    {
	"GL_POINT_SMOOTH_HINT", GL_POINT_SMOOTH_HINT
    },
    {
	"GL_POINT_TOKEN", GL_POINT_TOKEN
    },
    {
	"GL_POINTS", GL_POINTS
    },
    {
	"GL_POLYGON", GL_POLYGON
    },
    {
	"GL_POLYGON_MODE", GL_POLYGON_MODE
    },
    {
	"GL_POLYGON_SMOOTH", GL_POLYGON_SMOOTH
    },
    {
	"GL_POLYGON_SMOOTH_HINT", GL_POLYGON_SMOOTH_HINT
    },
    {
	"GL_POLYGON_STIPPLE", GL_POLYGON_STIPPLE
    },
    {
	"GL_POLYGON_TOKEN", GL_POLYGON_TOKEN
    },
    {
	"GL_POSITION", GL_POSITION
    },
    {
	"GL_PROJECTION", GL_PROJECTION
    },
    {
	"GL_PROJECTION_MATRIX", GL_PROJECTION_MATRIX
    },
    {
	"GL_PROJECTION_STACK_DEPTH", GL_PROJECTION_STACK_DEPTH
    },
    {
	"GL_Q", GL_Q
    },
    {
	"GL_QUAD_STRIP", GL_QUAD_STRIP
    },
    {
	"GL_QUADRATIC_ATTENUATION", GL_QUADRATIC_ATTENUATION
    },
    {
	"GL_QUADS", GL_QUADS
    },
    {
	"GL_R", GL_R
    },
    {
	"GL_READ_BUFFER", GL_READ_BUFFER
    },
    {
	"GL_RED", GL_RED
    },
    {
	"GL_RED_BIAS", GL_RED_BIAS
    },
    {
	"GL_RED_BITS", GL_RED_BITS
    },
    {
	"GL_RED_SCALE", GL_RED_SCALE
    },
    {
	"GL_RENDER", GL_RENDER
    },
    {
	"GL_RENDER_MODE", GL_RENDER_MODE
    },
    {
	"GL_RENDERER", GL_RENDERER
    },
    {
	"GL_REPEAT", GL_REPEAT
    },
    {
	"GL_REPLACE", GL_REPLACE
    },
    {
	"GL_RETURN", GL_RETURN
    },
    {
	"GL_RGB", GL_RGB
    },
    {
	"GL_RGBA", GL_RGBA
    },
    {
	"GL_RGBA_MODE", GL_RGBA_MODE
    },
    {
	"GL_RIGHT", GL_RIGHT
    },
    {
	"GL_S", GL_S
    },
    {
	"GL_SHININESS", GL_SHININESS
    },
    {
	"GL_SPECULAR", GL_SPECULAR
    },
    {
	"GL_SRC_ALPHA", GL_SRC_ALPHA
    },
    {
	"GL_SRC_ALPHA_SATURATE", GL_SRC_ALPHA_SATURATE
    },
    {
	"GL_SRC_COLOR", GL_SRC_COLOR
    },
    {
	"GL_SCISSOR_BOX", GL_SCISSOR_BOX
    },
    {
	"GL_SCISSOR_TEST", GL_SCISSOR_TEST
    },
    {
	"GL_SELECT", GL_SELECT
    },
    {
	"GL_SET", GL_SET
    },
    {
	"GL_SHADE_MODEL", GL_SHADE_MODEL
    },
    {
	"GL_SHORT", GL_SHORT
    },
    {
	"GL_SMOOTH", GL_SMOOTH
    },
    {
	"GL_SPHERE_MAP", GL_SPHERE_MAP
    },
    {
	"GL_SPOT_CUTOFF", GL_SPOT_CUTOFF
    },
    {
	"GL_SPOT_DIRECTION", GL_SPOT_DIRECTION
    },
    {
	"GL_SPOT_EXPONENT", GL_SPOT_EXPONENT
    },
    {
	"GL_STACK_OVERFLOW", GL_STACK_OVERFLOW
    },
    {
	"GL_STACK_UNDERFLOW", GL_STACK_UNDERFLOW
    },
    {
	"GL_STENCIL", GL_STENCIL
    },
    {
	"GL_STENCIL_BITS", GL_STENCIL_BITS
    },
    {
	"GL_STENCIL_CLEAR_VALUE", GL_STENCIL_CLEAR_VALUE
    },
    {
	"GL_STENCIL_FAIL", GL_STENCIL_FAIL
    },
    {
	"GL_STENCIL_FUNC", GL_STENCIL_FUNC
    },
    {
	"GL_STENCIL_INDEX", GL_STENCIL_INDEX
    },
    {
	"GL_STENCIL_PASS_DEPTH_FAIL", GL_STENCIL_PASS_DEPTH_FAIL
    },
    {
	"GL_STENCIL_PASS_DEPTH_PASS", GL_STENCIL_PASS_DEPTH_PASS
    },
    {
	"GL_STENCIL_REF", GL_STENCIL_REF
    },
    {
	"GL_STENCIL_TEST", GL_STENCIL_TEST
    },
    {
	"GL_STENCIL_VALUE_MASK", GL_STENCIL_VALUE_MASK
    },
    {
	"GL_STENCIL_WRITEMASK", GL_STENCIL_WRITEMASK
    },
    {
	"GL_STEREO", GL_STEREO
    },
    {
	"GL_SUBPIXEL_BITS", GL_SUBPIXEL_BITS
    },
    {
	"GL_T", GL_T
    },
    {
	"GL_TEXTURE", GL_TEXTURE
    },
    {
	"GL_TEXTURE_1D", GL_TEXTURE_1D
    },
    {
	"GL_TEXTURE_2D", GL_TEXTURE_2D
    },
    {
	"GL_TEXTURE_BORDER", GL_TEXTURE_BORDER
    },
    {
	"GL_TEXTURE_BORDER_COLOR", GL_TEXTURE_BORDER_COLOR
    },
    {
	"GL_TEXTURE_COMPONENTS", GL_TEXTURE_COMPONENTS
    },
    {
	"GL_TEXTURE_ENV", GL_TEXTURE_ENV
    },
    {
	"GL_TEXTURE_ENV_COLOR", GL_TEXTURE_ENV_COLOR
    },
    {
	"GL_TEXTURE_ENV_MODE", GL_TEXTURE_ENV_MODE
    },
    {
	"GL_TEXTURE_GEN_MODE", GL_TEXTURE_GEN_MODE
    },
    {
	"GL_TEXTURE_GEN_Q", GL_TEXTURE_GEN_Q
    },
    {
	"GL_TEXTURE_GEN_R", GL_TEXTURE_GEN_R
    },
    {
	"GL_TEXTURE_GEN_S", GL_TEXTURE_GEN_S
    },
    {
	"GL_TEXTURE_GEN_T", GL_TEXTURE_GEN_T
    },
    {
	"GL_TEXTURE_HEIGHT", GL_TEXTURE_HEIGHT
    },
    {
	"GL_TEXTURE_MAG_FILTER", GL_TEXTURE_MAG_FILTER
    },
    {
	"GL_TEXTURE_MATRIX", GL_TEXTURE_MATRIX
    },
    {
	"GL_TEXTURE_MIN_FILTER", GL_TEXTURE_MIN_FILTER
    },
    {
	"GL_TEXTURE_STACK_DEPTH", GL_TEXTURE_STACK_DEPTH
    },
    {
	"GL_TEXTURE_WIDTH", GL_TEXTURE_WIDTH
    },
    {
	"GL_TEXTURE_WRAP_S", GL_TEXTURE_WRAP_S
    },
    {
	"GL_TEXTURE_WRAP_T", GL_TEXTURE_WRAP_T
    },
    {
	"GL_TRIANGLES", GL_TRIANGLES
    },
    {
	"GL_TRIANGLE_FAN", GL_TRIANGLE_FAN
    },
    {
	"GL_TRIANGLE_STRIP", GL_TRIANGLE_STRIP
    },
    {
	"GL_UNPACK_ALIGNMENT", GL_UNPACK_ALIGNMENT
    },
    {
	"GL_UNPACK_LSB_FIRST", GL_UNPACK_LSB_FIRST
    },
    {
	"GL_UNPACK_ROW_LENGTH", GL_UNPACK_ROW_LENGTH
    },
    {
	"GL_UNPACK_SKIP_PIXELS", GL_UNPACK_SKIP_PIXELS
    },
    {
	"GL_UNPACK_SKIP_ROWS", GL_UNPACK_SKIP_ROWS
    },
    {
	"GL_UNPACK_SWAP_BYTES", GL_UNPACK_SWAP_BYTES
    },
    {
	"GL_UNSIGNED_BYTE", GL_UNSIGNED_BYTE
    },
    {
	"GL_UNSIGNED_INT", GL_UNSIGNED_INT
    },
    {
	"GL_UNSIGNED_SHORT", GL_UNSIGNED_SHORT
    },
    {
	"GL_VENDOR", GL_VENDOR
    },
    {
	"GL_VIEWPORT", GL_VIEWPORT
    },
    {
	"GL_XOR", GL_XOR
    },
    {
	"GL_ZERO", GL_ZERO
    },
    {
	"GL_ZOOM_X", GL_ZOOM_X
    },
    {
	"GL_ZOOM_Y", GL_ZOOM_Y
    },
    {
	"GL_VERSION", GL_VERSION
    },
    {
	"Bad enumeration", GL_NULL
    }
};


void AutoClearColor(GLint color)
{

    if (buffer.colorMode == GL_RGB) {
	glClearColor(colorMap[color][0], colorMap[color][1], colorMap[color][2],
		     1.0);
    } else {
	glClearIndex(color);
    }
}

void AutoColor(GLint color)
{

    if (buffer.colorMode == GL_RGB) {
	glColor4f(colorMap[color][0], colorMap[color][1], colorMap[color][2],
		  1.0);
    } else {
	glIndexi(color);
    }
}

long AutoColorCompare(GLfloat buf, GLint color)
{

    if (ABS(buf-(GLfloat)color) < epsilon.zero) {
	return GL_TRUE;
    } else {
	return GL_FALSE;
    }
}

void ErrorReport(char *fileName, long line, char *errStr)
{
    char buf[80];
    long flag, i, j, k, l;

    Output(1, " failed.\n");

    Output(2, "    File - %s, line - %d.\n", fileName, line);
    if (errStr) {
	i = 0;
	while (1) {
	    while (1) {
		if (errStr[i] == 0x0) {
		    flag = GL_TRUE;
		    break;
		} else if (errStr[i] != ' ' && errStr[i] != '\n') {
		    flag = GL_FALSE;
		    break;
		} else {
		    i++;
		}
	    }
	    if (flag == GL_TRUE) {
		break;
	    }
	    j = i;
	    k = i;
	    while (1) {
		while (1) {
		    if (errStr[j] == 0x0 || errStr[j] == '\n') {
			flag = GL_TRUE;
			break;
		    } else if (errStr[j] == ' ') {
			flag = GL_FALSE;
			break;
		    } else {
			j++;
		    }
		}
		if (j-i+1 > 80-10) {
		    if (k == i) {
			k = i + 60;
			for (l = 0; l < 80-10; l++, i++) {
			    buf[l] = errStr[i];
			}
			buf[l] = 0;
			Output(2, "        %s-\n", buf);
		    } else {
			for (l = 0; i != k; l++, i++) {
			    buf[l] = errStr[i];
			}
			buf[l] = 0;
			Output(2, "        %s\n", buf);
		    }
		    i = k;
		    break;
		} else {
		    if (flag == GL_TRUE) {
			for (l = 0; i != j; l++, i++) {
			    buf[l] = errStr[i];
			}
			buf[l] = 0;
			Output(2, "        %s\n", buf);
			i = j;
			break;
		    } else {
			k = j;
			j++;
		    }
		}
	    }
	}
    }
    StateReport();
    if (machine.pathLevel != 0) {
	PathReport();
    }
}

void GetEnumName(long value, char *str)
{
    long i;

    for (i = 0; enumInfo[i].value != GL_NULL; i++) {
	if (enumInfo[i].value == value) {
	    STRCOPY(str, enumInfo[i].name);
	    return;
	}
    }
    StrMake(str, "%d (%s)", value, enumInfo[i].name);
}

long GLErrorReport(void)
{
    char buf[40];
    long error;

    error = glGetError();
    if (error != GL_NO_ERROR) {
	Output(1, " failed.\n");
	GetEnumName(error, buf);
	Output(2, "    GL Error - %s.\n", buf);
	StateReport();
	if (machine.pathLevel != 0) {
	    PathReport();
	}
	while ((error = glGetError()) != GL_NO_ERROR) {
	    GetEnumName(error, buf);
	    Output(2, "    GL Error - %s.\n", buf);
	}
	return ERROR;
    } else {
	return NO_ERROR;
    }
}

void MakeIdentMatrix(GLfloat *buf)
{
    long i;

    for (i = 0; i < 16; i++) {
	buf[i] = 0.0;
    }
    for (i = 0; i < 4; i++) {
	buf[i*4+i] = 1.0;
    }
}

void Ortho2D(double left, double right, double bottom, double top)
{
    GLfloat m[4][4], deltaX, deltaY;
    GLint mode;

    MakeIdentMatrix(&m[0][0]);
    deltaX = right - left;
    deltaY = top - bottom;
    m[0][0] = 2.0 / deltaX;
    m[3][0] = -(right + left) / deltaX;
    m[1][1] = 2.0 / deltaY;
    m[3][1] = -(top + bottom) / deltaY;
    m[2][2] = -1.0;
    glGetIntegerv(GL_MATRIX_MODE, &mode);
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixf(&m[0][0]);
    glMatrixMode(mode);
}

void Ortho3D(double left, double right, double bottom, double top,
	     double zNear, double zFar)
{
    GLfloat m[4][4], deltaX, deltaY, deltaZ;
    GLint mode;

    MakeIdentMatrix(&m[0][0]);
    deltaX = right - left;
    deltaY = top - bottom;
    deltaZ = zFar - zNear;
    m[0][0] = 2.0 / deltaX;
    m[3][0] = -(right + left) / deltaX;
    m[1][1] = 2.0 / deltaY;
    m[3][1] = -(top + bottom) / deltaY;
    m[2][2] = -2.0 / deltaZ;
    m[3][2] = -(zFar + zNear) / deltaZ;
    glGetIntegerv(GL_MATRIX_MODE, &mode);
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixf(&m[0][0]);
    glMatrixMode((GLenum)mode);
}

void Output(long level, char *format, ...)
{
    va_list args;

    va_start(args, format);
    if (machine.verboseLevel >= level) {
	vprintf(format, args);
	fflush(stdout);
    }
    va_end(args);
}

GLfloat Random(GLfloat low, GLfloat hi)
{
    GLfloat x;

    x = (GLfloat)((double)RAND() / RAND_MAX);
    return (x * (hi - low) + low);
}

void ReadScreen(GLint x, GLint y, GLsizei w, GLsizei h, GLenum type,
		GLfloat *buf)
{
    long repeat=1, i, j;

    switch (type) {
      case GL_AUTO_COLOR:
      case GL_COLOR_INDEX:
      case GL_STENCIL_INDEX:
      case GL_DEPTH_COMPONENT:
      case GL_RED:
      case GL_GREEN:
      case GL_BLUE:
      case GL_ALPHA:
	repeat = 1;
	break;
      case GL_RGB:
      case GL_LUMINANCE:
	repeat = 3;
	break;
      case GL_RGBA:
      case GL_LUMINANCE_ALPHA:
	repeat = 4;
	break;
    }

    for (i = 0; i < w*h*repeat; i++) {
	buf[i] = 0.0;
    }

    if (machine.failMode == GL_TRUE) {
	return;
    }

    if (type == GL_AUTO_COLOR) {
	if (buffer.colorMode == GL_COLOR_INDEX) {
	    GLint *tmpBuf = (GLint *)MALLOC(w*h*sizeof(GLint));

	    glReadPixels(x, y, w, h, GL_COLOR_INDEX, GL_INT,
			 (GLvoid *)tmpBuf);
	    for (i = 0; i < w*h; i++) {
		if (tmpBuf[i] < 4) {
		    buf[i] = tmpBuf[i];
		}
	    }
	    FREE(tmpBuf);
	} else {
	    GLfloat *tmpBuf = (GLfloat *)MALLOC(w*h*3*sizeof(GLfloat));
	    GLfloat *ptr = buf;

	    glReadPixels(x, y, w, h, GL_RGB, GL_FLOAT, (GLvoid *)tmpBuf);
	    for (i = 0; i < w*h*3; i += 3) {
		for (j = 0; j < 4; j++) {
		    if (ABS(tmpBuf[i]-colorMap[j][0]) < epsilon.zero &&
			ABS(tmpBuf[i+1]-colorMap[j][1]) < epsilon.zero &&
			ABS(tmpBuf[i+2]-colorMap[j][2]) < epsilon.zero) {
			*ptr = (GLfloat)j;
			break;
		    }
		}
		ptr++;
	    }
	    FREE(tmpBuf);
	}
    } else {
	if (buffer.colorMode == GL_COLOR_INDEX) {
	    if (type == GL_RGB || type == GL_RGBA) {
		GLint *tmpBuf = (GLint *)MALLOC(w*h*sizeof(GLint));
		GLfloat *ptr = buf;
		long max = (long)POW(2.0, (float)buffer.ciBits) - 1;

		glReadPixels(x, y, w, h, GL_COLOR_INDEX, GL_INT,
			     (GLvoid *)tmpBuf);
		for (i = 0; i < w*h; i++) {
		    if (tmpBuf[i] < max) {
			*ptr++ = colorMap[tmpBuf[i]][0];
			*ptr++ = colorMap[tmpBuf[i]][1];
			*ptr++ = colorMap[tmpBuf[i]][2];
			if (type == GL_RGBA) {
			    *ptr++ = 1.0;
			}
		    } else {
			ptr += 3;
			if (type == GL_RGBA) {
			    ptr++;
			}
		    }
		}
		FREE(tmpBuf);
	    } else {
		glReadPixels(x, y, w, h, type, GL_FLOAT, (GLvoid *)buf);
	    }
	} else {
	    glReadPixels(x, y, w, h, type, GL_FLOAT, (GLvoid *)buf);
	}
    }
}

void ResetMatrix(void)
{
    GLfloat buf[16];

    MakeIdentMatrix(buf);
    glMatrixMode(GL_MODELVIEW);
    glLoadMatrixf(buf);
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixf(buf);
    glMatrixMode(GL_TEXTURE);
    glLoadMatrixf(buf);
}

long Round(float x)
{

    return (long)(x + 0.5);
}

void StrMake(char *str, char *format, ...)
{
    va_list args;

    va_start(args, format);
    vsprintf(str, format, args);
    va_end(args);
}