From 8667d4d97a3e958a7f63c18c34a62469ba5d2079 Mon Sep 17 00:00:00 2001 From: ftrapero Date: Thu, 15 Jun 2017 14:15:08 +0200 Subject: Squashed 'nx-X11/extras/Mesa_6.4.1/' content from commit 53d1bc0 git-subtree-dir: nx-X11/extras/Mesa_6.4.1 git-subtree-split: 53d1bc081eb633aecbd5ab0bf3981f734a2102f2 --- src/mesa/shader/arbfragparse.c | 229 + src/mesa/shader/arbfragparse.h | 39 + src/mesa/shader/arbprogparse.c | 4134 +++++++++++++++++++ src/mesa/shader/arbprogparse.h | 75 + src/mesa/shader/arbprogram.c | 724 ++++ src/mesa/shader/arbprogram.h | 128 + src/mesa/shader/arbprogram.syn | 2786 +++++++++++++ src/mesa/shader/arbprogram_syn.h | 1327 ++++++ src/mesa/shader/arbvertparse.c | 207 + src/mesa/shader/arbvertparse.h | 36 + src/mesa/shader/asmopcodes.reg | 78 + src/mesa/shader/atifragshader.c | 439 ++ src/mesa/shader/atifragshader.h | 105 + src/mesa/shader/descrip.mms | 83 + src/mesa/shader/grammar/descrip.mms | 41 + src/mesa/shader/grammar/grammar.c | 3148 ++++++++++++++ src/mesa/shader/grammar/grammar.h | 103 + src/mesa/shader/grammar/grammar.syn | 567 +++ src/mesa/shader/grammar/grammar_crt.c | 64 + src/mesa/shader/grammar/grammar_crt.h | 20 + src/mesa/shader/grammar/grammar_mesa.c | 87 + src/mesa/shader/grammar/grammar_mesa.h | 43 + src/mesa/shader/grammar/grammar_syn.h | 202 + src/mesa/shader/nvfragparse.c | 1826 ++++++++ src/mesa/shader/nvfragparse.h | 52 + src/mesa/shader/nvfragprog.h | 168 + src/mesa/shader/nvprogram.c | 869 ++++ src/mesa/shader/nvprogram.h | 119 + src/mesa/shader/nvvertexec.c | 851 ++++ src/mesa/shader/nvvertexec.h | 43 + src/mesa/shader/nvvertparse.c | 1603 +++++++ src/mesa/shader/nvvertparse.h | 50 + src/mesa/shader/nvvertprog.h | 111 + src/mesa/shader/program.c | 1405 +++++++ src/mesa/shader/program.h | 298 ++ src/mesa/shader/shaderobjects.c | 1182 ++++++ src/mesa/shader/shaderobjects.h | 168 + src/mesa/shader/shaderobjects_3dlabs.c | 1052 +++++ src/mesa/shader/shaderobjects_3dlabs.h | 40 + src/mesa/shader/slang/Include/BaseTypes.h | 133 + src/mesa/shader/slang/Include/Common.h | 288 ++ src/mesa/shader/slang/Include/ConstantUnion.h | 50 + src/mesa/shader/slang/Include/InfoSink.h | 135 + src/mesa/shader/slang/Include/InitializeGlobals.h | 43 + .../shader/slang/Include/InitializeParseContext.h | 44 + src/mesa/shader/slang/Include/PoolAlloc.h | 346 ++ src/mesa/shader/slang/Include/ResourceLimits.h | 61 + src/mesa/shader/slang/Include/ShHandle.h | 177 + src/mesa/shader/slang/Include/Types.h | 297 ++ src/mesa/shader/slang/Include/intermediate.h | 516 +++ .../slang/MachineIndependent/Gen_glslang.cpp | 2942 +++++++++++++ .../slang/MachineIndependent/Gen_glslang_tab.cpp | 4354 ++++++++++++++++++++ .../shader/slang/MachineIndependent/InfoSink.cpp | 107 + .../shader/slang/MachineIndependent/Initialize.cpp | 948 +++++ .../shader/slang/MachineIndependent/Initialize.h | 58 + .../slang/MachineIndependent/IntermTraverse.cpp | 243 ++ .../slang/MachineIndependent/Intermediate.cpp | 2110 ++++++++++ src/mesa/shader/slang/MachineIndependent/MMap.h | 84 + .../slang/MachineIndependent/ParseHelper.cpp | 1452 +++++++ .../shader/slang/MachineIndependent/ParseHelper.h | 143 + .../shader/slang/MachineIndependent/PoolAlloc.cpp | 349 ++ .../slang/MachineIndependent/QualifierAlive.cpp | 91 + .../slang/MachineIndependent/QualifierAlive.h | 35 + .../shader/slang/MachineIndependent/RemoveTree.cpp | 98 + .../shader/slang/MachineIndependent/RemoveTree.h | 35 + .../shader/slang/MachineIndependent/ShaderLang.cpp | 607 +++ .../slang/MachineIndependent/SymbolTable.cpp | 235 ++ .../shader/slang/MachineIndependent/SymbolTable.h | 320 ++ src/mesa/shader/slang/MachineIndependent/glslang.l | 614 +++ src/mesa/shader/slang/MachineIndependent/glslang.y | 2009 +++++++++ .../shader/slang/MachineIndependent/glslang_tab.h | 260 ++ .../shader/slang/MachineIndependent/intermOut.cpp | 496 +++ .../slang/MachineIndependent/localintermediate.h | 91 + .../shader/slang/MachineIndependent/parseConst.cpp | 344 ++ .../slang/MachineIndependent/preprocessor/atom.c | 768 ++++ .../slang/MachineIndependent/preprocessor/atom.h | 96 + .../MachineIndependent/preprocessor/compile.h | 132 + .../slang/MachineIndependent/preprocessor/cpp.c | 1037 +++++ .../slang/MachineIndependent/preprocessor/cpp.h | 119 + .../preprocessor/cpp_comment_fix.c | 76 + .../MachineIndependent/preprocessor/cppstruct.c | 185 + .../slang/MachineIndependent/preprocessor/memory.c | 191 + .../slang/MachineIndependent/preprocessor/memory.h | 89 + .../slang/MachineIndependent/preprocessor/parser.h | 126 + .../MachineIndependent/preprocessor/preprocess.h | 84 + .../MachineIndependent/preprocessor/scanner.c | 789 ++++ .../MachineIndependent/preprocessor/scanner.h | 118 + .../MachineIndependent/preprocessor/slglobals.h | 115 + .../MachineIndependent/preprocessor/symbols.c | 318 ++ .../MachineIndependent/preprocessor/symbols.h | 145 + .../slang/MachineIndependent/preprocessor/tokens.c | 462 +++ .../slang/MachineIndependent/preprocessor/tokens.h | 122 + src/mesa/shader/slang/MachineIndependent/unistd.h | 1 + .../slang/OGLCompilersDLL/Initialisation.cpp | 151 + .../shader/slang/OGLCompilersDLL/Initialisation.h | 47 + .../shader/slang/OSDependent/Linux/osinclude.h | 78 + .../shader/slang/OSDependent/Linux/ossource.cpp | 140 + .../shader/slang/OSDependent/Windows/osinclude.h | 68 + .../shader/slang/OSDependent/Windows/ossource.cpp | 119 + src/mesa/shader/slang/Public/ShaderLang.h | 212 + src/mesa/shader/slang/Public/ShaderLangExt.h | 57 + src/mesa/shader/slang/descrip.mms | 52 + src/mesa/shader/slang/library/gc_to_bin.c | 79 + src/mesa/shader/slang/library/gc_to_string.py | 55 + .../shader/slang/library/slang_common_builtin.gc | 1410 +++++++ .../shader/slang/library/slang_common_builtin_gc.h | 1410 +++++++ .../slang/library/slang_common_builtin_gc_bin.h | 943 +++++ src/mesa/shader/slang/library/slang_core.gc | 1565 +++++++ src/mesa/shader/slang/library/slang_core_gc.h | 1565 +++++++ src/mesa/shader/slang/library/slang_core_gc_bin.h | 490 +++ .../shader/slang/library/slang_fragment_builtin.gc | 366 ++ .../slang/library/slang_fragment_builtin_gc.h | 366 ++ .../slang/library/slang_fragment_builtin_gc_bin.h | 87 + src/mesa/shader/slang/library/slang_shader.syn | 1508 +++++++ src/mesa/shader/slang/library/slang_shader_syn.h | 758 ++++ src/mesa/shader/slang/library/slang_version.syn | 118 + src/mesa/shader/slang/library/slang_version_syn.h | 64 + .../shader/slang/library/slang_vertex_builtin.gc | 262 ++ .../shader/slang/library/slang_vertex_builtin_gc.h | 262 ++ .../slang/library/slang_vertex_builtin_gc_bin.h | 82 + src/mesa/shader/slang/slang_assemble.c | 1208 ++++++ src/mesa/shader/slang/slang_assemble.h | 145 + src/mesa/shader/slang/slang_assemble_assignment.c | 187 + src/mesa/shader/slang/slang_assemble_assignment.h | 45 + src/mesa/shader/slang/slang_assemble_conditional.c | 485 +++ src/mesa/shader/slang/slang_assemble_conditional.h | 67 + src/mesa/shader/slang/slang_assemble_constructor.c | 339 ++ src/mesa/shader/slang/slang_assemble_constructor.h | 80 + src/mesa/shader/slang/slang_assemble_typeinfo.c | 430 ++ src/mesa/shader/slang/slang_assemble_typeinfo.h | 67 + src/mesa/shader/slang/slang_compile.c | 2369 +++++++++++ src/mesa/shader/slang/slang_compile.h | 271 ++ src/mesa/shader/slang/slang_execute.c | 352 ++ src/mesa/shader/slang/slang_execute.h | 57 + src/mesa/shader/slang/slang_mesa.cpp | 144 + src/mesa/shader/slang/slang_mesa.h | 36 + src/mesa/shader/slang/slang_preprocess.c | 87 + src/mesa/shader/slang/slang_preprocess.h | 39 + src/mesa/shader/slang/slang_storage.c | 255 ++ src/mesa/shader/slang/slang_storage.h | 109 + src/mesa/shader/slang/slang_utility.c | 73 + src/mesa/shader/slang/slang_utility.h | 51 + src/mesa/shader/slang/traverse_wrap.h | 112 + 143 files changed, 68912 insertions(+) create mode 100644 src/mesa/shader/arbfragparse.c create mode 100644 src/mesa/shader/arbfragparse.h create mode 100644 src/mesa/shader/arbprogparse.c create mode 100644 src/mesa/shader/arbprogparse.h create mode 100644 src/mesa/shader/arbprogram.c create mode 100644 src/mesa/shader/arbprogram.h create mode 100644 src/mesa/shader/arbprogram.syn create mode 100644 src/mesa/shader/arbprogram_syn.h create mode 100644 src/mesa/shader/arbvertparse.c create mode 100644 src/mesa/shader/arbvertparse.h create mode 100644 src/mesa/shader/asmopcodes.reg create mode 100644 src/mesa/shader/atifragshader.c create mode 100644 src/mesa/shader/atifragshader.h create mode 100644 src/mesa/shader/descrip.mms create mode 100644 src/mesa/shader/grammar/descrip.mms create mode 100644 src/mesa/shader/grammar/grammar.c create mode 100644 src/mesa/shader/grammar/grammar.h create mode 100644 src/mesa/shader/grammar/grammar.syn create mode 100755 src/mesa/shader/grammar/grammar_crt.c create mode 100755 src/mesa/shader/grammar/grammar_crt.h create mode 100644 src/mesa/shader/grammar/grammar_mesa.c create mode 100644 src/mesa/shader/grammar/grammar_mesa.h create mode 100644 src/mesa/shader/grammar/grammar_syn.h create mode 100644 src/mesa/shader/nvfragparse.c create mode 100644 src/mesa/shader/nvfragparse.h create mode 100644 src/mesa/shader/nvfragprog.h create mode 100644 src/mesa/shader/nvprogram.c create mode 100644 src/mesa/shader/nvprogram.h create mode 100644 src/mesa/shader/nvvertexec.c create mode 100644 src/mesa/shader/nvvertexec.h create mode 100644 src/mesa/shader/nvvertparse.c create mode 100644 src/mesa/shader/nvvertparse.h create mode 100644 src/mesa/shader/nvvertprog.h create mode 100644 src/mesa/shader/program.c create mode 100644 src/mesa/shader/program.h create mode 100644 src/mesa/shader/shaderobjects.c create mode 100644 src/mesa/shader/shaderobjects.h create mode 100755 src/mesa/shader/shaderobjects_3dlabs.c create mode 100755 src/mesa/shader/shaderobjects_3dlabs.h create mode 100755 src/mesa/shader/slang/Include/BaseTypes.h create mode 100755 src/mesa/shader/slang/Include/Common.h create mode 100755 src/mesa/shader/slang/Include/ConstantUnion.h create mode 100755 src/mesa/shader/slang/Include/InfoSink.h create mode 100755 src/mesa/shader/slang/Include/InitializeGlobals.h create mode 100755 src/mesa/shader/slang/Include/InitializeParseContext.h create mode 100755 src/mesa/shader/slang/Include/PoolAlloc.h create mode 100755 src/mesa/shader/slang/Include/ResourceLimits.h create mode 100755 src/mesa/shader/slang/Include/ShHandle.h create mode 100755 src/mesa/shader/slang/Include/Types.h create mode 100755 src/mesa/shader/slang/Include/intermediate.h create mode 100755 src/mesa/shader/slang/MachineIndependent/Gen_glslang.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/Gen_glslang_tab.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/InfoSink.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/Initialize.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/Initialize.h create mode 100755 src/mesa/shader/slang/MachineIndependent/IntermTraverse.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/Intermediate.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/MMap.h create mode 100755 src/mesa/shader/slang/MachineIndependent/ParseHelper.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/ParseHelper.h create mode 100755 src/mesa/shader/slang/MachineIndependent/PoolAlloc.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/QualifierAlive.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/QualifierAlive.h create mode 100755 src/mesa/shader/slang/MachineIndependent/RemoveTree.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/RemoveTree.h create mode 100755 src/mesa/shader/slang/MachineIndependent/ShaderLang.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/SymbolTable.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/SymbolTable.h create mode 100644 src/mesa/shader/slang/MachineIndependent/glslang.l create mode 100644 src/mesa/shader/slang/MachineIndependent/glslang.y create mode 100755 src/mesa/shader/slang/MachineIndependent/glslang_tab.h create mode 100755 src/mesa/shader/slang/MachineIndependent/intermOut.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/localintermediate.h create mode 100755 src/mesa/shader/slang/MachineIndependent/parseConst.cpp create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/atom.c create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/atom.h create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/compile.h create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/cpp.c create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/cpp.h create mode 100644 src/mesa/shader/slang/MachineIndependent/preprocessor/cpp_comment_fix.c create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/cppstruct.c create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/memory.c create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/memory.h create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/parser.h create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/preprocess.h create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/scanner.c create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/scanner.h create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/slglobals.h create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/symbols.c create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/symbols.h create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/tokens.c create mode 100755 src/mesa/shader/slang/MachineIndependent/preprocessor/tokens.h create mode 100755 src/mesa/shader/slang/MachineIndependent/unistd.h create mode 100755 src/mesa/shader/slang/OGLCompilersDLL/Initialisation.cpp create mode 100755 src/mesa/shader/slang/OGLCompilersDLL/Initialisation.h create mode 100755 src/mesa/shader/slang/OSDependent/Linux/osinclude.h create mode 100755 src/mesa/shader/slang/OSDependent/Linux/ossource.cpp create mode 100755 src/mesa/shader/slang/OSDependent/Windows/osinclude.h create mode 100755 src/mesa/shader/slang/OSDependent/Windows/ossource.cpp create mode 100755 src/mesa/shader/slang/Public/ShaderLang.h create mode 100755 src/mesa/shader/slang/Public/ShaderLangExt.h create mode 100644 src/mesa/shader/slang/descrip.mms create mode 100755 src/mesa/shader/slang/library/gc_to_bin.c create mode 100644 src/mesa/shader/slang/library/gc_to_string.py create mode 100755 src/mesa/shader/slang/library/slang_common_builtin.gc create mode 100644 src/mesa/shader/slang/library/slang_common_builtin_gc.h create mode 100755 src/mesa/shader/slang/library/slang_common_builtin_gc_bin.h create mode 100755 src/mesa/shader/slang/library/slang_core.gc create mode 100644 src/mesa/shader/slang/library/slang_core_gc.h create mode 100755 src/mesa/shader/slang/library/slang_core_gc_bin.h create mode 100755 src/mesa/shader/slang/library/slang_fragment_builtin.gc create mode 100644 src/mesa/shader/slang/library/slang_fragment_builtin_gc.h create mode 100755 src/mesa/shader/slang/library/slang_fragment_builtin_gc_bin.h create mode 100644 src/mesa/shader/slang/library/slang_shader.syn create mode 100644 src/mesa/shader/slang/library/slang_shader_syn.h create mode 100755 src/mesa/shader/slang/library/slang_version.syn create mode 100755 src/mesa/shader/slang/library/slang_version_syn.h create mode 100755 src/mesa/shader/slang/library/slang_vertex_builtin.gc create mode 100644 src/mesa/shader/slang/library/slang_vertex_builtin_gc.h create mode 100755 src/mesa/shader/slang/library/slang_vertex_builtin_gc_bin.h create mode 100644 src/mesa/shader/slang/slang_assemble.c create mode 100644 src/mesa/shader/slang/slang_assemble.h create mode 100644 src/mesa/shader/slang/slang_assemble_assignment.c create mode 100644 src/mesa/shader/slang/slang_assemble_assignment.h create mode 100644 src/mesa/shader/slang/slang_assemble_conditional.c create mode 100644 src/mesa/shader/slang/slang_assemble_conditional.h create mode 100644 src/mesa/shader/slang/slang_assemble_constructor.c create mode 100644 src/mesa/shader/slang/slang_assemble_constructor.h create mode 100644 src/mesa/shader/slang/slang_assemble_typeinfo.c create mode 100644 src/mesa/shader/slang/slang_assemble_typeinfo.h create mode 100644 src/mesa/shader/slang/slang_compile.c create mode 100644 src/mesa/shader/slang/slang_compile.h create mode 100644 src/mesa/shader/slang/slang_execute.c create mode 100644 src/mesa/shader/slang/slang_execute.h create mode 100644 src/mesa/shader/slang/slang_mesa.cpp create mode 100644 src/mesa/shader/slang/slang_mesa.h create mode 100644 src/mesa/shader/slang/slang_preprocess.c create mode 100644 src/mesa/shader/slang/slang_preprocess.h create mode 100644 src/mesa/shader/slang/slang_storage.c create mode 100644 src/mesa/shader/slang/slang_storage.h create mode 100644 src/mesa/shader/slang/slang_utility.c create mode 100644 src/mesa/shader/slang/slang_utility.h create mode 100644 src/mesa/shader/slang/traverse_wrap.h (limited to 'src/mesa/shader') diff --git a/src/mesa/shader/arbfragparse.c b/src/mesa/shader/arbfragparse.c new file mode 100644 index 000000000..237c348ba --- /dev/null +++ b/src/mesa/shader/arbfragparse.c @@ -0,0 +1,229 @@ +/* + * Mesa 3-D graphics library + * Version: 6.2 + * + * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#define DEBUG_FP 0 + +/** + * \file arbfragparse.c + * ARB_fragment_program parser. + * \author Karl Rasche + */ + +#include "glheader.h" +#include "context.h" +#include "imports.h" +#include "macros.h" +#include "mtypes.h" +#include "program.h" +#include "arbprogparse.h" +#include "arbfragparse.h" + +void +_mesa_debug_fp_inst(GLint num, struct fp_instruction *fp) +{ + GLint a; + + static const char *opcode_string[] = { + "ABS", /* ARB_f_p only */ + "ADD", + "CMP", /* ARB_f_p only */ + "COS", + "DDX", /* NV_f_p only */ + "DDY", /* NV_f_p only */ + "DP3", + "DP4", + "DPH", /* ARB_f_p only */ + "DST", + "END", /* private opcode */ + "EX2", + "FLR", + "FRC", + "KIL", /* ARB_f_p only */ + "KIL_NV", /* NV_f_p only */ + "LG2", + "LIT", + "LRP", + "MAD", + "MAX", + "MIN", + "MOV", + "MUL", + "PK2H", /* NV_f_p only */ + "PK2US", /* NV_f_p only */ + "PK4B", /* NV_f_p only */ + "PK4UB", /* NV_f_p only */ + "POW", + "PRINT", /* Mesa only */ + "RCP", + "RFL", /* NV_f_p only */ + "RSQ", + "SCS", /* ARB_f_p only */ + "SEQ", /* NV_f_p only */ + "SFL", /* NV_f_p only */ + "SGE", /* NV_f_p only */ + "SGT", /* NV_f_p only */ + "SIN", + "SLE", /* NV_f_p only */ + "SLT", + "SNE", /* NV_f_p only */ + "STR", /* NV_f_p only */ + "SUB", + "SWZ", /* ARB_f_p only */ + "TEX", + "TXB", /* ARB_f_p only */ + "TXD", /* NV_f_p only */ + "TXP", /* ARB_f_p only */ + "TXP_NV", /* NV_f_p only */ + "UP2H", /* NV_f_p only */ + "UP2US", /* NV_f_p only */ + "UP4B", /* NV_f_p only */ + "UP4UB", /* NV_f_p only */ + "X2D", /* NV_f_p only - 2d mat mul */ + "XPD", /* ARB_f_p only - cross product */ + }; + + static const char *file_string[] = { + "TEMP", + "INPUT", + "OUTPUT", + "LOCAL", + "ENV", + "NAMED", + "STATE", + "WRITE_ONLY", + "ADDR" + }; + + static const char swz[] = "xyzw01??"; + + for (a=0; aBase.String = ap.Base.String; + program->Base.NumInstructions = ap.Base.NumInstructions; + program->Base.NumTemporaries = ap.Base.NumTemporaries; + program->Base.NumParameters = ap.Base.NumParameters; + program->Base.NumAttributes = ap.Base.NumAttributes; + program->Base.NumAddressRegs = ap.Base.NumAddressRegs; + program->NumAluInstructions = ap.NumAluInstructions; + program->NumTexInstructions = ap.NumTexInstructions; + program->NumTexIndirections = ap.NumTexIndirections; + + program->InputsRead = ap.InputsRead; + program->OutputsWritten = ap.OutputsWritten; + for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++) + program->TexturesUsed[i] = ap.TexturesUsed[i]; + + if (program->Parameters) { + /* free previous program's parameters */ + _mesa_free_parameter_list(program->Parameters); + } + program->Parameters = ap.Parameters; + program->FogOption = ap.FogOption; + +#if DEBUG_FP + _mesa_debug_fp_inst(ap.Base.NumInstructions, ap.FPInstructions); +#endif + + program->Instructions = ap.FPInstructions; +} diff --git a/src/mesa/shader/arbfragparse.h b/src/mesa/shader/arbfragparse.h new file mode 100644 index 000000000..0d3e69fa8 --- /dev/null +++ b/src/mesa/shader/arbfragparse.h @@ -0,0 +1,39 @@ +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef ARBFRAGPARSE_H +#define ARBFRAGPARSE_H + +#include "mtypes.h" + +extern void +_mesa_parse_arb_fragment_program(GLcontext * ctx, GLenum target, + const GLubyte * str, GLsizei len, + struct fragment_program *program); + +extern void +_mesa_debug_fp_inst(GLint num, struct fp_instruction *fp); + + +#endif diff --git a/src/mesa/shader/arbprogparse.c b/src/mesa/shader/arbprogparse.c new file mode 100644 index 000000000..57891b234 --- /dev/null +++ b/src/mesa/shader/arbprogparse.c @@ -0,0 +1,4134 @@ +/* + * Mesa 3-D graphics library + * Version: 6.4 + * + * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#define DEBUG_PARSING 0 + +/** + * \file arbprogparse.c + * ARB_*_program parser core + * \author Karl Rasche + */ + +#include "mtypes.h" +#include "glheader.h" +#include "context.h" +#include "hash.h" +#include "imports.h" +#include "macros.h" +#include "program.h" +#include "nvvertprog.h" +#include "nvfragprog.h" +#include "arbprogparse.h" +#include "grammar_mesa.h" + +#include "dispatch.h" + +#ifndef __extension__ +#if !defined(__GNUC__) || (__GNUC__ < 2) || \ + ((__GNUC__ == 2) && (__GNUC_MINOR__ <= 7)) +# define __extension__ +#endif +#endif + +/* TODO: + * Fragment Program Stuff: + * ----------------------------------------------------- + * + * - things from Michal's email + * + overflow on atoi + * + not-overflowing floats (don't use parse_integer..) + * + can remove range checking in arbparse.c + * + * - check all limits of number of various variables + * + parameters + * + * - test! test! test! + * + * Vertex Program Stuff: + * ----------------------------------------------------- + * - Optimize param array usage and count limits correctly, see spec, + * section 2.14.3.7 + * + Record if an array is reference absolutly or relatively (or both) + * + For absolute arrays, store a bitmap of accesses + * + For single parameters, store an access flag + * + After parsing, make a parameter cleanup and merging pass, where + * relative arrays are layed out first, followed by abs arrays, and + * finally single state. + * + Remap offsets for param src and dst registers + * + Now we can properly count parameter usage + * + * - Multiple state binding errors in param arrays (see spec, just before + * section 2.14.3.3) + * - grep for XXX + * + * Mesa Stuff + * ----------------------------------------------------- + * - User clipping planes vs. PositionInvariant + * - Is it sufficient to just multiply by the mvp to transform in the + * PositionInvariant case? Or do we need something more involved? + * + * - vp_src swizzle is GLubyte, fp_src swizzle is GLuint + * - fetch state listed in program_parameters list + * + WTF should this go??? + * + currently in nvvertexec.c and s_nvfragprog.c + * + * - allow for multiple address registers (and fetch address regs properly) + * + * Cosmetic Stuff + * ----------------------------------------------------- + * - remove any leftover unused grammer.c stuff (dict_ ?) + * - fix grammer.c error handling so its not static + * - #ifdef around stuff pertaining to extentions + * + * Outstanding Questions: + * ----------------------------------------------------- + * - ARB_matrix_palette / ARB_vertex_blend -- not supported + * what gets hacked off because of this: + * + VERTEX_ATTRIB_MATRIXINDEX + * + VERTEX_ATTRIB_WEIGHT + * + MATRIX_MODELVIEW + * + MATRIX_PALETTE + * + * - When can we fetch env/local params from their own register files, and + * when to we have to fetch them into the main state register file? + * (think arrays) + * + * Grammar Changes: + * ----------------------------------------------------- + */ + +/* Changes since moving the file to shader directory + +2004-III-4 ------------------------------------------------------------ +- added #include "grammar_mesa.h" +- removed grammar specific code part (it resides now in grammar.c) +- added GL_ARB_fragment_program_shadow tokens +- modified #include "arbparse_syn.h" +- major changes inside _mesa_parse_arb_program() +- check the program string for '\0' characters +- copy the program string to a one-byte-longer location to have + it null-terminated +- position invariance test (not writing to result.position) moved + to syntax part +*/ + +typedef GLubyte *production; + +/** + * This is the text describing the rules to parse the grammar + */ +__extension__ static char arb_grammar_text[] = +#include "arbprogram_syn.h" +; + +/** + * These should match up with the values defined in arbprogram.syn + */ + +/* + Changes: + - changed and merged V_* and F_* opcode values to OP_*. + - added GL_ARB_fragment_program_shadow specific tokens (michal) +*/ +#define REVISION 0x09 + +/* program type */ +#define FRAGMENT_PROGRAM 0x01 +#define VERTEX_PROGRAM 0x02 + +/* program section */ +#define OPTION 0x01 +#define INSTRUCTION 0x02 +#define DECLARATION 0x03 +#define END 0x04 + +/* GL_ARB_fragment_program option */ +#define ARB_PRECISION_HINT_FASTEST 0x00 +#define ARB_PRECISION_HINT_NICEST 0x01 +#define ARB_FOG_EXP 0x02 +#define ARB_FOG_EXP2 0x03 +#define ARB_FOG_LINEAR 0x04 + +/* GL_ARB_vertex_program option */ +#define ARB_POSITION_INVARIANT 0x05 + +/* GL_ARB_fragment_program_shadow option */ +#define ARB_FRAGMENT_PROGRAM_SHADOW 0x06 + +/* GL_ARB_draw_buffers option */ +#define ARB_DRAW_BUFFERS 0x07 + +/* GL_ARB_fragment_program instruction class */ +#define OP_ALU_INST 0x00 +#define OP_TEX_INST 0x01 + +/* GL_ARB_vertex_program instruction class */ +/* OP_ALU_INST */ + +/* GL_ARB_fragment_program instruction type */ +#define OP_ALU_VECTOR 0x00 +#define OP_ALU_SCALAR 0x01 +#define OP_ALU_BINSC 0x02 +#define OP_ALU_BIN 0x03 +#define OP_ALU_TRI 0x04 +#define OP_ALU_SWZ 0x05 +#define OP_TEX_SAMPLE 0x06 +#define OP_TEX_KIL 0x07 + +/* GL_ARB_vertex_program instruction type */ +#define OP_ALU_ARL 0x08 +/* OP_ALU_VECTOR */ +/* OP_ALU_SCALAR */ +/* OP_ALU_BINSC */ +/* OP_ALU_BIN */ +/* OP_ALU_TRI */ +/* OP_ALU_SWZ */ + +/* GL_ARB_fragment_program instruction code */ +#define OP_ABS 0x00 +#define OP_ABS_SAT 0x1B +#define OP_FLR 0x09 +#define OP_FLR_SAT 0x26 +#define OP_FRC 0x0A +#define OP_FRC_SAT 0x27 +#define OP_LIT 0x0C +#define OP_LIT_SAT 0x2A +#define OP_MOV 0x11 +#define OP_MOV_SAT 0x30 +#define OP_COS 0x1F +#define OP_COS_SAT 0x20 +#define OP_EX2 0x07 +#define OP_EX2_SAT 0x25 +#define OP_LG2 0x0B +#define OP_LG2_SAT 0x29 +#define OP_RCP 0x14 +#define OP_RCP_SAT 0x33 +#define OP_RSQ 0x15 +#define OP_RSQ_SAT 0x34 +#define OP_SIN 0x38 +#define OP_SIN_SAT 0x39 +#define OP_SCS 0x35 +#define OP_SCS_SAT 0x36 +#define OP_POW 0x13 +#define OP_POW_SAT 0x32 +#define OP_ADD 0x01 +#define OP_ADD_SAT 0x1C +#define OP_DP3 0x03 +#define OP_DP3_SAT 0x21 +#define OP_DP4 0x04 +#define OP_DP4_SAT 0x22 +#define OP_DPH 0x05 +#define OP_DPH_SAT 0x23 +#define OP_DST 0x06 +#define OP_DST_SAT 0x24 +#define OP_MAX 0x0F +#define OP_MAX_SAT 0x2E +#define OP_MIN 0x10 +#define OP_MIN_SAT 0x2F +#define OP_MUL 0x12 +#define OP_MUL_SAT 0x31 +#define OP_SGE 0x16 +#define OP_SGE_SAT 0x37 +#define OP_SLT 0x17 +#define OP_SLT_SAT 0x3A +#define OP_SUB 0x18 +#define OP_SUB_SAT 0x3B +#define OP_XPD 0x1A +#define OP_XPD_SAT 0x43 +#define OP_CMP 0x1D +#define OP_CMP_SAT 0x1E +#define OP_LRP 0x2B +#define OP_LRP_SAT 0x2C +#define OP_MAD 0x0E +#define OP_MAD_SAT 0x2D +#define OP_SWZ 0x19 +#define OP_SWZ_SAT 0x3C +#define OP_TEX 0x3D +#define OP_TEX_SAT 0x3E +#define OP_TXB 0x3F +#define OP_TXB_SAT 0x40 +#define OP_TXP 0x41 +#define OP_TXP_SAT 0x42 +#define OP_KIL 0x28 + +/* GL_ARB_vertex_program instruction code */ +#define OP_ARL 0x02 +/* OP_ABS */ +/* OP_FLR */ +/* OP_FRC */ +/* OP_LIT */ +/* OP_MOV */ +/* OP_EX2 */ +#define OP_EXP 0x08 +/* OP_LG2 */ +#define OP_LOG 0x0D +/* OP_RCP */ +/* OP_RSQ */ +/* OP_POW */ +/* OP_ADD */ +/* OP_DP3 */ +/* OP_DP4 */ +/* OP_DPH */ +/* OP_DST */ +/* OP_MAX */ +/* OP_MIN */ +/* OP_MUL */ +/* OP_SGE */ +/* OP_SLT */ +/* OP_SUB */ +/* OP_XPD */ +/* OP_MAD */ +/* OP_SWZ */ + +/* fragment attribute binding */ +#define FRAGMENT_ATTRIB_COLOR 0x01 +#define FRAGMENT_ATTRIB_TEXCOORD 0x02 +#define FRAGMENT_ATTRIB_FOGCOORD 0x03 +#define FRAGMENT_ATTRIB_POSITION 0x04 + +/* vertex attribute binding */ +#define VERTEX_ATTRIB_POSITION 0x01 +#define VERTEX_ATTRIB_WEIGHT 0x02 +#define VERTEX_ATTRIB_NORMAL 0x03 +#define VERTEX_ATTRIB_COLOR 0x04 +#define VERTEX_ATTRIB_FOGCOORD 0x05 +#define VERTEX_ATTRIB_TEXCOORD 0x06 +#define VERTEX_ATTRIB_MATRIXINDEX 0x07 +#define VERTEX_ATTRIB_GENERIC 0x08 + +/* fragment result binding */ +#define FRAGMENT_RESULT_COLOR 0x01 +#define FRAGMENT_RESULT_DEPTH 0x02 + +/* vertex result binding */ +#define VERTEX_RESULT_POSITION 0x01 +#define VERTEX_RESULT_COLOR 0x02 +#define VERTEX_RESULT_FOGCOORD 0x03 +#define VERTEX_RESULT_POINTSIZE 0x04 +#define VERTEX_RESULT_TEXCOORD 0x05 + +/* texture target */ +#define TEXTARGET_1D 0x01 +#define TEXTARGET_2D 0x02 +#define TEXTARGET_3D 0x03 +#define TEXTARGET_RECT 0x04 +#define TEXTARGET_CUBE 0x05 +/* GL_ARB_fragment_program_shadow */ +#define TEXTARGET_SHADOW1D 0x06 +#define TEXTARGET_SHADOW2D 0x07 +#define TEXTARGET_SHADOWRECT 0x08 + +/* face type */ +#define FACE_FRONT 0x00 +#define FACE_BACK 0x01 + +/* color type */ +#define COLOR_PRIMARY 0x00 +#define COLOR_SECONDARY 0x01 + +/* component */ +#define COMPONENT_X 0x00 +#define COMPONENT_Y 0x01 +#define COMPONENT_Z 0x02 +#define COMPONENT_W 0x03 +#define COMPONENT_0 0x04 +#define COMPONENT_1 0x05 + +/* array index type */ +#define ARRAY_INDEX_ABSOLUTE 0x00 +#define ARRAY_INDEX_RELATIVE 0x01 + +/* matrix name */ +#define MATRIX_MODELVIEW 0x01 +#define MATRIX_PROJECTION 0x02 +#define MATRIX_MVP 0x03 +#define MATRIX_TEXTURE 0x04 +#define MATRIX_PALETTE 0x05 +#define MATRIX_PROGRAM 0x06 + +/* matrix modifier */ +#define MATRIX_MODIFIER_IDENTITY 0x00 +#define MATRIX_MODIFIER_INVERSE 0x01 +#define MATRIX_MODIFIER_TRANSPOSE 0x02 +#define MATRIX_MODIFIER_INVTRANS 0x03 + +/* constant type */ +#define CONSTANT_SCALAR 0x01 +#define CONSTANT_VECTOR 0x02 + +/* program param type */ +#define PROGRAM_PARAM_ENV 0x01 +#define PROGRAM_PARAM_LOCAL 0x02 + +/* register type */ +#define REGISTER_ATTRIB 0x01 +#define REGISTER_PARAM 0x02 +#define REGISTER_RESULT 0x03 +#define REGISTER_ESTABLISHED_NAME 0x04 + +/* param binding */ +#define PARAM_NULL 0x00 +#define PARAM_ARRAY_ELEMENT 0x01 +#define PARAM_STATE_ELEMENT 0x02 +#define PARAM_PROGRAM_ELEMENT 0x03 +#define PARAM_PROGRAM_ELEMENTS 0x04 +#define PARAM_CONSTANT 0x05 + +/* param state property */ +#define STATE_MATERIAL_PARSER 0x01 +#define STATE_LIGHT_PARSER 0x02 +#define STATE_LIGHT_MODEL 0x03 +#define STATE_LIGHT_PROD 0x04 +#define STATE_FOG 0x05 +#define STATE_MATRIX_ROWS 0x06 +/* GL_ARB_fragment_program */ +#define STATE_TEX_ENV 0x07 +#define STATE_DEPTH 0x08 +/* GL_ARB_vertex_program */ +#define STATE_TEX_GEN 0x09 +#define STATE_CLIP_PLANE 0x0A +#define STATE_POINT 0x0B + +/* state material property */ +#define MATERIAL_AMBIENT 0x01 +#define MATERIAL_DIFFUSE 0x02 +#define MATERIAL_SPECULAR 0x03 +#define MATERIAL_EMISSION 0x04 +#define MATERIAL_SHININESS 0x05 + +/* state light property */ +#define LIGHT_AMBIENT 0x01 +#define LIGHT_DIFFUSE 0x02 +#define LIGHT_SPECULAR 0x03 +#define LIGHT_POSITION 0x04 +#define LIGHT_ATTENUATION 0x05 +#define LIGHT_HALF 0x06 +#define LIGHT_SPOT_DIRECTION 0x07 + +/* state light model property */ +#define LIGHT_MODEL_AMBIENT 0x01 +#define LIGHT_MODEL_SCENECOLOR 0x02 + +/* state light product property */ +#define LIGHT_PROD_AMBIENT 0x01 +#define LIGHT_PROD_DIFFUSE 0x02 +#define LIGHT_PROD_SPECULAR 0x03 + +/* state texture environment property */ +#define TEX_ENV_COLOR 0x01 + +/* state texture generation coord property */ +#define TEX_GEN_EYE 0x01 +#define TEX_GEN_OBJECT 0x02 + +/* state fog property */ +#define FOG_COLOR 0x01 +#define FOG_PARAMS 0x02 + +/* state depth property */ +#define DEPTH_RANGE 0x01 + +/* state point parameters property */ +#define POINT_SIZE 0x01 +#define POINT_ATTENUATION 0x02 + +/* declaration */ +#define ATTRIB 0x01 +#define PARAM 0x02 +#define TEMP 0x03 +#define OUTPUT 0x04 +#define ALIAS 0x05 +/* GL_ARB_vertex_program */ +#define ADDRESS 0x06 + +/*----------------------------------------------------------------------- + * From here on down is the semantic checking portion + * + */ + +/** + * Variable Table Handling functions + */ +typedef enum +{ + vt_none, + vt_address, + vt_attrib, + vt_param, + vt_temp, + vt_output, + vt_alias +} var_type; + + +/* + * Setting an explicit field for each of the binding properties is a bit wasteful + * of space, but it should be much more clear when reading later on.. + */ +struct var_cache +{ + GLubyte *name; + var_type type; + GLuint address_binding; /* The index of the address register we should + * be using */ + GLuint attrib_binding; /* For type vt_attrib, see nvfragprog.h for values */ + GLuint attrib_binding_idx; /* The index into the attrib register file corresponding + * to the state in attrib_binding */ + GLuint attrib_is_generic; /* If the attrib was specified through a generic + * vertex attrib */ + GLuint temp_binding; /* The index of the temp register we are to use */ + GLuint output_binding; /* For type vt_output, see nvfragprog.h for values */ + GLuint output_binding_idx; /* This is the index into the result register file + * corresponding to the bound result state */ + struct var_cache *alias_binding; /* For type vt_alias, points to the var_cache entry + * that this is aliased to */ + GLuint param_binding_type; /* {PROGRAM_STATE_VAR, PROGRAM_LOCAL_PARAM, + * PROGRAM_ENV_PARAM} */ + GLuint param_binding_begin; /* This is the offset into the program_parameter_list where + * the tokens representing our bound state (or constants) + * start */ + GLuint param_binding_length; /* This is how many entries in the the program_parameter_list + * we take up with our state tokens or constants. Note that + * this is _not_ the same as the number of param registers + * we eventually use */ + struct var_cache *next; +}; + +static GLvoid +var_cache_create (struct var_cache **va) +{ + *va = (struct var_cache *) _mesa_malloc (sizeof (struct var_cache)); + if (*va) { + (**va).name = NULL; + (**va).type = vt_none; + (**va).attrib_binding = ~0; + (**va).attrib_is_generic = 0; + (**va).temp_binding = ~0; + (**va).output_binding = ~0; + (**va).output_binding_idx = ~0; + (**va).param_binding_type = ~0; + (**va).param_binding_begin = ~0; + (**va).param_binding_length = ~0; + (**va).alias_binding = NULL; + (**va).next = NULL; + } +} + +static GLvoid +var_cache_destroy (struct var_cache **va) +{ + if (*va) { + var_cache_destroy (&(**va).next); + _mesa_free (*va); + *va = NULL; + } +} + +static GLvoid +var_cache_append (struct var_cache **va, struct var_cache *nv) +{ + if (*va) + var_cache_append (&(**va).next, nv); + else + *va = nv; +} + +static struct var_cache * +var_cache_find (struct var_cache *va, GLubyte * name) +{ + /*struct var_cache *first = va;*/ + + while (va) { + if (!strcmp ( (const char*) name, (const char*) va->name)) { + if (va->type == vt_alias) + return va->alias_binding; + return va; + } + + va = va->next; + } + + return NULL; +} + +/** + * constructs an integer from 4 GLubytes in LE format + */ +static GLuint +parse_position (GLubyte ** inst) +{ + GLuint value; + + value = (GLuint) (*(*inst)++); + value += (GLuint) (*(*inst)++) * 0x100; + value += (GLuint) (*(*inst)++) * 0x10000; + value += (GLuint) (*(*inst)++) * 0x1000000; + + return value; +} + +/** + * This will, given a string, lookup the string as a variable name in the + * var cache. If the name is found, the var cache node corresponding to the + * var name is returned. If it is not found, a new entry is allocated + * + * \param I Points into the binary array where the string identifier begins + * \param found 1 if the string was found in the var_cache, 0 if it was allocated + * \return The location on the var_cache corresponding the the string starting at I + */ +static struct var_cache * +parse_string (GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program, GLuint * found) +{ + GLubyte *i = *inst; + struct var_cache *va = NULL; + (void) Program; + + *inst += _mesa_strlen ((char *) i) + 1; + + va = var_cache_find (*vc_head, i); + + if (va) { + *found = 1; + return va; + } + + *found = 0; + var_cache_create (&va); + va->name = i; + + var_cache_append (vc_head, va); + + return va; +} + +static char * +parse_string_without_adding (GLubyte ** inst, struct arb_program *Program) +{ + GLubyte *i = *inst; + (void) Program; + + *inst += _mesa_strlen ((char *) i) + 1; + + return (char *) i; +} + +/** + * \return -1 if we parse '-', return 1 otherwise + */ +static GLint +parse_sign (GLubyte ** inst) +{ + /*return *(*inst)++ != '+'; */ + + if (**inst == '-') { + (*inst)++; + return -1; + } + else if (**inst == '+') { + (*inst)++; + return 1; + } + + return 1; +} + +/** + * parses and returns signed integer + */ +static GLint +parse_integer (GLubyte ** inst, struct arb_program *Program) +{ + GLint sign; + GLint value; + + /* check if *inst points to '+' or '-' + * if yes, grab the sign and increment *inst + */ + sign = parse_sign (inst); + + /* now check if *inst points to 0 + * if yes, increment the *inst and return the default value + */ + if (**inst == 0) { + (*inst)++; + return 0; + } + + /* parse the integer as you normally would do it */ + value = _mesa_atoi (parse_string_without_adding (inst, Program)); + + /* now, after terminating 0 there is a position + * to parse it - parse_position() + */ + Program->Position = parse_position (inst); + + return value * sign; +} + +/** + Accumulate this string of digits, and return them as + a large integer represented in floating point (for range). + If scale is not NULL, also accumulates a power-of-ten + integer scale factor that represents the number of digits + in the string. +*/ +static GLdouble +parse_float_string(GLubyte ** inst, struct arb_program *Program, GLdouble *scale) +{ + GLdouble value = 0.0; + GLdouble oscale = 1.0; + + if (**inst == 0) { /* this string of digits is empty-- do nothing */ + (*inst)++; + } + else { /* nonempty string-- parse out the digits */ + while (**inst >= '0' && **inst <= '9') { + GLubyte digit = *((*inst)++); + value = value * 10.0 + (GLint) (digit - '0'); + oscale *= 10.0; + } + assert(**inst == 0); /* integer string should end with 0 */ + (*inst)++; /* skip over terminating 0 */ + Program->Position = parse_position(inst); /* skip position (from integer) */ + } + if (scale) + *scale = oscale; + return value; +} + +/** + Parse an unsigned floating-point number from this stream of tokenized + characters. Example floating-point formats supported: + 12.34 + 12 + 0.34 + .34 + 12.34e-4 + */ +static GLfloat +parse_float (GLubyte ** inst, struct arb_program *Program) +{ + GLint exponent; + GLdouble whole, fraction, fracScale = 1.0; + + whole = parse_float_string(inst, Program, 0); + fraction = parse_float_string(inst, Program, &fracScale); + + /* Parse signed exponent */ + exponent = parse_integer(inst, Program); /* This is the exponent */ + + /* Assemble parts of floating-point number: */ + return (GLfloat) ((whole + fraction / fracScale) * + _mesa_pow(10.0, (GLfloat) exponent)); +} + + +/** + */ +static GLfloat +parse_signed_float (GLubyte ** inst, struct arb_program *Program) +{ + GLint sign = parse_sign (inst); + GLfloat value = parse_float (inst, Program); + return value * sign; +} + +/** + * This picks out a constant value from the parsed array. The constant vector is r + * returned in the *values array, which should be of length 4. + * + * \param values - The 4 component vector with the constant value in it + */ +static GLvoid +parse_constant (GLubyte ** inst, GLfloat *values, struct arb_program *Program, + GLboolean use) +{ + GLuint components, i; + + + switch (*(*inst)++) { + case CONSTANT_SCALAR: + if (use == GL_TRUE) { + values[0] = + values[1] = + values[2] = values[3] = parse_float (inst, Program); + } + else { + values[0] = + values[1] = + values[2] = values[3] = parse_signed_float (inst, Program); + } + + break; + case CONSTANT_VECTOR: + values[0] = values[1] = values[2] = 0; + values[3] = 1; + components = *(*inst)++; + for (i = 0; i < components; i++) { + values[i] = parse_signed_float (inst, Program); + } + break; + } +} + +/** + * \param offset The offset from the address register that we should + * address + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_relative_offset (GLcontext *ctx, GLubyte **inst, struct arb_program *Program, + GLint *offset) +{ + *offset = parse_integer(inst, Program); + return 0; +} + +/** + * \param color 0 if color type is primary, 1 if color type is secondary + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_color_type (GLcontext * ctx, GLubyte ** inst, struct arb_program *Program, + GLint * color) +{ + (void) ctx; (void) Program; + *color = *(*inst)++ != COLOR_PRIMARY; + return 0; +} + +/** + * Get an integer corresponding to a generic vertex attribute. + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_generic_attrib_num(GLcontext *ctx, GLubyte ** inst, + struct arb_program *Program, GLuint *attrib) +{ + GLint i = parse_integer(inst, Program); + + if ((i < 0) || (i > MAX_VERTEX_PROGRAM_ATTRIBS)) + { + _mesa_set_program_error (ctx, Program->Position, + "Invalid generic vertex attribute index"); + _mesa_error (ctx, GL_INVALID_OPERATION, "Invalid generic vertex attribute index"); + + return 1; + } + + *attrib = (GLuint) i; + + return 0; +} + + +/** + * \param color The index of the color buffer to write into + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_output_color_num (GLcontext * ctx, GLubyte ** inst, + struct arb_program *Program, GLuint * color) +{ + GLint i = parse_integer (inst, Program); + + if ((i < 0) || (i >= (int)ctx->Const.MaxDrawBuffers)) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid draw buffer index"); + _mesa_error (ctx, GL_INVALID_OPERATION, "Invalid draw buffer index"); + return 1; + } + + *color = (GLuint) i; + return 0; +} + + +/** + * \param coord The texture unit index + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_texcoord_num (GLcontext * ctx, GLubyte ** inst, + struct arb_program *Program, GLuint * coord) +{ + GLint i = parse_integer (inst, Program); + + if ((i < 0) || (i >= (int)ctx->Const.MaxTextureUnits)) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid texture unit index"); + _mesa_error (ctx, GL_INVALID_OPERATION, "Invalid texture unit index"); + return 1; + } + + *coord = (GLuint) i; + return 0; +} + +/** + * \param coord The weight index + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_weight_num (GLcontext * ctx, GLubyte ** inst, struct arb_program *Program, + GLint * coord) +{ + *coord = parse_integer (inst, Program); + + if ((*coord < 0) || (*coord >= 1)) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid weight index"); + _mesa_error (ctx, GL_INVALID_OPERATION, "Invalid weight index"); + return 1; + } + + return 0; +} + +/** + * \param coord The clip plane index + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_clipplane_num (GLcontext * ctx, GLubyte ** inst, + struct arb_program *Program, GLint * coord) +{ + *coord = parse_integer (inst, Program); + + if ((*coord < 0) || (*coord >= (GLint) ctx->Const.MaxClipPlanes)) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid clip plane index"); + _mesa_error (ctx, GL_INVALID_OPERATION, "Invalid clip plane index"); + return 1; + } + + return 0; +} + + +/** + * \return 0 on front face, 1 on back face + */ +static GLuint +parse_face_type (GLubyte ** inst) +{ + switch (*(*inst)++) { + case FACE_FRONT: + return 0; + + case FACE_BACK: + return 1; + } + return 0; +} + + +/** + * Given a matrix and a modifier token on the binary array, return tokens + * that _mesa_fetch_state() [program.c] can understand. + * + * \param matrix - the matrix we are talking about + * \param matrix_idx - the index of the matrix we have (for texture & program matricies) + * \param matrix_modifier - the matrix modifier (trans, inv, etc) + * \return 0 on sucess, 1 on failure + */ +static GLuint +parse_matrix (GLcontext * ctx, GLubyte ** inst, struct arb_program *Program, + GLint * matrix, GLint * matrix_idx, GLint * matrix_modifier) +{ + GLubyte mat = *(*inst)++; + + *matrix_idx = 0; + + switch (mat) { + case MATRIX_MODELVIEW: + *matrix = STATE_MODELVIEW; + *matrix_idx = parse_integer (inst, Program); + if (*matrix_idx > 0) { + _mesa_set_program_error (ctx, Program->Position, + "ARB_vertex_blend not supported\n"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "ARB_vertex_blend not supported\n"); + return 1; + } + break; + + case MATRIX_PROJECTION: + *matrix = STATE_PROJECTION; + break; + + case MATRIX_MVP: + *matrix = STATE_MVP; + break; + + case MATRIX_TEXTURE: + *matrix = STATE_TEXTURE; + *matrix_idx = parse_integer (inst, Program); + if (*matrix_idx >= (GLint) ctx->Const.MaxTextureUnits) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid Texture Unit"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Invalid Texture Unit: %d", *matrix_idx); + return 1; + } + break; + + /* This is not currently supported (ARB_matrix_palette) */ + case MATRIX_PALETTE: + *matrix_idx = parse_integer (inst, Program); + _mesa_set_program_error (ctx, Program->Position, + "ARB_matrix_palette not supported\n"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "ARB_matrix_palette not supported\n"); + return 1; + break; + + case MATRIX_PROGRAM: + *matrix = STATE_PROGRAM; + *matrix_idx = parse_integer (inst, Program); + if (*matrix_idx >= (GLint) ctx->Const.MaxProgramMatrices) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid Program Matrix"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Invalid Program Matrix: %d", *matrix_idx); + return 1; + } + break; + } + + switch (*(*inst)++) { + case MATRIX_MODIFIER_IDENTITY: + *matrix_modifier = 0; + break; + case MATRIX_MODIFIER_INVERSE: + *matrix_modifier = STATE_MATRIX_INVERSE; + break; + case MATRIX_MODIFIER_TRANSPOSE: + *matrix_modifier = STATE_MATRIX_TRANSPOSE; + break; + case MATRIX_MODIFIER_INVTRANS: + *matrix_modifier = STATE_MATRIX_INVTRANS; + break; + } + + return 0; +} + + +/** + * This parses a state string (rather, the binary version of it) into + * a 6-token sequence as described in _mesa_fetch_state() [program.c] + * + * \param inst - the start in the binary arry to start working from + * \param state_tokens - the storage for the 6-token state description + * \return - 0 on sucess, 1 on error + */ +static GLuint +parse_state_single_item (GLcontext * ctx, GLubyte ** inst, + struct arb_program *Program, GLint * state_tokens) +{ + switch (*(*inst)++) { + case STATE_MATERIAL_PARSER: + state_tokens[0] = STATE_MATERIAL; + state_tokens[1] = parse_face_type (inst); + switch (*(*inst)++) { + case MATERIAL_AMBIENT: + state_tokens[2] = STATE_AMBIENT; + break; + case MATERIAL_DIFFUSE: + state_tokens[2] = STATE_DIFFUSE; + break; + case MATERIAL_SPECULAR: + state_tokens[2] = STATE_SPECULAR; + break; + case MATERIAL_EMISSION: + state_tokens[2] = STATE_EMISSION; + break; + case MATERIAL_SHININESS: + state_tokens[2] = STATE_SHININESS; + break; + } + break; + + case STATE_LIGHT_PARSER: + state_tokens[0] = STATE_LIGHT; + state_tokens[1] = parse_integer (inst, Program); + + /* Check the value of state_tokens[1] against the # of lights */ + if (state_tokens[1] >= (GLint) ctx->Const.MaxLights) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid Light Number"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Invalid Light Number: %d", state_tokens[1]); + return 1; + } + + switch (*(*inst)++) { + case LIGHT_AMBIENT: + state_tokens[2] = STATE_AMBIENT; + break; + case LIGHT_DIFFUSE: + state_tokens[2] = STATE_DIFFUSE; + break; + case LIGHT_SPECULAR: + state_tokens[2] = STATE_SPECULAR; + break; + case LIGHT_POSITION: + state_tokens[2] = STATE_POSITION; + break; + case LIGHT_ATTENUATION: + state_tokens[2] = STATE_ATTENUATION; + break; + case LIGHT_HALF: + state_tokens[2] = STATE_HALF; + break; + case LIGHT_SPOT_DIRECTION: + state_tokens[2] = STATE_SPOT_DIRECTION; + break; + } + break; + + case STATE_LIGHT_MODEL: + switch (*(*inst)++) { + case LIGHT_MODEL_AMBIENT: + state_tokens[0] = STATE_LIGHTMODEL_AMBIENT; + break; + case LIGHT_MODEL_SCENECOLOR: + state_tokens[0] = STATE_LIGHTMODEL_SCENECOLOR; + state_tokens[1] = parse_face_type (inst); + break; + } + break; + + case STATE_LIGHT_PROD: + state_tokens[0] = STATE_LIGHTPROD; + state_tokens[1] = parse_integer (inst, Program); + + /* Check the value of state_tokens[1] against the # of lights */ + if (state_tokens[1] >= (GLint) ctx->Const.MaxLights) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid Light Number"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Invalid Light Number: %d", state_tokens[1]); + return 1; + } + + state_tokens[2] = parse_face_type (inst); + switch (*(*inst)++) { + case LIGHT_PROD_AMBIENT: + state_tokens[3] = STATE_AMBIENT; + break; + case LIGHT_PROD_DIFFUSE: + state_tokens[3] = STATE_DIFFUSE; + break; + case LIGHT_PROD_SPECULAR: + state_tokens[3] = STATE_SPECULAR; + break; + } + break; + + + case STATE_FOG: + switch (*(*inst)++) { + case FOG_COLOR: + state_tokens[0] = STATE_FOG_COLOR; + break; + case FOG_PARAMS: + state_tokens[0] = STATE_FOG_PARAMS; + break; + } + break; + + case STATE_TEX_ENV: + state_tokens[1] = parse_integer (inst, Program); + switch (*(*inst)++) { + case TEX_ENV_COLOR: + state_tokens[0] = STATE_TEXENV_COLOR; + break; + } + break; + + case STATE_TEX_GEN: + { + GLuint type, coord; + + state_tokens[0] = STATE_TEXGEN; + /*state_tokens[1] = parse_integer (inst, Program);*/ /* Texture Unit */ + + if (parse_texcoord_num (ctx, inst, Program, &coord)) + return 1; + state_tokens[1] = coord; + + /* EYE or OBJECT */ + type = *(*inst++); + + /* 0 - s, 1 - t, 2 - r, 3 - q */ + coord = *(*inst++); + + if (type == TEX_GEN_EYE) { + switch (coord) { + case COMPONENT_X: + state_tokens[2] = STATE_TEXGEN_EYE_S; + break; + case COMPONENT_Y: + state_tokens[2] = STATE_TEXGEN_EYE_T; + break; + case COMPONENT_Z: + state_tokens[2] = STATE_TEXGEN_EYE_R; + break; + case COMPONENT_W: + state_tokens[2] = STATE_TEXGEN_EYE_Q; + break; + } + } + else { + switch (coord) { + case COMPONENT_X: + state_tokens[2] = STATE_TEXGEN_OBJECT_S; + break; + case COMPONENT_Y: + state_tokens[2] = STATE_TEXGEN_OBJECT_T; + break; + case COMPONENT_Z: + state_tokens[2] = STATE_TEXGEN_OBJECT_R; + break; + case COMPONENT_W: + state_tokens[2] = STATE_TEXGEN_OBJECT_Q; + break; + } + } + } + break; + + case STATE_DEPTH: + switch (*(*inst)++) { + case DEPTH_RANGE: + state_tokens[0] = STATE_DEPTH_RANGE; + break; + } + break; + + case STATE_CLIP_PLANE: + state_tokens[0] = STATE_CLIPPLANE; + state_tokens[1] = parse_integer (inst, Program); + if (parse_clipplane_num (ctx, inst, Program, &state_tokens[1])) + return 1; + break; + + case STATE_POINT: + switch (*(*inst++)) { + case POINT_SIZE: + state_tokens[0] = STATE_POINT_SIZE; + break; + + case POINT_ATTENUATION: + state_tokens[0] = STATE_POINT_ATTENUATION; + break; + } + break; + + /* XXX: I think this is the correct format for a matrix row */ + case STATE_MATRIX_ROWS: + state_tokens[0] = STATE_MATRIX; + if (parse_matrix + (ctx, inst, Program, &state_tokens[1], &state_tokens[2], + &state_tokens[5])) + return 1; + + state_tokens[3] = parse_integer (inst, Program); /* The first row to grab */ + + if ((**inst) != 0) { /* Either the last row, 0 */ + state_tokens[4] = parse_integer (inst, Program); + if (state_tokens[4] < state_tokens[3]) { + _mesa_set_program_error (ctx, Program->Position, + "Second matrix index less than the first"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Second matrix index (%d) less than the first (%d)", + state_tokens[4], state_tokens[3]); + return 1; + } + } + else { + state_tokens[4] = state_tokens[3]; + (*inst)++; + } + break; + } + + return 0; +} + +/** + * This parses a state string (rather, the binary version of it) into + * a 6-token similar for the state fetching code in program.c + * + * One might ask, why fetch these parameters into just like you fetch + * state when they are already stored in other places? + * + * Because of array offsets -> We can stick env/local parameters in the + * middle of a parameter array and then index someplace into the array + * when we execute. + * + * One optimization might be to only do this for the cases where the + * env/local parameters end up inside of an array, and leave the + * single parameters (or arrays of pure env/local pareameters) in their + * respective register files. + * + * For ENV parameters, the format is: + * state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM + * state_tokens[1] = STATE_ENV + * state_tokens[2] = the parameter index + * + * for LOCAL parameters, the format is: + * state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM + * state_tokens[1] = STATE_LOCAL + * state_tokens[2] = the parameter index + * + * \param inst - the start in the binary arry to start working from + * \param state_tokens - the storage for the 6-token state description + * \return - 0 on sucess, 1 on failure + */ +static GLuint +parse_program_single_item (GLcontext * ctx, GLubyte ** inst, + struct arb_program *Program, GLint * state_tokens) +{ + if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) + state_tokens[0] = STATE_FRAGMENT_PROGRAM; + else + state_tokens[0] = STATE_VERTEX_PROGRAM; + + + switch (*(*inst)++) { + case PROGRAM_PARAM_ENV: + state_tokens[1] = STATE_ENV; + state_tokens[2] = parse_integer (inst, Program); + + /* Check state_tokens[2] against the number of ENV parameters available */ + if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) && + (state_tokens[2] >= (GLint) ctx->Const.MaxFragmentProgramEnvParams)) + || + ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) && + (state_tokens[2] >= (GLint) ctx->Const.MaxVertexProgramEnvParams))) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid Program Env Parameter"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Invalid Program Env Parameter: %d", + state_tokens[2]); + return 1; + } + + break; + + case PROGRAM_PARAM_LOCAL: + state_tokens[1] = STATE_LOCAL; + state_tokens[2] = parse_integer (inst, Program); + + /* Check state_tokens[2] against the number of LOCAL parameters available */ + if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) && + (state_tokens[2] >= (GLint) ctx->Const.MaxFragmentProgramLocalParams)) + || + ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) && + (state_tokens[2] >= (GLint) ctx->Const.MaxVertexProgramLocalParams))) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid Program Local Parameter"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Invalid Program Local Parameter: %d", + state_tokens[2]); + return 1; + } + break; + } + + return 0; +} + +/** + * For ARB_vertex_program, programs are not allowed to use both an explicit + * vertex attribute and a generic vertex attribute corresponding to the same + * state. See section 2.14.3.1 of the GL_ARB_vertex_program spec. + * + * This will walk our var_cache and make sure that nobody does anything fishy. + * + * \return 0 on sucess, 1 on error + */ +static GLuint +generic_attrib_check(struct var_cache *vc_head) +{ + int a; + struct var_cache *curr; + GLboolean explicitAttrib[MAX_VERTEX_PROGRAM_ATTRIBS], + genericAttrib[MAX_VERTEX_PROGRAM_ATTRIBS]; + + for (a=0; atype == vt_attrib) { + if (curr->attrib_is_generic) + genericAttrib[ curr->attrib_binding_idx ] = GL_TRUE; + else + explicitAttrib[ curr->attrib_binding_idx ] = GL_TRUE; + } + + curr = curr->next; + } + + for (a=0; aBase.Target == GL_FRAGMENT_PROGRAM_ARB) { + switch (*(*inst)++) { + case FRAGMENT_ATTRIB_COLOR: + err = parse_color_type (ctx, inst, Program, &coord); + *binding = FRAG_ATTRIB_COL0 + coord; + *binding_idx = 1 + coord; + break; + + case FRAGMENT_ATTRIB_TEXCOORD: + err = parse_texcoord_num (ctx, inst, Program, &texcoord); + *binding = FRAG_ATTRIB_TEX0 + texcoord; + *binding_idx = 4 + texcoord; + break; + + case FRAGMENT_ATTRIB_FOGCOORD: + *binding = FRAG_ATTRIB_FOGC; + *binding_idx = 3; + break; + + case FRAGMENT_ATTRIB_POSITION: + *binding = FRAG_ATTRIB_WPOS; + *binding_idx = 0; + break; + + default: + err = 1; + break; + } + } + else { + switch (*(*inst)++) { + case VERTEX_ATTRIB_POSITION: + *binding = VERT_ATTRIB_POS; + *binding_idx = 0; + break; + + case VERTEX_ATTRIB_WEIGHT: + { + GLint weight; + + err = parse_weight_num (ctx, inst, Program, &weight); + *binding = VERT_ATTRIB_WEIGHT; + *binding_idx = 1; + } + _mesa_set_program_error (ctx, Program->Position, + "ARB_vertex_blend not supported\n"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "ARB_vertex_blend not supported\n"); + return 1; + break; + + case VERTEX_ATTRIB_NORMAL: + *binding = VERT_ATTRIB_NORMAL; + *binding_idx = 2; + break; + + case VERTEX_ATTRIB_COLOR: + { + GLint color; + + err = parse_color_type (ctx, inst, Program, &color); + if (color) { + *binding = VERT_ATTRIB_COLOR1; + *binding_idx = 4; + } + else { + *binding = VERT_ATTRIB_COLOR0; + *binding_idx = 3; + } + } + break; + + case VERTEX_ATTRIB_FOGCOORD: + *binding = VERT_ATTRIB_FOG; + *binding_idx = 5; + break; + + case VERTEX_ATTRIB_TEXCOORD: + { + GLuint unit; + + err = parse_texcoord_num (ctx, inst, Program, &unit); + *binding = VERT_ATTRIB_TEX0 + unit; + *binding_idx = 8 + unit; + } + break; + + /* It looks like we don't support this at all, atm */ + case VERTEX_ATTRIB_MATRIXINDEX: + parse_integer (inst, Program); + _mesa_set_program_error (ctx, Program->Position, + "ARB_palette_matrix not supported"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "ARB_palette_matrix not supported"); + return 1; + break; + + case VERTEX_ATTRIB_GENERIC: + { + GLuint attrib; + + if (!parse_generic_attrib_num(ctx, inst, Program, &attrib)) { + *is_generic = 1; + switch (attrib) { + case 0: + *binding = VERT_ATTRIB_POS; + break; + case 1: + *binding = VERT_ATTRIB_WEIGHT; + break; + case 2: + *binding = VERT_ATTRIB_NORMAL; + break; + case 3: + *binding = VERT_ATTRIB_COLOR0; + break; + case 4: + *binding = VERT_ATTRIB_COLOR1; + break; + case 5: + *binding = VERT_ATTRIB_FOG; + break; + case 6: + break; + case 7: + break; + default: + *binding = VERT_ATTRIB_TEX0 + (attrib-8); + break; + } + *binding_idx = attrib; + } + } + break; + + default: + err = 1; + break; + } + } + + /* Can this even happen? */ + if (err) { + _mesa_set_program_error (ctx, Program->Position, + "Bad attribute binding"); + _mesa_error (ctx, GL_INVALID_OPERATION, "Bad attribute binding"); + } + + Program->InputsRead |= (1 << *binding_idx); + + return err; +} + +/** + * This translates between a binary token for an output variable type + * and the mesa token for the same thing. + * + * + * XXX: What is the 'name' for vertex program state? -> do we need it? + * I don't think we do; + * + * See nvfragprog.h for definitions + * + * \param inst - The parsed tokens + * \param binding - The name of the state we are binding too + * \param binding_idx - The index into the result register file that this is bound too + * + * See nvfragparse.c for the register file layout for fragment programs + * See nvvertparse.c for the register file layout for vertex programs + */ +static GLuint +parse_result_binding (GLcontext * ctx, GLubyte ** inst, GLuint * binding, + GLuint * binding_idx, struct arb_program *Program) +{ + GLuint b, out_color; + + switch (*(*inst)++) { + case FRAGMENT_RESULT_COLOR: + /* for frag programs, this is FRAGMENT_RESULT_COLOR */ + if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) { + /* This gets result of the color buffer we're supposed to + * draw into + */ + parse_output_color_num(ctx, inst, Program, &out_color); + + *binding = FRAG_OUTPUT_COLR; + + /* XXX: We're ignoring the color buffer for now. */ + *binding_idx = 0; + } + /* for vtx programs, this is VERTEX_RESULT_POSITION */ + else { + *binding_idx = 0; + } + break; + + case FRAGMENT_RESULT_DEPTH: + /* for frag programs, this is FRAGMENT_RESULT_DEPTH */ + if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) { + *binding = FRAG_OUTPUT_DEPR; + *binding_idx = 2; + } + /* for vtx programs, this is VERTEX_RESULT_COLOR */ + else { + GLint color_type; + GLuint face_type = parse_face_type(inst); + GLint color_type_ret = parse_color_type(ctx, inst, Program, &color_type); + + /* back face */ + if (face_type) { + if (color_type_ret) return 1; + + /* secondary color */ + if (color_type) { + *binding_idx = 4; + } + /* primary color */ + else { + *binding_idx = 3; + } + } + /* front face */ + else { + /* secondary color */ + if (color_type) { + *binding_idx = 2; + } + /* primary color */ + else { + *binding_idx = 1; + } + } + } + break; + + case VERTEX_RESULT_FOGCOORD: + *binding_idx = 5; + break; + + case VERTEX_RESULT_POINTSIZE: + *binding_idx = 6; + break; + + case VERTEX_RESULT_TEXCOORD: + if (parse_texcoord_num (ctx, inst, Program, &b)) + return 1; + *binding_idx = 7 + b; + break; + } + + Program->OutputsWritten |= (1 << *binding_idx); + + return 0; +} + +/** + * This handles the declaration of ATTRIB variables + * + * XXX: Still needs + * parse_vert_attrib_binding(), or something like that + * + * \return 0 on sucess, 1 on error + */ +static GLint +parse_attrib (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program) +{ + GLuint found; + char *error_msg; + struct var_cache *attrib_var; + + attrib_var = parse_string (inst, vc_head, Program, &found); + Program->Position = parse_position (inst); + if (found) { + error_msg = (char *) + _mesa_malloc (_mesa_strlen ((char *) attrib_var->name) + 40); + _mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s", + attrib_var->name); + + _mesa_set_program_error (ctx, Program->Position, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, error_msg); + + _mesa_free (error_msg); + return 1; + } + + attrib_var->type = vt_attrib; + + /* I think this is ok now - karl */ + /* XXX: */ + /*if (Program->type == GL_FRAGMENT_PROGRAM_ARB) */ + { + if (parse_attrib_binding + (ctx, inst, Program, &attrib_var->attrib_binding, + &attrib_var->attrib_binding_idx, &attrib_var->attrib_is_generic)) + return 1; + if (generic_attrib_check(*vc_head)) { + _mesa_set_program_error (ctx, Program->Position, + "Cannot use both a generic vertex attribute and a specific attribute of the same type"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Cannot use both a generic vertex attribute and a specific attribute of the same type"); + return 1; + } + + } + + Program->Base.NumAttributes++; + return 0; +} + +/** + * \param use -- TRUE if we're called when declaring implicit parameters, + * FALSE if we're declaraing variables. This has to do with + * if we get a signed or unsigned float for scalar constants + */ +static GLuint +parse_param_elements (GLcontext * ctx, GLubyte ** inst, + struct var_cache *param_var, + struct arb_program *Program, GLboolean use) +{ + GLint idx; + GLuint err; + GLint state_tokens[6]; + GLfloat const_values[4]; + + err = 0; + + switch (*(*inst)++) { + case PARAM_STATE_ELEMENT: + + if (parse_state_single_item (ctx, inst, Program, state_tokens)) + return 1; + + /* If we adding STATE_MATRIX that has multiple rows, we need to + * unroll it and call _mesa_add_state_reference() for each row + */ + if ((state_tokens[0] == STATE_MATRIX) + && (state_tokens[3] != state_tokens[4])) { + GLint row; + GLint first_row = state_tokens[3]; + GLint last_row = state_tokens[4]; + + for (row = first_row; row <= last_row; row++) { + state_tokens[3] = state_tokens[4] = row; + + idx = + _mesa_add_state_reference (Program->Parameters, + state_tokens); + if (param_var->param_binding_begin == ~0U) + param_var->param_binding_begin = idx; + param_var->param_binding_length++; + Program->Base.NumParameters++; + } + } + else { + idx = + _mesa_add_state_reference (Program->Parameters, state_tokens); + if (param_var->param_binding_begin == ~0U) + param_var->param_binding_begin = idx; + param_var->param_binding_length++; + Program->Base.NumParameters++; + } + break; + + case PARAM_PROGRAM_ELEMENT: + + if (parse_program_single_item (ctx, inst, Program, state_tokens)) + return 1; + idx = _mesa_add_state_reference (Program->Parameters, state_tokens); + if (param_var->param_binding_begin == ~0U) + param_var->param_binding_begin = idx; + param_var->param_binding_length++; + Program->Base.NumParameters++; + + /* Check if there is more: 0 -> we're done, else its an integer */ + if (**inst) { + GLuint out_of_range, new_idx; + GLuint start_idx = state_tokens[2] + 1; + GLuint end_idx = parse_integer (inst, Program); + + out_of_range = 0; + if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) { + if (((state_tokens[1] == STATE_ENV) + && (end_idx >= ctx->Const.MaxFragmentProgramEnvParams)) + || ((state_tokens[1] == STATE_LOCAL) + && (end_idx >= + ctx->Const.MaxFragmentProgramLocalParams))) + out_of_range = 1; + } + else { + if (((state_tokens[1] == STATE_ENV) + && (end_idx >= ctx->Const.MaxVertexProgramEnvParams)) + || ((state_tokens[1] == STATE_LOCAL) + && (end_idx >= + ctx->Const.MaxVertexProgramLocalParams))) + out_of_range = 1; + } + if (out_of_range) { + _mesa_set_program_error (ctx, Program->Position, + "Invalid Program Parameter"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Invalid Program Parameter: %d", end_idx); + return 1; + } + + for (new_idx = start_idx; new_idx <= end_idx; new_idx++) { + state_tokens[2] = new_idx; + idx = + _mesa_add_state_reference (Program->Parameters, + state_tokens); + param_var->param_binding_length++; + Program->Base.NumParameters++; + } + } + else + { + (*inst)++; + } + break; + + case PARAM_CONSTANT: + parse_constant (inst, const_values, Program, use); + idx = + _mesa_add_named_constant (Program->Parameters, + (char *) param_var->name, const_values); + if (param_var->param_binding_begin == ~0U) + param_var->param_binding_begin = idx; + param_var->param_binding_length++; + Program->Base.NumParameters++; + break; + + default: + _mesa_set_program_error (ctx, Program->Position, + "Unexpected token in parse_param_elements()"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Unexpected token in parse_param_elements()"); + return 1; + } + + /* Make sure we haven't blown past our parameter limits */ + if (((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) && + (Program->Base.NumParameters >= + ctx->Const.MaxVertexProgramLocalParams)) + || ((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) + && (Program->Base.NumParameters >= + ctx->Const.MaxFragmentProgramLocalParams))) { + _mesa_set_program_error (ctx, Program->Position, + "Too many parameter variables"); + _mesa_error (ctx, GL_INVALID_OPERATION, "Too many parameter variables"); + return 1; + } + + return err; +} + +/** + * This picks out PARAM program parameter bindings. + * + * XXX: This needs to be stressed & tested + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_param (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program) +{ + GLuint found, err; + GLint specified_length; + char *error_msg; + struct var_cache *param_var; + + err = 0; + param_var = parse_string (inst, vc_head, Program, &found); + Program->Position = parse_position (inst); + + if (found) { + error_msg = (char *) _mesa_malloc (_mesa_strlen ((char *) param_var->name) + 40); + _mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s", + param_var->name); + + _mesa_set_program_error (ctx, Program->Position, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, error_msg); + + _mesa_free (error_msg); + return 1; + } + + specified_length = parse_integer (inst, Program); + + if (specified_length < 0) { + _mesa_set_program_error (ctx, Program->Position, + "Negative parameter array length"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Negative parameter array length: %d", specified_length); + return 1; + } + + param_var->type = vt_param; + param_var->param_binding_length = 0; + + /* Right now, everything is shoved into the main state register file. + * + * In the future, it would be nice to leave things ENV/LOCAL params + * in their respective register files, if possible + */ + param_var->param_binding_type = PROGRAM_STATE_VAR; + + /* Remember to: + * * - add each guy to the parameter list + * * - increment the param_var->param_binding_len + * * - store the param_var->param_binding_begin for the first one + * * - compare the actual len to the specified len at the end + */ + while (**inst != PARAM_NULL) { + if (parse_param_elements (ctx, inst, param_var, Program, GL_FALSE)) + return 1; + } + + /* Test array length here! */ + if (specified_length) { + if (specified_length != (int)param_var->param_binding_length) { + _mesa_set_program_error (ctx, Program->Position, + "Declared parameter array length does not match parameter list"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Declared parameter array length does not match parameter list"); + } + } + + (*inst)++; + + return 0; +} + +/** + * + */ +static GLuint +parse_param_use (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program, struct var_cache **new_var) +{ + struct var_cache *param_var; + + /* First, insert a dummy entry into the var_cache */ + var_cache_create (¶m_var); + param_var->name = (GLubyte *) _mesa_strdup (" "); + param_var->type = vt_param; + + param_var->param_binding_length = 0; + /* Don't fill in binding_begin; We use the default value of -1 + * to tell if its already initialized, elsewhere. + * + * param_var->param_binding_begin = 0; + */ + param_var->param_binding_type = PROGRAM_STATE_VAR; + + var_cache_append (vc_head, param_var); + + /* Then fill it with juicy parameter goodness */ + if (parse_param_elements (ctx, inst, param_var, Program, GL_TRUE)) + return 1; + + *new_var = param_var; + + return 0; +} + + +/** + * This handles the declaration of TEMP variables + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_temp (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program) +{ + GLuint found; + struct var_cache *temp_var; + char *error_msg; + + while (**inst != 0) { + temp_var = parse_string (inst, vc_head, Program, &found); + Program->Position = parse_position (inst); + if (found) { + error_msg = (char *) + _mesa_malloc (_mesa_strlen ((char *) temp_var->name) + 40); + _mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s", + temp_var->name); + + _mesa_set_program_error (ctx, Program->Position, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, error_msg); + + _mesa_free (error_msg); + return 1; + } + + temp_var->type = vt_temp; + + if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) && + (Program->Base.NumTemporaries >= + ctx->Const.MaxFragmentProgramTemps)) + || ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) + && (Program->Base.NumTemporaries >= + ctx->Const.MaxVertexProgramTemps))) { + _mesa_set_program_error (ctx, Program->Position, + "Too many TEMP variables declared"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Too many TEMP variables declared"); + return 1; + } + + temp_var->temp_binding = Program->Base.NumTemporaries; + Program->Base.NumTemporaries++; + } + (*inst)++; + + return 0; +} + +/** + * This handles variables of the OUTPUT variety + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_output (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program) +{ + GLuint found; + struct var_cache *output_var; + + output_var = parse_string (inst, vc_head, Program, &found); + Program->Position = parse_position (inst); + if (found) { + char *error_msg; + error_msg = (char *) + _mesa_malloc (_mesa_strlen ((char *) output_var->name) + 40); + _mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s", + output_var->name); + + _mesa_set_program_error (ctx, Program->Position, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, error_msg); + + _mesa_free (error_msg); + return 1; + } + + output_var->type = vt_output; + return parse_result_binding (ctx, inst, &output_var->output_binding, + &output_var->output_binding_idx, Program); +} + +/** + * This handles variables of the ALIAS kind + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_alias (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program) +{ + GLuint found; + struct var_cache *temp_var; + char *error_msg; + + + temp_var = parse_string (inst, vc_head, Program, &found); + Program->Position = parse_position (inst); + + if (found) { + error_msg = (char *) + _mesa_malloc (_mesa_strlen ((char *) temp_var->name) + 40); + _mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s", + temp_var->name); + + _mesa_set_program_error (ctx, Program->Position, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, error_msg); + + _mesa_free (error_msg); + return 1; + } + + temp_var->type = vt_alias; + temp_var->alias_binding = parse_string (inst, vc_head, Program, &found); + Program->Position = parse_position (inst); + + if (!found) + { + error_msg = (char *) + _mesa_malloc (_mesa_strlen ((char *) temp_var->name) + 40); + _mesa_sprintf (error_msg, "Alias value %s is not defined", + temp_var->alias_binding->name); + + _mesa_set_program_error (ctx, Program->Position, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, error_msg); + + _mesa_free (error_msg); + return 1; + } + + return 0; +} + +/** + * This handles variables of the ADDRESS kind + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_address (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program) +{ + GLuint found; + struct var_cache *temp_var; + char *error_msg; + + while (**inst != 0) { + temp_var = parse_string (inst, vc_head, Program, &found); + Program->Position = parse_position (inst); + if (found) { + error_msg = (char *) + _mesa_malloc (_mesa_strlen ((char *) temp_var->name) + 40); + _mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s", + temp_var->name); + + _mesa_set_program_error (ctx, Program->Position, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, error_msg); + + _mesa_free (error_msg); + return 1; + } + + temp_var->type = vt_address; + + if (Program->Base.NumAddressRegs >= + ctx->Const.MaxVertexProgramAddressRegs) { + _mesa_set_program_error (ctx, Program->Position, + "Too many ADDRESS variables declared"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Too many ADDRESS variables declared"); + return 1; + } + + temp_var->address_binding = Program->Base.NumAddressRegs; + Program->Base.NumAddressRegs++; + } + (*inst)++; + + return 0; +} + +/** + * Parse a program declaration + * + * \return 0 on sucess, 1 on error + */ +static GLint +parse_declaration (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program) +{ + GLint err = 0; + + switch (*(*inst)++) { + case ADDRESS: + err = parse_address (ctx, inst, vc_head, Program); + break; + + case ALIAS: + err = parse_alias (ctx, inst, vc_head, Program); + break; + + case ATTRIB: + err = parse_attrib (ctx, inst, vc_head, Program); + break; + + case OUTPUT: + err = parse_output (ctx, inst, vc_head, Program); + break; + + case PARAM: + err = parse_param (ctx, inst, vc_head, Program); + break; + + case TEMP: + err = parse_temp (ctx, inst, vc_head, Program); + break; + } + + return err; +} + +/** + * Handle the parsing out of a masked destination register + * + * If we are a vertex program, make sure we don't write to + * result.position of we have specified that the program is + * position invariant + * + * \param File - The register file we write to + * \param Index - The register index we write to + * \param WriteMask - The mask controlling which components we write (1->write) + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_masked_dst_reg (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, struct arb_program *Program, + GLint * File, GLint * Index, GLint *WriteMask) +{ + GLuint result, tmp; + struct var_cache *dst; + + /* We either have a result register specified, or a + * variable that may or may not be writable + */ + switch (*(*inst)++) { + case REGISTER_RESULT: + if (parse_result_binding + (ctx, inst, &result, (GLuint *) Index, Program)) + return 1; + *File = PROGRAM_OUTPUT; + break; + + case REGISTER_ESTABLISHED_NAME: + dst = parse_string (inst, vc_head, Program, &result); + Program->Position = parse_position (inst); + + /* If the name has never been added to our symbol table, we're hosed */ + if (!result) { + _mesa_set_program_error (ctx, Program->Position, + "0: Undefined variable"); + _mesa_error (ctx, GL_INVALID_OPERATION, "0: Undefined variable: %s", + dst->name); + return 1; + } + + switch (dst->type) { + case vt_output: + *File = PROGRAM_OUTPUT; + *Index = dst->output_binding_idx; + break; + + case vt_temp: + *File = PROGRAM_TEMPORARY; + *Index = dst->temp_binding; + break; + + /* If the var type is not vt_output or vt_temp, no go */ + default: + _mesa_set_program_error (ctx, Program->Position, + "Destination register is read only"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Destination register is read only: %s", + dst->name); + return 1; + } + break; + + default: + _mesa_set_program_error (ctx, Program->Position, + "Unexpected opcode in parse_masked_dst_reg()"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Unexpected opcode in parse_masked_dst_reg()"); + return 1; + } + + + /* Position invariance test */ + /* This test is done now in syntax portion - when position invariance OPTION + is specified, "result.position" rule is disabled so there is no way + to write the position + */ + /*if ((Program->HintPositionInvariant) && (*File == PROGRAM_OUTPUT) && + (*Index == 0)) { + _mesa_set_program_error (ctx, Program->Position, + "Vertex program specified position invariance and wrote vertex position"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Vertex program specified position invariance and wrote vertex position"); + }*/ + + /* And then the mask. + * w,a -> bit 0 + * z,b -> bit 1 + * y,g -> bit 2 + * x,r -> bit 3 + * + * ==> Need to reverse the order of bits for this! + */ + tmp = (GLint) *(*inst)++; + *WriteMask = (((tmp>>3) & 0x1) | + ((tmp>>1) & 0x2) | + ((tmp<<1) & 0x4) | + ((tmp<<3) & 0x8)); + + return 0; +} + + +/** + * Handle the parsing of a address register + * + * \param Index - The register index we write to + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_address_reg (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, + struct arb_program *Program, GLint * Index) +{ + struct var_cache *dst; + GLuint result; + (void) Index; + + dst = parse_string (inst, vc_head, Program, &result); + Program->Position = parse_position (inst); + + /* If the name has never been added to our symbol table, we're hosed */ + if (!result) { + _mesa_set_program_error (ctx, Program->Position, "Undefined variable"); + _mesa_error (ctx, GL_INVALID_OPERATION, "Undefined variable: %s", + dst->name); + return 1; + } + + if (dst->type != vt_address) { + _mesa_set_program_error (ctx, Program->Position, + "Variable is not of type ADDRESS"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Variable: %s is not of type ADDRESS", dst->name); + return 1; + } + + return 0; +} + +#if 0 /* unused */ +/** + * Handle the parsing out of a masked address register + * + * \param Index - The register index we write to + * \param WriteMask - The mask controlling which components we write (1->write) + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_masked_address_reg (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, + struct arb_program *Program, GLint * Index, + GLboolean * WriteMask) +{ + if (parse_address_reg (ctx, inst, vc_head, Program, Index)) + return 1; + + /* This should be 0x8 */ + (*inst)++; + + /* Writemask of .x is implied */ + WriteMask[0] = 1; + WriteMask[1] = WriteMask[2] = WriteMask[3] = 0; + + return 0; +} +#endif + +/** + * Parse out a swizzle mask. + * + * The values in the input stream are: + * COMPONENT_X -> x/r + * COMPONENT_Y -> y/g + * COMPONENT_Z-> z/b + * COMPONENT_W-> w/a + * + * The values in the output mask are: + * 0 -> x/r + * 1 -> y/g + * 2 -> z/b + * 3 -> w/a + * + * The len parameter allows us to grab 4 components for a vector + * swizzle, or just 1 component for a scalar src register selection + */ +static GLuint +parse_swizzle_mask (GLubyte ** inst, GLubyte * mask, GLint len) +{ + GLint a; + + for (a = 0; a < 4; a++) + mask[a] = a; + + for (a = 0; a < len; a++) { + switch (*(*inst)++) { + case COMPONENT_X: + mask[a] = 0; + break; + + case COMPONENT_Y: + mask[a] = 1; + break; + + case COMPONENT_Z: + mask[a] = 2; + break; + + case COMPONENT_W: + mask[a] = 3; + break; + } + } + + return 0; +} + +/** + */ +static GLuint +parse_extended_swizzle_mask(GLubyte **inst, GLubyte *mask, GLubyte *negate) +{ + GLint a; + GLubyte swz; + + *negate = 0x0; + for (a = 0; a < 4; a++) { + if (parse_sign (inst) == -1) + *negate |= (1 << a); + + swz = *(*inst)++; + + switch (swz) { + case COMPONENT_0: + mask[a] = SWIZZLE_ZERO; + break; + case COMPONENT_1: + mask[a] = SWIZZLE_ONE; + break; + case COMPONENT_X: + mask[a] = SWIZZLE_X; + break; + case COMPONENT_Y: + mask[a] = SWIZZLE_Y; + break; + case COMPONENT_Z: + mask[a] = SWIZZLE_Z; + break; + case COMPONENT_W: + mask[a] = SWIZZLE_W; + break; + + } +#if 0 + if (swz == 0) + mask[a] = SWIZZLE_ZERO; + else if (swz == 1) + mask[a] = SWIZZLE_ONE; + else + mask[a] = swz - 2; +#endif + + } + + return 0; +} + + +static GLuint +parse_src_reg (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head, + struct arb_program *Program, GLint * File, GLint * Index, + GLboolean *IsRelOffset ) +{ + struct var_cache *src; + GLuint binding_state, binding_idx, is_generic, found; + GLint offset; + + *IsRelOffset = 0; + + /* And the binding for the src */ + switch (*(*inst)++) { + case REGISTER_ATTRIB: + if (parse_attrib_binding + (ctx, inst, Program, &binding_state, &binding_idx, &is_generic)) + return 1; + *File = PROGRAM_INPUT; + *Index = binding_idx; + + /* We need to insert a dummy variable into the var_cache so we can + * catch generic vertex attrib aliasing errors + */ + var_cache_create(&src); + src->type = vt_attrib; + src->name = (GLubyte *)_mesa_strdup("Dummy Attrib Variable"); + src->attrib_binding = binding_state; + src->attrib_binding_idx = binding_idx; + src->attrib_is_generic = is_generic; + var_cache_append(vc_head, src); + if (generic_attrib_check(*vc_head)) { + _mesa_set_program_error (ctx, Program->Position, + "Cannot use both a generic vertex attribute and a specific attribute of the same type"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Cannot use both a generic vertex attribute and a specific attribute of the same type"); + return 1; + } + break; + + case REGISTER_PARAM: + switch (**inst) { + case PARAM_ARRAY_ELEMENT: + (*inst)++; + src = parse_string (inst, vc_head, Program, &found); + Program->Position = parse_position (inst); + + if (!found) { + _mesa_set_program_error (ctx, Program->Position, + "2: Undefined variable"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "2: Undefined variable: %s", src->name); + return 1; + } + + *File = src->param_binding_type; + + switch (*(*inst)++) { + case ARRAY_INDEX_ABSOLUTE: + offset = parse_integer (inst, Program); + + if ((offset < 0) + || (offset >= (int)src->param_binding_length)) { + _mesa_set_program_error (ctx, Program->Position, + "Index out of range"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Index %d out of range for %s", offset, + src->name); + return 1; + } + + *Index = src->param_binding_begin + offset; + break; + + case ARRAY_INDEX_RELATIVE: + { + GLint addr_reg_idx, rel_off; + + /* First, grab the address regiseter */ + if (parse_address_reg (ctx, inst, vc_head, Program, &addr_reg_idx)) + return 1; + + /* And the .x */ + ((*inst)++); + ((*inst)++); + ((*inst)++); + ((*inst)++); + + /* Then the relative offset */ + if (parse_relative_offset(ctx, inst, Program, &rel_off)) return 1; + + /* And store it properly */ + *Index = src->param_binding_begin + rel_off; + *IsRelOffset = 1; + } + break; + } + break; + + default: + + if (parse_param_use (ctx, inst, vc_head, Program, &src)) + return 1; + + *File = src->param_binding_type; + *Index = src->param_binding_begin; + break; + } + break; + + case REGISTER_ESTABLISHED_NAME: + + src = parse_string (inst, vc_head, Program, &found); + Program->Position = parse_position (inst); + + /* If the name has never been added to our symbol table, we're hosed */ + if (!found) { + _mesa_set_program_error (ctx, Program->Position, + "3: Undefined variable"); + _mesa_error (ctx, GL_INVALID_OPERATION, "3: Undefined variable: %s", + src->name); + return 1; + } + + switch (src->type) { + case vt_attrib: + *File = PROGRAM_INPUT; + *Index = src->attrib_binding_idx; + break; + + /* XXX: We have to handle offsets someplace in here! -- or are those above? */ + case vt_param: + *File = src->param_binding_type; + *Index = src->param_binding_begin; + break; + + case vt_temp: + *File = PROGRAM_TEMPORARY; + *Index = src->temp_binding; + break; + + /* If the var type is vt_output no go */ + default: + _mesa_set_program_error (ctx, Program->Position, + "destination register is read only"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "destination register is read only: %s", + src->name); + return 1; + } + break; + + default: + _mesa_set_program_error (ctx, Program->Position, + "Unknown token in parse_src_reg"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Unknown token in parse_src_reg"); + return 1; + } + + return 0; +} + +/** + */ +static GLuint +parse_fp_vector_src_reg (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, struct arb_program *Program, + struct fp_src_register *reg ) +{ + + GLint File; + GLint Index; + GLboolean Negate; + GLubyte Swizzle[4]; + GLboolean IsRelOffset; + + /* Grab the sign */ + Negate = (parse_sign (inst) == -1) ? 0xf : 0x0; + + /* And the src reg */ + if (parse_src_reg (ctx, inst, vc_head, Program, &File, &Index, &IsRelOffset)) + return 1; + + /* finally, the swizzle */ + parse_swizzle_mask (inst, Swizzle, 4); + + reg->File = File; + reg->Index = Index; + reg->Abs = 0; /* NV only */ + reg->NegateAbs = 0; /* NV only */ + reg->NegateBase = Negate; + reg->Swizzle = (Swizzle[0] << 0 | + Swizzle[1] << 3 | + Swizzle[2] << 6 | + Swizzle[3] << 9); + + return 0; +} + + +static GLuint +parse_fp_dst_reg(GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, struct arb_program *Program, + struct fp_dst_register *reg ) +{ + GLint file, idx, mask; + + if (parse_masked_dst_reg (ctx, inst, vc_head, Program, &file, &idx, &mask)) + return 1; + + reg->CondMask = 0; /* NV only */ + reg->CondSwizzle = 0; /* NV only */ + reg->File = file; + reg->Index = idx; + reg->WriteMask = mask; + return 0; +} + + + +static GLuint +parse_fp_scalar_src_reg (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, struct arb_program *Program, + struct fp_src_register *reg ) +{ + + GLint File; + GLint Index; + GLboolean Negate; + GLubyte Swizzle[4]; + GLboolean IsRelOffset; + + /* Grab the sign */ + Negate = (parse_sign (inst) == -1) ? 0x1 : 0x0; + + /* And the src reg */ + if (parse_src_reg (ctx, inst, vc_head, Program, &File, &Index, &IsRelOffset)) + return 1; + + /* finally, the swizzle */ + parse_swizzle_mask (inst, Swizzle, 1); + + reg->File = File; + reg->Index = Index; + reg->Abs = 0; /* NV only */ + reg->NegateAbs = 0; /* NV only */ + reg->NegateBase = Negate; + reg->Swizzle = (Swizzle[0] << 0); + + return 0; +} + + +/** + * This is a big mother that handles getting opcodes into the instruction + * and handling the src & dst registers for fragment program instructions + */ +static GLuint +parse_fp_instruction (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, struct arb_program *Program, + struct fp_instruction *fp) +{ + GLint a; + GLuint texcoord; + GLubyte instClass, type, code; + GLboolean rel; + + /* No condition codes in ARB_fp */ + fp->UpdateCondRegister = 0; + + /* Record the position in the program string for debugging */ + fp->StringPos = Program->Position; + + fp->Data = NULL; + + fp->DstReg.File = 0xf; /* mark as undef */ + fp->SrcReg[0].File = 0xf; /* mark as undef */ + fp->SrcReg[1].File = 0xf; /* mark as undef */ + fp->SrcReg[2].File = 0xf; /* mark as undef */ + + /* OP_ALU_INST or OP_TEX_INST */ + instClass = *(*inst)++; + + /* OP_ALU_{VECTOR, SCALAR, BINSC, BIN, TRI, SWZ}, + * OP_TEX_{SAMPLE, KIL} + */ + type = *(*inst)++; + + /* The actual opcode name */ + code = *(*inst)++; + + /* Increment the correct count */ + switch (instClass) { + case OP_ALU_INST: + Program->NumAluInstructions++; + break; + case OP_TEX_INST: + Program->NumTexInstructions++; + break; + } + + fp->Saturate = 0; + fp->Precision = FLOAT32; + + fp->DstReg.CondMask = COND_TR; + + switch (type) { + case OP_ALU_VECTOR: + switch (code) { + case OP_ABS_SAT: + fp->Saturate = 1; + case OP_ABS: + fp->Opcode = FP_OPCODE_ABS; + break; + + case OP_FLR_SAT: + fp->Saturate = 1; + case OP_FLR: + fp->Opcode = FP_OPCODE_FLR; + break; + + case OP_FRC_SAT: + fp->Saturate = 1; + case OP_FRC: + fp->Opcode = FP_OPCODE_FRC; + break; + + case OP_LIT_SAT: + fp->Saturate = 1; + case OP_LIT: + fp->Opcode = FP_OPCODE_LIT; + break; + + case OP_MOV_SAT: + fp->Saturate = 1; + case OP_MOV: + fp->Opcode = FP_OPCODE_MOV; + break; + } + + if (parse_fp_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg)) + return 1; + + if (parse_fp_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0])) + return 1; + break; + + case OP_ALU_SCALAR: + switch (code) { + case OP_COS_SAT: + fp->Saturate = 1; + case OP_COS: + fp->Opcode = FP_OPCODE_COS; + break; + + case OP_EX2_SAT: + fp->Saturate = 1; + case OP_EX2: + fp->Opcode = FP_OPCODE_EX2; + break; + + case OP_LG2_SAT: + fp->Saturate = 1; + case OP_LG2: + fp->Opcode = FP_OPCODE_LG2; + break; + + case OP_RCP_SAT: + fp->Saturate = 1; + case OP_RCP: + fp->Opcode = FP_OPCODE_RCP; + break; + + case OP_RSQ_SAT: + fp->Saturate = 1; + case OP_RSQ: + fp->Opcode = FP_OPCODE_RSQ; + break; + + case OP_SIN_SAT: + fp->Saturate = 1; + case OP_SIN: + fp->Opcode = FP_OPCODE_SIN; + break; + + case OP_SCS_SAT: + fp->Saturate = 1; + case OP_SCS: + + fp->Opcode = FP_OPCODE_SCS; + break; + } + + if (parse_fp_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg)) + return 1; + + if (parse_fp_scalar_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0])) + return 1; + break; + + case OP_ALU_BINSC: + switch (code) { + case OP_POW_SAT: + fp->Saturate = 1; + case OP_POW: + fp->Opcode = FP_OPCODE_POW; + break; + } + + if (parse_fp_dst_reg(ctx, inst, vc_head, Program, &fp->DstReg)) + return 1; + + for (a = 0; a < 2; a++) { + if (parse_fp_scalar_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[a])) + return 1; + } + break; + + + case OP_ALU_BIN: + switch (code) { + case OP_ADD_SAT: + fp->Saturate = 1; + case OP_ADD: + fp->Opcode = FP_OPCODE_ADD; + break; + + case OP_DP3_SAT: + fp->Saturate = 1; + case OP_DP3: + fp->Opcode = FP_OPCODE_DP3; + break; + + case OP_DP4_SAT: + fp->Saturate = 1; + case OP_DP4: + fp->Opcode = FP_OPCODE_DP4; + break; + + case OP_DPH_SAT: + fp->Saturate = 1; + case OP_DPH: + fp->Opcode = FP_OPCODE_DPH; + break; + + case OP_DST_SAT: + fp->Saturate = 1; + case OP_DST: + fp->Opcode = FP_OPCODE_DST; + break; + + case OP_MAX_SAT: + fp->Saturate = 1; + case OP_MAX: + fp->Opcode = FP_OPCODE_MAX; + break; + + case OP_MIN_SAT: + fp->Saturate = 1; + case OP_MIN: + fp->Opcode = FP_OPCODE_MIN; + break; + + case OP_MUL_SAT: + fp->Saturate = 1; + case OP_MUL: + fp->Opcode = FP_OPCODE_MUL; + break; + + case OP_SGE_SAT: + fp->Saturate = 1; + case OP_SGE: + fp->Opcode = FP_OPCODE_SGE; + break; + + case OP_SLT_SAT: + fp->Saturate = 1; + case OP_SLT: + fp->Opcode = FP_OPCODE_SLT; + break; + + case OP_SUB_SAT: + fp->Saturate = 1; + case OP_SUB: + fp->Opcode = FP_OPCODE_SUB; + break; + + case OP_XPD_SAT: + fp->Saturate = 1; + case OP_XPD: + fp->Opcode = FP_OPCODE_XPD; + break; + } + + if (parse_fp_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg)) + return 1; + for (a = 0; a < 2; a++) { + if (parse_fp_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[a])) + return 1; + } + break; + + case OP_ALU_TRI: + switch (code) { + case OP_CMP_SAT: + fp->Saturate = 1; + case OP_CMP: + fp->Opcode = FP_OPCODE_CMP; + break; + + case OP_LRP_SAT: + fp->Saturate = 1; + case OP_LRP: + fp->Opcode = FP_OPCODE_LRP; + break; + + case OP_MAD_SAT: + fp->Saturate = 1; + case OP_MAD: + fp->Opcode = FP_OPCODE_MAD; + break; + } + + if (parse_fp_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg)) + return 1; + + for (a = 0; a < 3; a++) { + if (parse_fp_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[a])) + return 1; + } + break; + + case OP_ALU_SWZ: + switch (code) { + case OP_SWZ_SAT: + fp->Saturate = 1; + case OP_SWZ: + fp->Opcode = FP_OPCODE_SWZ; + break; + } + if (parse_fp_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg)) + return 1; + + { + GLubyte Swizzle[4]; /* FP's swizzle mask is a GLubyte, while VP's is GLuint */ + GLubyte negateMask; + GLint File, Index; + + if (parse_src_reg(ctx, inst, vc_head, Program, &File, &Index, &rel)) + return 1; + parse_extended_swizzle_mask (inst, Swizzle, &negateMask); + fp->SrcReg[0].File = File; + fp->SrcReg[0].Index = Index; + fp->SrcReg[0].NegateBase = negateMask; + fp->SrcReg[0].Swizzle = (Swizzle[0] << 0 | + Swizzle[1] << 3 | + Swizzle[2] << 6 | + Swizzle[3] << 9); + } + break; + + case OP_TEX_SAMPLE: + switch (code) { + case OP_TEX_SAT: + fp->Saturate = 1; + case OP_TEX: + fp->Opcode = FP_OPCODE_TEX; + break; + + case OP_TXP_SAT: + fp->Saturate = 1; + case OP_TXP: + fp->Opcode = FP_OPCODE_TXP; + break; + + case OP_TXB_SAT: + fp->Saturate = 1; + case OP_TXB: + fp->Opcode = FP_OPCODE_TXB; + break; + } + + if (parse_fp_dst_reg (ctx, inst, vc_head, Program, &fp->DstReg)) + return 1; + + if (parse_fp_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0])) + return 1; + + /* texImageUnit */ + if (parse_texcoord_num (ctx, inst, Program, &texcoord)) + return 1; + fp->TexSrcUnit = texcoord; + + /* texTarget */ + switch (*(*inst)++) { + case TEXTARGET_1D: + fp->TexSrcIdx = TEXTURE_1D_INDEX; + break; + case TEXTARGET_2D: + fp->TexSrcIdx = TEXTURE_2D_INDEX; + break; + case TEXTARGET_3D: + fp->TexSrcIdx = TEXTURE_3D_INDEX; + break; + case TEXTARGET_RECT: + fp->TexSrcIdx = TEXTURE_RECT_INDEX; + break; + case TEXTARGET_CUBE: + fp->TexSrcIdx = TEXTURE_CUBE_INDEX; + break; + case TEXTARGET_SHADOW1D: + case TEXTARGET_SHADOW2D: + case TEXTARGET_SHADOWRECT: + /* TODO ARB_fragment_program_shadow code */ + break; + } + Program->TexturesUsed[texcoord] |= (1<TexSrcIdx); + break; + + case OP_TEX_KIL: + if (parse_fp_vector_src_reg(ctx, inst, vc_head, Program, &fp->SrcReg[0])) + return 1; + fp->Opcode = FP_OPCODE_KIL; + break; + } + + return 0; +} + +static GLuint +parse_vp_dst_reg(GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, struct arb_program *Program, + struct vp_dst_register *reg ) +{ + GLint file, idx, mask; + + if (parse_masked_dst_reg(ctx, inst, vc_head, Program, &file, &idx, &mask)) + return 1; + + reg->File = file; + reg->Index = idx; + reg->WriteMask = mask; + return 0; +} + +/** + * Handle the parsing out of a masked address register + * + * \param Index - The register index we write to + * \param WriteMask - The mask controlling which components we write (1->write) + * + * \return 0 on sucess, 1 on error + */ +static GLuint +parse_vp_address_reg (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, + struct arb_program *Program, + struct vp_dst_register *reg) +{ + GLint idx; + + if (parse_address_reg (ctx, inst, vc_head, Program, &idx)) + return 1; + + /* This should be 0x8 */ + (*inst)++; + + reg->File = PROGRAM_ADDRESS; + reg->Index = idx; + + /* Writemask of .x is implied */ + reg->WriteMask = 0x1; + return 0; +} + +/** + */ +static GLuint +parse_vp_vector_src_reg (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, struct arb_program *Program, + struct vp_src_register *reg ) +{ + + GLint File; + GLint Index; + GLboolean Negate; + GLubyte Swizzle[4]; + GLboolean IsRelOffset; + + /* Grab the sign */ + Negate = (parse_sign (inst) == -1) ? 0xf : 0x0; + + /* And the src reg */ + if (parse_src_reg (ctx, inst, vc_head, Program, &File, &Index, &IsRelOffset)) + return 1; + + /* finally, the swizzle */ + parse_swizzle_mask (inst, Swizzle, 4); + + reg->File = File; + reg->Index = Index; + reg->Swizzle = ((Swizzle[0] << 0) | + (Swizzle[1] << 3) | + (Swizzle[2] << 6) | + (Swizzle[3] << 9)); + reg->Negate = Negate; + reg->RelAddr = IsRelOffset; + return 0; +} + + +static GLuint +parse_vp_scalar_src_reg (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, struct arb_program *Program, + struct vp_src_register *reg ) +{ + + GLint File; + GLint Index; + GLboolean Negate; + GLubyte Swizzle[4]; + GLboolean IsRelOffset; + + /* Grab the sign */ + Negate = (parse_sign (inst) == -1) ? 0x1 : 0x0; + + /* And the src reg */ + if (parse_src_reg (ctx, inst, vc_head, Program, &File, &Index, &IsRelOffset)) + return 1; + + /* finally, the swizzle */ + parse_swizzle_mask (inst, Swizzle, 1); + + reg->File = File; + reg->Index = Index; + reg->Swizzle = (Swizzle[0] << 0); + reg->Negate = Negate; + reg->RelAddr = IsRelOffset; + return 0; +} + + +/** + * This is a big mother that handles getting opcodes into the instruction + * and handling the src & dst registers for vertex program instructions + */ +static GLuint +parse_vp_instruction (GLcontext * ctx, GLubyte ** inst, + struct var_cache **vc_head, struct arb_program *Program, + struct vp_instruction *vp) +{ + GLint a; + GLubyte type, code; + + /* OP_ALU_{ARL, VECTOR, SCALAR, BINSC, BIN, TRI, SWZ} */ + type = *(*inst)++; + + /* The actual opcode name */ + code = *(*inst)++; + + /* Record the position in the program string for debugging */ + vp->StringPos = Program->Position; + vp->Data = NULL; + vp->SrcReg[0].RelAddr = vp->SrcReg[1].RelAddr = vp->SrcReg[2].RelAddr = 0; + vp->SrcReg[0].Swizzle = SWIZZLE_NOOP; + vp->SrcReg[1].Swizzle = SWIZZLE_NOOP; + vp->SrcReg[2].Swizzle = SWIZZLE_NOOP; + vp->SrcReg[3].Swizzle = SWIZZLE_NOOP; + vp->DstReg.WriteMask = 0xf; + + switch (type) { + /* XXX: */ + case OP_ALU_ARL: + vp->Opcode = VP_OPCODE_ARL; + + /* Remember to set SrcReg.RelAddr; */ + + /* Get the masked address register [dst] */ + if (parse_vp_address_reg(ctx, inst, vc_head, Program, &vp->DstReg)) + return 1; + + vp->DstReg.File = PROGRAM_ADDRESS; + + /* Get a scalar src register */ + if (parse_vp_scalar_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[0])) + return 1; + + break; + + case OP_ALU_VECTOR: + switch (code) { + case OP_ABS: + vp->Opcode = VP_OPCODE_ABS; + break; + case OP_FLR: + vp->Opcode = VP_OPCODE_FLR; + break; + case OP_FRC: + vp->Opcode = VP_OPCODE_FRC; + break; + case OP_LIT: + vp->Opcode = VP_OPCODE_LIT; + break; + case OP_MOV: + vp->Opcode = VP_OPCODE_MOV; + break; + } + + if (parse_vp_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg)) + return 1; + + if (parse_vp_vector_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[0])) + return 1; + break; + + case OP_ALU_SCALAR: + switch (code) { + case OP_EX2: + vp->Opcode = VP_OPCODE_EX2; + break; + case OP_EXP: + vp->Opcode = VP_OPCODE_EXP; + break; + case OP_LG2: + vp->Opcode = VP_OPCODE_LG2; + break; + case OP_LOG: + vp->Opcode = VP_OPCODE_LOG; + break; + case OP_RCP: + vp->Opcode = VP_OPCODE_RCP; + break; + case OP_RSQ: + vp->Opcode = VP_OPCODE_RSQ; + break; + } + if (parse_vp_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg)) + return 1; + + if (parse_vp_scalar_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[0])) + return 1; + break; + + case OP_ALU_BINSC: + switch (code) { + case OP_POW: + vp->Opcode = VP_OPCODE_POW; + break; + } + if (parse_vp_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg)) + return 1; + + for (a = 0; a < 2; a++) { + if (parse_vp_scalar_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[a])) + return 1; + } + break; + + case OP_ALU_BIN: + switch (code) { + case OP_ADD: + vp->Opcode = VP_OPCODE_ADD; + break; + case OP_DP3: + vp->Opcode = VP_OPCODE_DP3; + break; + case OP_DP4: + vp->Opcode = VP_OPCODE_DP4; + break; + case OP_DPH: + vp->Opcode = VP_OPCODE_DPH; + break; + case OP_DST: + vp->Opcode = VP_OPCODE_DST; + break; + case OP_MAX: + vp->Opcode = VP_OPCODE_MAX; + break; + case OP_MIN: + vp->Opcode = VP_OPCODE_MIN; + break; + case OP_MUL: + vp->Opcode = VP_OPCODE_MUL; + break; + case OP_SGE: + vp->Opcode = VP_OPCODE_SGE; + break; + case OP_SLT: + vp->Opcode = VP_OPCODE_SLT; + break; + case OP_SUB: + vp->Opcode = VP_OPCODE_SUB; + break; + case OP_XPD: + vp->Opcode = VP_OPCODE_XPD; + break; + } + if (parse_vp_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg)) + return 1; + + for (a = 0; a < 2; a++) { + if (parse_vp_vector_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[a])) + return 1; + } + break; + + case OP_ALU_TRI: + switch (code) { + case OP_MAD: + vp->Opcode = VP_OPCODE_MAD; + break; + } + + if (parse_vp_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg)) + return 1; + + for (a = 0; a < 3; a++) { + if (parse_vp_vector_src_reg(ctx, inst, vc_head, Program, &vp->SrcReg[a])) + return 1; + } + break; + + case OP_ALU_SWZ: + switch (code) { + case OP_SWZ: + vp->Opcode = VP_OPCODE_SWZ; + break; + } + { + GLubyte Swizzle[4]; /* FP's swizzle mask is a GLubyte, while VP's is GLuint */ + GLubyte Negate[4]; + GLboolean RelAddr; + GLint File, Index; + + if (parse_vp_dst_reg(ctx, inst, vc_head, Program, &vp->DstReg)) + return 1; + + if (parse_src_reg(ctx, inst, vc_head, Program, &File, &Index, &RelAddr)) + return 1; + parse_extended_swizzle_mask (inst, Swizzle, Negate); + vp->SrcReg[0].File = File; + vp->SrcReg[0].Index = Index; + vp->SrcReg[0].Negate = (Negate[0] << 0 | + Negate[1] << 1 | + Negate[2] << 2 | + Negate[3] << 3); + vp->SrcReg[0].Swizzle = (Swizzle[0] << 0 | + Swizzle[1] << 3 | + Swizzle[2] << 6 | + Swizzle[3] << 9); + vp->SrcReg[0].RelAddr = RelAddr; + } + break; + } + return 0; +} + +#if DEBUG_PARSING + +static GLvoid +print_state_token (GLint token) +{ + switch (token) { + case STATE_MATERIAL: + fprintf (stderr, "STATE_MATERIAL "); + break; + case STATE_LIGHT: + fprintf (stderr, "STATE_LIGHT "); + break; + + case STATE_LIGHTMODEL_AMBIENT: + fprintf (stderr, "STATE_AMBIENT "); + break; + + case STATE_LIGHTMODEL_SCENECOLOR: + fprintf (stderr, "STATE_SCENECOLOR "); + break; + + case STATE_LIGHTPROD: + fprintf (stderr, "STATE_LIGHTPROD "); + break; + + case STATE_TEXGEN: + fprintf (stderr, "STATE_TEXGEN "); + break; + + case STATE_FOG_COLOR: + fprintf (stderr, "STATE_FOG_COLOR "); + break; + + case STATE_FOG_PARAMS: + fprintf (stderr, "STATE_FOG_PARAMS "); + break; + + case STATE_CLIPPLANE: + fprintf (stderr, "STATE_CLIPPLANE "); + break; + + case STATE_POINT_SIZE: + fprintf (stderr, "STATE_POINT_SIZE "); + break; + + case STATE_POINT_ATTENUATION: + fprintf (stderr, "STATE_ATTENUATION "); + break; + + case STATE_MATRIX: + fprintf (stderr, "STATE_MATRIX "); + break; + + case STATE_MODELVIEW: + fprintf (stderr, "STATE_MODELVIEW "); + break; + + case STATE_PROJECTION: + fprintf (stderr, "STATE_PROJECTION "); + break; + + case STATE_MVP: + fprintf (stderr, "STATE_MVP "); + break; + + case STATE_TEXTURE: + fprintf (stderr, "STATE_TEXTURE "); + break; + + case STATE_PROGRAM: + fprintf (stderr, "STATE_PROGRAM "); + break; + + case STATE_MATRIX_INVERSE: + fprintf (stderr, "STATE_INVERSE "); + break; + + case STATE_MATRIX_TRANSPOSE: + fprintf (stderr, "STATE_TRANSPOSE "); + break; + + case STATE_MATRIX_INVTRANS: + fprintf (stderr, "STATE_INVTRANS "); + break; + + case STATE_AMBIENT: + fprintf (stderr, "STATE_AMBIENT "); + break; + + case STATE_DIFFUSE: + fprintf (stderr, "STATE_DIFFUSE "); + break; + + case STATE_SPECULAR: + fprintf (stderr, "STATE_SPECULAR "); + break; + + case STATE_EMISSION: + fprintf (stderr, "STATE_EMISSION "); + break; + + case STATE_SHININESS: + fprintf (stderr, "STATE_SHININESS "); + break; + + case STATE_HALF: + fprintf (stderr, "STATE_HALF "); + break; + + case STATE_POSITION: + fprintf (stderr, "STATE_POSITION "); + break; + + case STATE_ATTENUATION: + fprintf (stderr, "STATE_ATTENUATION "); + break; + + case STATE_SPOT_DIRECTION: + fprintf (stderr, "STATE_DIRECTION "); + break; + + case STATE_TEXGEN_EYE_S: + fprintf (stderr, "STATE_TEXGEN_EYE_S "); + break; + + case STATE_TEXGEN_EYE_T: + fprintf (stderr, "STATE_TEXGEN_EYE_T "); + break; + + case STATE_TEXGEN_EYE_R: + fprintf (stderr, "STATE_TEXGEN_EYE_R "); + break; + + case STATE_TEXGEN_EYE_Q: + fprintf (stderr, "STATE_TEXGEN_EYE_Q "); + break; + + case STATE_TEXGEN_OBJECT_S: + fprintf (stderr, "STATE_TEXGEN_EYE_S "); + break; + + case STATE_TEXGEN_OBJECT_T: + fprintf (stderr, "STATE_TEXGEN_OBJECT_T "); + break; + + case STATE_TEXGEN_OBJECT_R: + fprintf (stderr, "STATE_TEXGEN_OBJECT_R "); + break; + + case STATE_TEXGEN_OBJECT_Q: + fprintf (stderr, "STATE_TEXGEN_OBJECT_Q "); + break; + + case STATE_TEXENV_COLOR: + fprintf (stderr, "STATE_TEXENV_COLOR "); + break; + + case STATE_DEPTH_RANGE: + fprintf (stderr, "STATE_DEPTH_RANGE "); + break; + + case STATE_VERTEX_PROGRAM: + fprintf (stderr, "STATE_VERTEX_PROGRAM "); + break; + + case STATE_FRAGMENT_PROGRAM: + fprintf (stderr, "STATE_FRAGMENT_PROGRAM "); + break; + + case STATE_ENV: + fprintf (stderr, "STATE_ENV "); + break; + + case STATE_LOCAL: + fprintf (stderr, "STATE_LOCAL "); + break; + + } + fprintf (stderr, "[%d] ", token); +} + + +static GLvoid +debug_variables (GLcontext * ctx, struct var_cache *vc_head, + struct arb_program *Program) +{ + struct var_cache *vc; + GLint a, b; + + fprintf (stderr, "debug_variables, vc_head: %x\n", vc_head); + + /* First of all, print out the contents of the var_cache */ + vc = vc_head; + while (vc) { + fprintf (stderr, "[%x]\n", vc); + switch (vc->type) { + case vt_none: + fprintf (stderr, "UNDEFINED %s\n", vc->name); + break; + case vt_attrib: + fprintf (stderr, "ATTRIB %s\n", vc->name); + fprintf (stderr, " binding: 0x%x\n", vc->attrib_binding); + break; + case vt_param: + fprintf (stderr, "PARAM %s begin: %d len: %d\n", vc->name, + vc->param_binding_begin, vc->param_binding_length); + b = vc->param_binding_begin; + for (a = 0; a < vc->param_binding_length; a++) { + fprintf (stderr, "%s\n", + Program->Parameters->Parameters[a + b].Name); + if (Program->Parameters->Parameters[a + b].Type == STATE) { + print_state_token (Program->Parameters->Parameters[a + b]. + StateIndexes[0]); + print_state_token (Program->Parameters->Parameters[a + b]. + StateIndexes[1]); + print_state_token (Program->Parameters->Parameters[a + b]. + StateIndexes[2]); + print_state_token (Program->Parameters->Parameters[a + b]. + StateIndexes[3]); + print_state_token (Program->Parameters->Parameters[a + b]. + StateIndexes[4]); + print_state_token (Program->Parameters->Parameters[a + b]. + StateIndexes[5]); + } + else + fprintf (stderr, "%f %f %f %f\n", + Program->Parameters->Parameters[a + b].Values[0], + Program->Parameters->Parameters[a + b].Values[1], + Program->Parameters->Parameters[a + b].Values[2], + Program->Parameters->Parameters[a + b].Values[3]); + } + break; + case vt_temp: + fprintf (stderr, "TEMP %s\n", vc->name); + fprintf (stderr, " binding: 0x%x\n", vc->temp_binding); + break; + case vt_output: + fprintf (stderr, "OUTPUT %s\n", vc->name); + fprintf (stderr, " binding: 0x%x\n", vc->output_binding); + break; + case vt_alias: + fprintf (stderr, "ALIAS %s\n", vc->name); + fprintf (stderr, " binding: 0x%x (%s)\n", + vc->alias_binding, vc->alias_binding->name); + break; + } + vc = vc->next; + } +} + +#endif + + +/** + * The main loop for parsing a fragment or vertex program + * + * \return GL_TRUE on success, GL_FALSE on error. + */ +static GLboolean +parse_arb_program(GLcontext * ctx, GLubyte * inst, struct var_cache **vc_head, + struct arb_program *Program) +{ + GLint err = 0; + + Program->MajorVersion = (GLuint) * inst++; + Program->MinorVersion = (GLuint) * inst++; + + while (*inst != END) { + switch (*inst++) { + + case OPTION: + switch (*inst++) { + case ARB_PRECISION_HINT_FASTEST: + Program->PrecisionOption = GL_FASTEST; + break; + + case ARB_PRECISION_HINT_NICEST: + Program->PrecisionOption = GL_NICEST; + break; + + case ARB_FOG_EXP: + Program->FogOption = GL_EXP; + break; + + case ARB_FOG_EXP2: + Program->FogOption = GL_EXP2; + break; + + case ARB_FOG_LINEAR: + Program->FogOption = GL_LINEAR; + break; + + case ARB_POSITION_INVARIANT: + if (Program->Base.Target == GL_VERTEX_PROGRAM_ARB) + Program->HintPositionInvariant = 1; + break; + + case ARB_FRAGMENT_PROGRAM_SHADOW: + if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) { + /* TODO ARB_fragment_program_shadow code */ + } + break; + + case ARB_DRAW_BUFFERS: + if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) { + /* do nothing for now */ + } + break; + } + break; + + case INSTRUCTION: + Program->Position = parse_position (&inst); + + if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) { + + /* Check the instruction count + * XXX: Does END count as an instruction? + */ + if (Program->Base.NumInstructions+1 == MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS) { + _mesa_set_program_error (ctx, Program->Position, + "Max instruction count exceeded!"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Max instruction count exceeded!"); + } + + /* Realloc Program->FPInstructions */ + Program->FPInstructions = + (struct fp_instruction *) _mesa_realloc (Program->FPInstructions, + Program->Base.NumInstructions*sizeof(struct fp_instruction), + (Program->Base.NumInstructions+1)*sizeof (struct fp_instruction)); + + /* parse the current instruction */ + err = parse_fp_instruction (ctx, &inst, vc_head, Program, + &Program->FPInstructions[Program->Base.NumInstructions]); + + } + else { + /* Check the instruction count + * XXX: Does END count as an instruction? + */ + if (Program->Base.NumInstructions+1 == MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS) { + _mesa_set_program_error (ctx, Program->Position, + "Max instruction count exceeded!"); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Max instruction count exceeded!"); + } + + /* Realloc Program->VPInstructions */ + Program->VPInstructions = + (struct vp_instruction *) _mesa_realloc (Program->VPInstructions, + Program->Base.NumInstructions*sizeof(struct vp_instruction), + (Program->Base.NumInstructions +1)*sizeof(struct vp_instruction)); + + /* parse the current instruction */ + err = parse_vp_instruction (ctx, &inst, vc_head, Program, + &Program->VPInstructions[Program->Base.NumInstructions]); + } + + /* increment Program->Base.NumInstructions */ + Program->Base.NumInstructions++; + break; + + case DECLARATION: + err = parse_declaration (ctx, &inst, vc_head, Program); + break; + + default: + break; + } + + if (err) + break; + } + + /* Finally, tag on an OPCODE_END instruction */ + if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) { + Program->FPInstructions = + (struct fp_instruction *) _mesa_realloc (Program->FPInstructions, + Program->Base.NumInstructions*sizeof(struct fp_instruction), + (Program->Base.NumInstructions+1)*sizeof(struct fp_instruction)); + + Program->FPInstructions[Program->Base.NumInstructions].Opcode = FP_OPCODE_END; + Program->FPInstructions[Program->Base.NumInstructions].Saturate = 0; + Program->FPInstructions[Program->Base.NumInstructions].DstReg.File = 0xf; + Program->FPInstructions[Program->Base.NumInstructions].SrcReg[0].File = 0xf; + Program->FPInstructions[Program->Base.NumInstructions].SrcReg[1].File = 0xf; + Program->FPInstructions[Program->Base.NumInstructions].SrcReg[2].File = 0xf; + /* YYY Wrong Position in program, whatever, at least not random -> crash + Program->Position = parse_position (&inst); + */ + Program->FPInstructions[Program->Base.NumInstructions].StringPos = Program->Position; + Program->FPInstructions[Program->Base.NumInstructions].Data = NULL; + } + else { + Program->VPInstructions = + (struct vp_instruction *) _mesa_realloc (Program->VPInstructions, + Program->Base.NumInstructions*sizeof(struct vp_instruction), + (Program->Base.NumInstructions+1)*sizeof(struct vp_instruction)); + + Program->VPInstructions[Program->Base.NumInstructions].Opcode = VP_OPCODE_END; + /* YYY Wrong Position in program, whatever, at least not random -> crash + Program->Position = parse_position (&inst); + */ + Program->VPInstructions[Program->Base.NumInstructions].StringPos = Program->Position; + Program->VPInstructions[Program->Base.NumInstructions].Data = NULL; + } + + /* increment Program->Base.NumInstructions */ + Program->Base.NumInstructions++; + + return err; +} + +/* XXX temporary */ +__extension__ static char core_grammar_text[] = +#include "grammar_syn.h" +; + +static int set_reg8 (GLcontext *ctx, grammar id, const byte *name, byte value) +{ + char error_msg[300]; + GLint error_pos; + + if (grammar_set_reg8 (id, name, value)) + return 0; + + grammar_get_last_error ((byte *) error_msg, 300, &error_pos); + _mesa_set_program_error (ctx, error_pos, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, "Grammar Register Error"); + return 1; +} + +static int extension_is_supported (const GLubyte *ext) +{ + const GLubyte *extensions = CALL_GetString(GET_DISPATCH(), (GL_EXTENSIONS)); + const GLubyte *end = extensions + _mesa_strlen ((const char *) extensions); + const GLint ext_len = (GLint)_mesa_strlen ((const char *) ext); + + while (extensions < end) + { + const GLubyte *name_end = (const GLubyte *) strchr ((const char *) extensions, ' '); + if (name_end == NULL) + name_end = end; + if (name_end - extensions == ext_len && _mesa_strncmp ((const char *) ext, + (const char *) extensions, ext_len) == 0) + return 1; + extensions = name_end + 1; + } + + return 0; +} + +static int enable_ext (GLcontext *ctx, grammar id, const byte *name, const byte *extname) +{ + if (extension_is_supported (extname)) + if (set_reg8 (ctx, id, name, 0x01)) + return 1; + return 0; +} + +/** + * This kicks everything off. + * + * \param ctx - The GL Context + * \param str - The program string + * \param len - The program string length + * \param program - The arb_program struct to return all the parsed info in + * \return GL_TRUE on sucess, GL_FALSE on error + */ +GLboolean +_mesa_parse_arb_program (GLcontext * ctx, const GLubyte * str, GLsizei len, + struct arb_program * program) +{ + GLint a, err, error_pos; + char error_msg[300]; + GLuint parsed_len; + struct var_cache *vc_head; + grammar arbprogram_syn_id; + GLubyte *parsed, *inst; + GLubyte *strz = NULL; + static int arbprogram_syn_is_ok = 0; /* XXX temporary */ + + /* Reset error state */ + _mesa_set_program_error(ctx, -1, NULL); + +#if DEBUG_PARSING + fprintf (stderr, "Loading grammar text!\n"); +#endif + + /* check if the arb_grammar_text (arbprogram.syn) is syntactically correct */ + if (!arbprogram_syn_is_ok) { + grammar grammar_syn_id; + GLint err; + GLuint parsed_len; + byte *parsed; + + grammar_syn_id = grammar_load_from_text ((byte *) core_grammar_text); + if (grammar_syn_id == 0) { + grammar_get_last_error ((byte *) error_msg, 300, &error_pos); + _mesa_set_program_error (ctx, error_pos, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Error loading grammar rule set"); + return GL_FALSE; + } + + err = grammar_check (grammar_syn_id, (byte *) arb_grammar_text, &parsed, &parsed_len); + + /* NOTE: we can't destroy grammar_syn_id right here because + * grammar_destroy() can reset the last error + */ + if (err == 0) { + grammar_get_last_error ((byte *) error_msg, 300, &error_pos); + _mesa_set_program_error (ctx, error_pos, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, "Error loading grammar rule set"); + + grammar_destroy (grammar_syn_id); + return GL_FALSE; + } + + grammar_destroy (grammar_syn_id); + + arbprogram_syn_is_ok = 1; + } + + /* create the grammar object */ + arbprogram_syn_id = grammar_load_from_text ((byte *) arb_grammar_text); + if (arbprogram_syn_id == 0) { + grammar_get_last_error ((GLubyte *) error_msg, 300, &error_pos); + _mesa_set_program_error (ctx, error_pos, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, + "Error loading grammer rule set"); + return GL_FALSE; + } + + /* Set program_target register value */ + if (set_reg8 (ctx, arbprogram_syn_id, (byte *) "program_target", + program->Base.Target == GL_FRAGMENT_PROGRAM_ARB ? 0x10 : 0x20)) { + grammar_destroy (arbprogram_syn_id); + return GL_FALSE; + } + + /* Enable all active extensions */ + if (enable_ext (ctx, arbprogram_syn_id, + (byte *) "vertex_blend", (byte *) "GL_ARB_vertex_blend") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "vertex_blend", (byte *) "GL_EXT_vertex_weighting") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "matrix_palette", (byte *) "GL_ARB_matrix_palette") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "point_parameters", (byte *) "GL_ARB_point_parameters") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "point_parameters", (byte *) "GL_EXT_point_parameters") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "secondary_color", (byte *) "GL_EXT_secondary_color") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "fog_coord", (byte *) "GL_EXT_fog_coord") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "texture_rectangle", (byte *) "GL_ARB_texture_rectangle") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "texture_rectangle", (byte *) "GL_EXT_texture_rectangle") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "texture_rectangle", (byte *) "GL_NV_texture_rectangle") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "fragment_program_shadow", (byte *) "GL_ARB_fragment_program_shadow") || + enable_ext (ctx, arbprogram_syn_id, + (byte *) "draw_buffers", (byte *) "GL_ARB_draw_buffers")) { + grammar_destroy (arbprogram_syn_id); + return GL_FALSE; + } + + /* check for NULL character occurences */ + { + int i; + for (i = 0; i < len; i++) + if (str[i] == '\0') { + _mesa_set_program_error (ctx, i, "invalid character"); + _mesa_error (ctx, GL_INVALID_OPERATION, "Lexical Error"); + + grammar_destroy (arbprogram_syn_id); + return GL_FALSE; + } + } + + /* copy the program string to a null-terminated string */ + strz = (GLubyte *) _mesa_malloc (len + 1); + if (!strz) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glprogramStringARB"); + return GL_FALSE; + } + _mesa_memcpy (strz, str, len); + strz[len] = '\0'; + +#if DEBUG_PARSING + printf ("Checking Grammar!\n"); +#endif + /* do a fast check on program string - initial production buffer is 4K */ + err = grammar_fast_check (arbprogram_syn_id, strz, &parsed, &parsed_len, 0x1000); + + /* Syntax parse error */ + if (err == 0) { + _mesa_free (strz); + grammar_get_last_error ((GLubyte *) error_msg, 300, &error_pos); + _mesa_set_program_error (ctx, error_pos, error_msg); + _mesa_error (ctx, GL_INVALID_OPERATION, "glProgramStringARB(syntax error)"); + + /* useful for debugging */ + if (0) { + int line, col; + char *s; + printf("Program: %s\n", (char *) strz); + printf("Error Pos: %d\n", ctx->Program.ErrorPos); + s = (char *) _mesa_find_line_column(strz, strz+ctx->Program.ErrorPos, &line, &col); + printf("line %d col %d: %s\n", line, col, s); + } + + grammar_destroy (arbprogram_syn_id); + return 1; + } + +#if DEBUG_PARSING + printf ("Destroying grammer dict [parse retval: %d]\n", err); +#endif + grammar_destroy (arbprogram_syn_id); + + /* Initialize the arb_program struct */ + program->Base.String = strz; + program->Base.NumInstructions = + program->Base.NumTemporaries = + program->Base.NumParameters = + program->Base.NumAttributes = program->Base.NumAddressRegs = 0; + program->Parameters = _mesa_new_parameter_list (); + program->InputsRead = 0; + program->OutputsWritten = 0; + program->Position = 0; + program->MajorVersion = program->MinorVersion = 0; + program->PrecisionOption = GL_DONT_CARE; + program->FogOption = GL_NONE; + program->HintPositionInvariant = GL_FALSE; + for (a = 0; a < MAX_TEXTURE_IMAGE_UNITS; a++) + program->TexturesUsed[a] = 0; + program->NumAluInstructions = + program->NumTexInstructions = + program->NumTexIndirections = 0; + + program->FPInstructions = NULL; + program->VPInstructions = NULL; + + vc_head = NULL; + err = GL_FALSE; + + /* Start examining the tokens in the array */ + inst = parsed; + + /* Check the grammer rev */ + if (*inst++ != REVISION) { + _mesa_set_program_error (ctx, 0, "Grammar version mismatch"); + _mesa_error(ctx, GL_INVALID_OPERATION, + "glProgramStringARB(Grammar verison mismatch)"); + err = GL_TRUE; + } + else { + /* ignore program target */ + inst++; + + err = parse_arb_program (ctx, inst, &vc_head, program); +#if DEBUG_PARSING + fprintf (stderr, "Symantic analysis returns %d [1 is bad!]\n", err); +#endif + } + + /*debug_variables(ctx, vc_head, program); */ + + /* We're done with the parsed binary array */ + var_cache_destroy (&vc_head); + + _mesa_free (parsed); +#if DEBUG_PARSING + printf ("_mesa_parse_arb_program() done\n"); +#endif + + return !err; +} diff --git a/src/mesa/shader/arbprogparse.h b/src/mesa/shader/arbprogparse.h new file mode 100644 index 000000000..ececfafa8 --- /dev/null +++ b/src/mesa/shader/arbprogparse.h @@ -0,0 +1,75 @@ +/* + * Mesa 3-D graphics library + * Version: 6.3 + * + * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#ifndef ARBPROGPARSE_H +#define ARBPROGPARSE_H + +#include "context.h" +#include "mtypes.h" +#include "nvvertprog.h" +#include "nvfragprog.h" + +/** + * This is basically a union of the vertex_program and fragment_program + * structs that we can use to parse the program into + * + * XXX: this should go into mtypes.h? + */ +struct arb_program +{ + struct program Base; + struct program_parameter_list *Parameters; + GLuint InputsRead; + GLuint OutputsWritten; + + GLuint Position; /* Just used for error reporting while parsing */ + GLuint MajorVersion; + GLuint MinorVersion; + + /* ARB_vertex_program specifics */ + struct vp_instruction *VPInstructions; + + /* Options currently recognized by the parser */ + /* ARB_fp */ + GLenum PrecisionOption; /* GL_DONT_CARE, GL_NICEST or GL_FASTEST */ + GLenum FogOption; /* GL_NONE, GL_LINEAR, GL_EXP or GL_EXP2 */ + + /* ARB_fp & _vp */ + GLboolean HintPositionInvariant; + + /* ARB_fragment_program specifics */ + struct fp_instruction *FPInstructions; + GLuint TexturesUsed[MAX_TEXTURE_IMAGE_UNITS]; + GLuint NumAluInstructions; + GLuint NumTexInstructions; + GLuint NumTexIndirections; +}; + + +extern GLboolean +_mesa_parse_arb_program( GLcontext *ctx, const GLubyte *str, GLsizei len, + struct arb_program *program ); + +#endif diff --git a/src/mesa/shader/arbprogram.c b/src/mesa/shader/arbprogram.c new file mode 100644 index 000000000..43baab4b0 --- /dev/null +++ b/src/mesa/shader/arbprogram.c @@ -0,0 +1,724 @@ +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file arbprogram.c + * ARB_vertex/fragment_program state management functions. + * \author Brian Paul + */ + + +#include "glheader.h" +#include "arbprogram.h" +#include "arbfragparse.h" +#include "arbvertparse.h" +#include "context.h" +#include "imports.h" +#include "macros.h" +#include "mtypes.h" +#include "nvprogram.h" +#include "nvfragparse.h" +#include "nvfragprog.h" +#include "nvvertparse.h" +#include "nvvertprog.h" + + +void GLAPIENTRY +_mesa_EnableVertexAttribArrayARB(GLuint index) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (index >= ctx->Const.MaxVertexProgramAttribs) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glEnableVertexAttribArrayARB(index)"); + return; + } + + FLUSH_VERTICES(ctx, _NEW_ARRAY); + ctx->Array.VertexAttrib[index].Enabled = GL_TRUE; + ctx->Array._Enabled |= _NEW_ARRAY_ATTRIB(index); + ctx->Array.NewState |= _NEW_ARRAY_ATTRIB(index); +} + + +void GLAPIENTRY +_mesa_DisableVertexAttribArrayARB(GLuint index) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (index >= ctx->Const.MaxVertexProgramAttribs) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glEnableVertexAttribArrayARB(index)"); + return; + } + + FLUSH_VERTICES(ctx, _NEW_ARRAY); + ctx->Array.VertexAttrib[index].Enabled = GL_FALSE; + ctx->Array._Enabled &= ~_NEW_ARRAY_ATTRIB(index); + ctx->Array.NewState |= _NEW_ARRAY_ATTRIB(index); +} + + +void GLAPIENTRY +_mesa_GetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params) +{ + GLfloat fparams[4]; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + _mesa_GetVertexAttribfvARB(index, pname, fparams); + if (ctx->ErrorValue == GL_NO_ERROR) { + if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { + COPY_4V(params, fparams); + } + else { + params[0] = fparams[0]; + } + } +} + + +void GLAPIENTRY +_mesa_GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (index == 0 || index >= MAX_VERTEX_PROGRAM_ATTRIBS) { + _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribfvARB(index)"); + return; + } + + switch (pname) { + case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB: + params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Enabled; + break; + case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB: + params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Size; + break; + case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB: + params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Stride; + break; + case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB: + params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Type; + break; + case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB: + params[0] = ctx->Array.VertexAttrib[index].Normalized; + break; + case GL_CURRENT_VERTEX_ATTRIB_ARB: + FLUSH_CURRENT(ctx, 0); + /* XXX should read: + COPY_4V(params, ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index]); + */ + COPY_4V(params, ctx->Current.Attrib[index]); + break; + case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB: + if (!ctx->Extensions.ARB_vertex_buffer_object) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribfvARB(pname)"); + return; + } + params[0] = (GLfloat) ctx->Array.VertexAttrib[index].BufferObj->Name; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribfvARB(pname)"); + return; + } +} + + +void GLAPIENTRY +_mesa_GetVertexAttribivARB(GLuint index, GLenum pname, GLint *params) +{ + GLfloat fparams[4]; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + _mesa_GetVertexAttribfvARB(index, pname, fparams); + if (ctx->ErrorValue == GL_NO_ERROR) { + if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) { + COPY_4V_CAST(params, fparams, GLint); /* float to int */ + } + else { + params[0] = (GLint) fparams[0]; + } + } +} + + +void GLAPIENTRY +_mesa_GetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid **pointer) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (index >= ctx->Const.MaxVertexProgramAttribs) { + _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribPointerARB(index)"); + return; + } + + if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribPointerARB(pname)"); + return; + } + + *pointer = (GLvoid *) ctx->Array.VertexAttrib[index].Ptr;; +} + + +void GLAPIENTRY +_mesa_ProgramStringARB(GLenum target, GLenum format, GLsizei len, + const GLvoid *string) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + FLUSH_VERTICES(ctx, _NEW_PROGRAM); + + if (target == GL_VERTEX_PROGRAM_ARB + && ctx->Extensions.ARB_vertex_program) { + struct vertex_program *prog = ctx->VertexProgram.Current; + if (format != GL_PROGRAM_FORMAT_ASCII_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(format)"); + return; + } + _mesa_parse_arb_vertex_program(ctx, target, (const GLubyte *) string, + len, prog); + + if (ctx->Driver.ProgramStringNotify) + ctx->Driver.ProgramStringNotify( ctx, target, &prog->Base ); + } + else if (target == GL_FRAGMENT_PROGRAM_ARB + && ctx->Extensions.ARB_fragment_program) { + struct fragment_program *prog = ctx->FragmentProgram.Current; + if (format != GL_PROGRAM_FORMAT_ASCII_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(format)"); + return; + } + _mesa_parse_arb_fragment_program(ctx, target, (const GLubyte *) string, + len, prog); + + if (ctx->Driver.ProgramStringNotify) + ctx->Driver.ProgramStringNotify( ctx, target, &prog->Base ); + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glProgramStringARB(target)"); + return; + } +} + + +void GLAPIENTRY +_mesa_ProgramEnvParameter4dARB(GLenum target, GLuint index, + GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + _mesa_ProgramEnvParameter4fARB(target, index, (GLfloat) x, (GLfloat) y, + (GLfloat) z, (GLfloat) w); +} + + +void GLAPIENTRY +_mesa_ProgramEnvParameter4dvARB(GLenum target, GLuint index, + const GLdouble *params) +{ + _mesa_ProgramEnvParameter4fARB(target, index, (GLfloat) params[0], + (GLfloat) params[1], (GLfloat) params[2], + (GLfloat) params[3]); +} + + +void GLAPIENTRY +_mesa_ProgramEnvParameter4fARB(GLenum target, GLuint index, + GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + FLUSH_VERTICES(ctx, _NEW_PROGRAM); + + if (target == GL_FRAGMENT_PROGRAM_ARB + && ctx->Extensions.ARB_fragment_program) { + if (index >= ctx->Const.MaxFragmentProgramEnvParams) { + _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameter(index)"); + return; + } + ASSIGN_4V(ctx->FragmentProgram.Parameters[index], x, y, z, w); + } + else if (target == GL_VERTEX_PROGRAM_ARB + && ctx->Extensions.ARB_vertex_program) { + if (index >= ctx->Const.MaxVertexProgramEnvParams) { + _mesa_error(ctx, GL_INVALID_VALUE, "glProgramEnvParameter(index)"); + return; + } + ASSIGN_4V(ctx->VertexProgram.Parameters[index], x, y, z, w); + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glProgramEnvParameter(target)"); + return; + } +} + + +void GLAPIENTRY +_mesa_ProgramEnvParameter4fvARB(GLenum target, GLuint index, + const GLfloat *params) +{ + _mesa_ProgramEnvParameter4fARB(target, index, params[0], params[1], + params[2], params[3]); +} + + +void GLAPIENTRY +_mesa_GetProgramEnvParameterdvARB(GLenum target, GLuint index, + GLdouble *params) +{ + GET_CURRENT_CONTEXT(ctx); + GLfloat fparams[4]; + + _mesa_GetProgramEnvParameterfvARB(target, index, fparams); + if (ctx->ErrorValue == GL_NO_ERROR) { + params[0] = fparams[0]; + params[1] = fparams[1]; + params[2] = fparams[2]; + params[3] = fparams[3]; + } +} + + +void GLAPIENTRY +_mesa_GetProgramEnvParameterfvARB(GLenum target, GLuint index, + GLfloat *params) +{ + GET_CURRENT_CONTEXT(ctx); + + FLUSH_VERTICES(ctx, _NEW_PROGRAM); + + if (!ctx->_CurrentProgram) + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (target == GL_FRAGMENT_PROGRAM_ARB + && ctx->Extensions.ARB_fragment_program) { + if (index >= ctx->Const.MaxFragmentProgramEnvParams) { + _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramEnvParameter(index)"); + return; + } + COPY_4V(params, ctx->FragmentProgram.Parameters[index]); + } + else if (target == GL_VERTEX_PROGRAM_ARB + && ctx->Extensions.ARB_vertex_program) { + if (index >= ctx->Const.MaxVertexProgramEnvParams) { + _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramEnvParameter(index)"); + return; + } + COPY_4V(params, ctx->VertexProgram.Parameters[index]); + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramEnvParameter(target)"); + return; + } +} + + +/** + * Note, this function is also used by the GL_NV_fragment_program extension. + */ +void GLAPIENTRY +_mesa_ProgramLocalParameter4fARB(GLenum target, GLuint index, + GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + GET_CURRENT_CONTEXT(ctx); + struct program *prog; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + FLUSH_VERTICES(ctx, _NEW_PROGRAM); + + if ((target == GL_FRAGMENT_PROGRAM_NV + && ctx->Extensions.NV_fragment_program) || + (target == GL_FRAGMENT_PROGRAM_ARB + && ctx->Extensions.ARB_fragment_program)) { + if (index >= ctx->Const.MaxFragmentProgramLocalParams) { + _mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameterARB"); + return; + } + prog = &(ctx->FragmentProgram.Current->Base); + } + else if (target == GL_VERTEX_PROGRAM_ARB + && ctx->Extensions.ARB_vertex_program) { + if (index >= ctx->Const.MaxVertexProgramLocalParams) { + _mesa_error(ctx, GL_INVALID_VALUE, "glProgramLocalParameterARB"); + return; + } + prog = &(ctx->VertexProgram.Current->Base); + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glProgramLocalParameterARB"); + return; + } + + ASSERT(index < MAX_PROGRAM_LOCAL_PARAMS); + prog->LocalParams[index][0] = x; + prog->LocalParams[index][1] = y; + prog->LocalParams[index][2] = z; + prog->LocalParams[index][3] = w; +} + + +/** + * Note, this function is also used by the GL_NV_fragment_program extension. + */ +void GLAPIENTRY +_mesa_ProgramLocalParameter4fvARB(GLenum target, GLuint index, + const GLfloat *params) +{ + _mesa_ProgramLocalParameter4fARB(target, index, params[0], params[1], + params[2], params[3]); +} + + +/** + * Note, this function is also used by the GL_NV_fragment_program extension. + */ +void GLAPIENTRY +_mesa_ProgramLocalParameter4dARB(GLenum target, GLuint index, + GLdouble x, GLdouble y, + GLdouble z, GLdouble w) +{ + _mesa_ProgramLocalParameter4fARB(target, index, (GLfloat) x, (GLfloat) y, + (GLfloat) z, (GLfloat) w); +} + + +/** + * Note, this function is also used by the GL_NV_fragment_program extension. + */ +void GLAPIENTRY +_mesa_ProgramLocalParameter4dvARB(GLenum target, GLuint index, + const GLdouble *params) +{ + _mesa_ProgramLocalParameter4fARB(target, index, + (GLfloat) params[0], (GLfloat) params[1], + (GLfloat) params[2], (GLfloat) params[3]); +} + + +/** + * Note, this function is also used by the GL_NV_fragment_program extension. + */ +void GLAPIENTRY +_mesa_GetProgramLocalParameterfvARB(GLenum target, GLuint index, + GLfloat *params) +{ + const struct program *prog; + GLuint maxParams; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (target == GL_VERTEX_PROGRAM_ARB + && ctx->Extensions.ARB_vertex_program) { + prog = &(ctx->VertexProgram.Current->Base); + maxParams = ctx->Const.MaxVertexProgramLocalParams; + } + else if (target == GL_FRAGMENT_PROGRAM_ARB + && ctx->Extensions.ARB_fragment_program) { + prog = &(ctx->FragmentProgram.Current->Base); + maxParams = ctx->Const.MaxFragmentProgramLocalParams; + } + else if (target == GL_FRAGMENT_PROGRAM_NV + && ctx->Extensions.NV_fragment_program) { + prog = &(ctx->FragmentProgram.Current->Base); + maxParams = MAX_NV_FRAGMENT_PROGRAM_PARAMS; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, + "glGetProgramLocalParameterARB(target)"); + return; + } + + if (index >= maxParams) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glGetProgramLocalParameterARB(index)"); + return; + } + + ASSERT(prog); + ASSERT(index < MAX_PROGRAM_LOCAL_PARAMS); + COPY_4V(params, prog->LocalParams[index]); +} + + +/** + * Note, this function is also used by the GL_NV_fragment_program extension. + */ +void GLAPIENTRY +_mesa_GetProgramLocalParameterdvARB(GLenum target, GLuint index, + GLdouble *params) +{ + GET_CURRENT_CONTEXT(ctx); + GLfloat floatParams[4]; + _mesa_GetProgramLocalParameterfvARB(target, index, floatParams); + if (ctx->ErrorValue == GL_NO_ERROR) { + COPY_4V(params, floatParams); + } +} + + +void GLAPIENTRY +_mesa_GetProgramivARB(GLenum target, GLenum pname, GLint *params) +{ + struct program *prog; + GET_CURRENT_CONTEXT(ctx); + + if (!ctx->_CurrentProgram) + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (target == GL_VERTEX_PROGRAM_ARB + && ctx->Extensions.ARB_vertex_program) { + prog = &(ctx->VertexProgram.Current->Base); + } + else if (target == GL_FRAGMENT_PROGRAM_ARB + && ctx->Extensions.ARB_fragment_program) { + prog = &(ctx->FragmentProgram.Current->Base); + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)"); + return; + } + + ASSERT(prog); + + switch (pname) { + case GL_PROGRAM_LENGTH_ARB: + *params = prog->String ? (GLint)_mesa_strlen((char *) prog->String) : 0; + break; + case GL_PROGRAM_FORMAT_ARB: + *params = prog->Format; + break; + case GL_PROGRAM_BINDING_ARB: + *params = prog->Id; + break; + case GL_PROGRAM_INSTRUCTIONS_ARB: + *params = prog->NumInstructions; + break; + case GL_MAX_PROGRAM_INSTRUCTIONS_ARB: + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramInstructions; + else + *params = ctx->Const.MaxFragmentProgramInstructions; + break; + case GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB: + *params = prog->NumInstructions; + break; + case GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB: + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramInstructions; + else + *params = ctx->Const.MaxFragmentProgramInstructions; + break; + case GL_PROGRAM_TEMPORARIES_ARB: + *params = prog->NumTemporaries; + break; + case GL_MAX_PROGRAM_TEMPORARIES_ARB: + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramTemps; + else + *params = ctx->Const.MaxFragmentProgramTemps; + break; + case GL_PROGRAM_NATIVE_TEMPORARIES_ARB: + /* XXX same as GL_PROGRAM_TEMPORARIES_ARB? */ + *params = prog->NumTemporaries; + break; + case GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB: + /* XXX same as GL_MAX_PROGRAM_TEMPORARIES_ARB? */ + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramTemps; + else + *params = ctx->Const.MaxFragmentProgramTemps; + break; + case GL_PROGRAM_PARAMETERS_ARB: + *params = prog->NumParameters; + break; + case GL_MAX_PROGRAM_PARAMETERS_ARB: + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramLocalParams; + else + *params = ctx->Const.MaxFragmentProgramLocalParams; + break; + case GL_PROGRAM_NATIVE_PARAMETERS_ARB: + /* XXX same as GL_MAX_PROGRAM_PARAMETERS_ARB? */ + *params = prog->NumParameters; + break; + case GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB: + /* XXX same as GL_MAX_PROGRAM_PARAMETERS_ARB? */ + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramLocalParams; + else + *params = ctx->Const.MaxFragmentProgramLocalParams; + break; + case GL_PROGRAM_ATTRIBS_ARB: + *params = prog->NumAttributes; + break; + case GL_MAX_PROGRAM_ATTRIBS_ARB: + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramAttribs; + else + *params = ctx->Const.MaxFragmentProgramAttribs; + break; + case GL_PROGRAM_NATIVE_ATTRIBS_ARB: + /* XXX same as GL_PROGRAM_ATTRIBS_ARB? */ + *params = prog->NumAttributes; + break; + case GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB: + /* XXX same as GL_MAX_PROGRAM_ATTRIBS_ARB? */ + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramAttribs; + else + *params = ctx->Const.MaxFragmentProgramAttribs; + break; + case GL_PROGRAM_ADDRESS_REGISTERS_ARB: + *params = prog->NumAddressRegs; + break; + case GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB: + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramAddressRegs; + else + *params = ctx->Const.MaxFragmentProgramAddressRegs; + break; + case GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB: + /* XXX same as GL_PROGRAM_ADDRESS_REGISTERS_ARB? */ + *params = prog->NumAddressRegs; + break; + case GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB: + /* XXX same as GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB? */ + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramAddressRegs; + else + *params = ctx->Const.MaxFragmentProgramAddressRegs; + break; + case GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB: + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramLocalParams; + else + *params = ctx->Const.MaxFragmentProgramLocalParams; + break; + case GL_MAX_PROGRAM_ENV_PARAMETERS_ARB: + if (target == GL_VERTEX_PROGRAM_ARB) + *params = ctx->Const.MaxVertexProgramEnvParams; + else + *params = ctx->Const.MaxFragmentProgramEnvParams; + break; + case GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB: + if (ctx->Driver.IsProgramNative) + *params = ctx->Driver.IsProgramNative( ctx, target, prog ); + else + *params = GL_TRUE; + break; + + /* + * The following apply to fragment programs only. + */ + case GL_PROGRAM_ALU_INSTRUCTIONS_ARB: + case GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB: + if (target != GL_FRAGMENT_PROGRAM_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)"); + return; + } + *params = ctx->FragmentProgram.Current->NumAluInstructions; + break; + case GL_PROGRAM_TEX_INSTRUCTIONS_ARB: + case GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB: + if (target != GL_FRAGMENT_PROGRAM_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)"); + return; + } + *params = ctx->FragmentProgram.Current->NumTexInstructions; + break; + case GL_PROGRAM_TEX_INDIRECTIONS_ARB: + case GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB: + if (target != GL_FRAGMENT_PROGRAM_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)"); + return; + } + *params = ctx->FragmentProgram.Current->NumTexIndirections; + break; + case GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB: + case GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB: + if (target != GL_FRAGMENT_PROGRAM_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)"); + return; + } + *params = ctx->Const.MaxFragmentProgramAluInstructions; + break; + case GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB: + case GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB: + if (target != GL_FRAGMENT_PROGRAM_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)"); + return; + } + *params = ctx->Const.MaxFragmentProgramTexInstructions; + break; + case GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB: + case GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB: + if (target != GL_FRAGMENT_PROGRAM_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(target)"); + return; + } + *params = ctx->Const.MaxFragmentProgramTexIndirections; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramivARB(pname)"); + return; + } +} + + +void GLAPIENTRY +_mesa_GetProgramStringARB(GLenum target, GLenum pname, GLvoid *string) +{ + struct program *prog; + GET_CURRENT_CONTEXT(ctx); + + if (!ctx->_CurrentProgram) + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (target == GL_VERTEX_PROGRAM_ARB) { + prog = &(ctx->VertexProgram.Current->Base); + } + else if (target == GL_FRAGMENT_PROGRAM_ARB) { + prog = &(ctx->FragmentProgram.Current->Base); + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramStringARB(target)"); + return; + } + + ASSERT(prog); + + if (pname != GL_PROGRAM_STRING_ARB) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramStringARB(pname)"); + return; + } + + MEMCPY(string, prog->String, _mesa_strlen((char *) prog->String)); +} + diff --git a/src/mesa/shader/arbprogram.h b/src/mesa/shader/arbprogram.h new file mode 100644 index 000000000..e1b99ab68 --- /dev/null +++ b/src/mesa/shader/arbprogram.h @@ -0,0 +1,128 @@ +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#ifndef ARBPROGRAM_H +#define ARBPROGRAM_H + + +extern void GLAPIENTRY +_mesa_EnableVertexAttribArrayARB(GLuint index); + + +extern void GLAPIENTRY +_mesa_DisableVertexAttribArrayARB(GLuint index); + + +extern void GLAPIENTRY +_mesa_GetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params); + + +extern void GLAPIENTRY +_mesa_GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params); + + +extern void GLAPIENTRY +_mesa_GetVertexAttribivARB(GLuint index, GLenum pname, GLint *params); + + +extern void GLAPIENTRY +_mesa_GetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid **pointer); + + +extern void GLAPIENTRY +_mesa_ProgramStringARB(GLenum target, GLenum format, GLsizei len, + const GLvoid *string); + + +extern void GLAPIENTRY +_mesa_ProgramEnvParameter4dARB(GLenum target, GLuint index, + GLdouble x, GLdouble y, GLdouble z, GLdouble w); + + +extern void GLAPIENTRY +_mesa_ProgramEnvParameter4dvARB(GLenum target, GLuint index, + const GLdouble *params); + + +extern void GLAPIENTRY +_mesa_ProgramEnvParameter4fARB(GLenum target, GLuint index, + GLfloat x, GLfloat y, GLfloat z, GLfloat w); + + +extern void GLAPIENTRY +_mesa_ProgramEnvParameter4fvARB(GLenum target, GLuint index, + const GLfloat *params); + + +extern void GLAPIENTRY +_mesa_ProgramLocalParameter4dARB(GLenum target, GLuint index, + GLdouble x, GLdouble y, + GLdouble z, GLdouble w); + + +extern void GLAPIENTRY +_mesa_ProgramLocalParameter4dvARB(GLenum target, GLuint index, + const GLdouble *params); + + +extern void GLAPIENTRY +_mesa_ProgramLocalParameter4fARB(GLenum target, GLuint index, + GLfloat x, GLfloat y, GLfloat z, GLfloat w); + + +extern void GLAPIENTRY +_mesa_ProgramLocalParameter4fvARB(GLenum target, GLuint index, + const GLfloat *params); + + +extern void GLAPIENTRY +_mesa_GetProgramEnvParameterdvARB(GLenum target, GLuint index, + GLdouble *params); + + +extern void GLAPIENTRY +_mesa_GetProgramEnvParameterfvARB(GLenum target, GLuint index, + GLfloat *params); + + +extern void GLAPIENTRY +_mesa_GetProgramLocalParameterdvARB(GLenum target, GLuint index, + GLdouble *params); + + +extern void GLAPIENTRY +_mesa_GetProgramLocalParameterfvARB(GLenum target, GLuint index, + GLfloat *params); + + +extern void GLAPIENTRY +_mesa_GetProgramivARB(GLenum target, GLenum pname, GLint *params); + + +extern void GLAPIENTRY +_mesa_GetProgramStringARB(GLenum target, GLenum pname, GLvoid *string); + + +#endif diff --git a/src/mesa/shader/arbprogram.syn b/src/mesa/shader/arbprogram.syn new file mode 100644 index 000000000..6ab0f2693 --- /dev/null +++ b/src/mesa/shader/arbprogram.syn @@ -0,0 +1,2786 @@ +/* + * Mesa 3-D graphics library + * Version: 6.2 + * + * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + /** + * \file arbprogram.syn + * ARB_fragment/vertex_program syntax + * \author Michal Krol + */ + +.syntax program; + +/* + This value must be incremented every time emit code values or structure of the production + array changes. This value is placed at the beginning of the production array. The loader + compares the value with its REVISION value. If they do not match, the loader is not up + to date. +*/ +.emtcode REVISION 0x09 + +/* program type */ +.emtcode FRAGMENT_PROGRAM 0x01 +.emtcode VERTEX_PROGRAM 0x02 + +/* program section */ +.emtcode OPTION 0x01 +.emtcode INSTRUCTION 0x02 +.emtcode DECLARATION 0x03 +.emtcode END 0x04 + +/* GL_ARB_fragment_program option */ +.emtcode ARB_PRECISION_HINT_FASTEST 0x00 +.emtcode ARB_PRECISION_HINT_NICEST 0x01 +.emtcode ARB_FOG_EXP 0x02 +.emtcode ARB_FOG_EXP2 0x03 +.emtcode ARB_FOG_LINEAR 0x04 + +/* GL_ARB_vertex_program option */ +.emtcode ARB_POSITION_INVARIANT 0x05 + +/* GL_ARB_fragment_program_shadow option */ +.emtcode ARB_FRAGMENT_PROGRAM_SHADOW 0x06 + +/* GL_ARB_draw_buffers option */ +.emtcode ARB_DRAW_BUFFERS 0x07 + +/* GL_ARB_fragment_program instruction class */ +.emtcode OP_ALU_INST 0x00 +.emtcode OP_TEX_INST 0x01 + +/* GL_ARB_vertex_program instruction class */ +/* OP_ALU_INST */ + +/* GL_ARB_fragment_program instruction type */ +.emtcode OP_ALU_VECTOR 0x00 +.emtcode OP_ALU_SCALAR 0x01 +.emtcode OP_ALU_BINSC 0x02 +.emtcode OP_ALU_BIN 0x03 +.emtcode OP_ALU_TRI 0x04 +.emtcode OP_ALU_SWZ 0x05 +.emtcode OP_TEX_SAMPLE 0x06 +.emtcode OP_TEX_KIL 0x07 + +/* GL_ARB_vertex_program instruction type */ +.emtcode OP_ALU_ARL 0x08 +/* OP_ALU_VECTOR */ +/* OP_ALU_SCALAR */ +/* OP_ALU_BINSC */ +/* OP_ALU_BIN */ +/* OP_ALU_TRI */ +/* OP_ALU_SWZ */ + +/* GL_ARB_fragment_program instruction code */ +.emtcode OP_ABS 0x00 +.emtcode OP_ABS_SAT 0x1B +.emtcode OP_FLR 0x09 +.emtcode OP_FLR_SAT 0x26 +.emtcode OP_FRC 0x0A +.emtcode OP_FRC_SAT 0x27 +.emtcode OP_LIT 0x0C +.emtcode OP_LIT_SAT 0x2A +.emtcode OP_MOV 0x11 +.emtcode OP_MOV_SAT 0x30 +.emtcode OP_COS 0x1F +.emtcode OP_COS_SAT 0x20 +.emtcode OP_EX2 0x07 +.emtcode OP_EX2_SAT 0x25 +.emtcode OP_LG2 0x0B +.emtcode OP_LG2_SAT 0x29 +.emtcode OP_RCP 0x14 +.emtcode OP_RCP_SAT 0x33 +.emtcode OP_RSQ 0x15 +.emtcode OP_RSQ_SAT 0x34 +.emtcode OP_SIN 0x38 +.emtcode OP_SIN_SAT 0x39 +.emtcode OP_SCS 0x35 +.emtcode OP_SCS_SAT 0x36 +.emtcode OP_POW 0x13 +.emtcode OP_POW_SAT 0x32 +.emtcode OP_ADD 0x01 +.emtcode OP_ADD_SAT 0x1C +.emtcode OP_DP3 0x03 +.emtcode OP_DP3_SAT 0x21 +.emtcode OP_DP4 0x04 +.emtcode OP_DP4_SAT 0x22 +.emtcode OP_DPH 0x05 +.emtcode OP_DPH_SAT 0x23 +.emtcode OP_DST 0x06 +.emtcode OP_DST_SAT 0x24 +.emtcode OP_MAX 0x0F +.emtcode OP_MAX_SAT 0x2E +.emtcode OP_MIN 0x10 +.emtcode OP_MIN_SAT 0x2F +.emtcode OP_MUL 0x12 +.emtcode OP_MUL_SAT 0x31 +.emtcode OP_SGE 0x16 +.emtcode OP_SGE_SAT 0x37 +.emtcode OP_SLT 0x17 +.emtcode OP_SLT_SAT 0x3A +.emtcode OP_SUB 0x18 +.emtcode OP_SUB_SAT 0x3B +.emtcode OP_XPD 0x1A +.emtcode OP_XPD_SAT 0x43 +.emtcode OP_CMP 0x1D +.emtcode OP_CMP_SAT 0x1E +.emtcode OP_LRP 0x2B +.emtcode OP_LRP_SAT 0x2C +.emtcode OP_MAD 0x0E +.emtcode OP_MAD_SAT 0x2D +.emtcode OP_SWZ 0x19 +.emtcode OP_SWZ_SAT 0x3C +.emtcode OP_TEX 0x3D +.emtcode OP_TEX_SAT 0x3E +.emtcode OP_TXB 0x3F +.emtcode OP_TXB_SAT 0x40 +.emtcode OP_TXP 0x41 +.emtcode OP_TXP_SAT 0x42 +.emtcode OP_KIL 0x28 + +/* GL_ARB_vertex_program instruction code */ +.emtcode OP_ARL 0x02 +/* OP_ABS */ +/* OP_FLR */ +/* OP_FRC */ +/* OP_LIT */ +/* OP_MOV */ +/* OP_EX2 */ +.emtcode OP_EXP 0x08 +/* OP_LG2 */ +.emtcode OP_LOG 0x0D +/* OP_RCP */ +/* OP_RSQ */ +/* OP_POW */ +/* OP_ADD */ +/* OP_DP3 */ +/* OP_DP4 */ +/* OP_DPH */ +/* OP_DST */ +/* OP_MAX */ +/* OP_MIN */ +/* OP_MUL */ +/* OP_SGE */ +/* OP_SLT */ +/* OP_SUB */ +/* OP_XPD */ +/* OP_MAD */ +/* OP_SWZ */ + +/* fragment attribute binding */ +.emtcode FRAGMENT_ATTRIB_COLOR 0x01 +.emtcode FRAGMENT_ATTRIB_TEXCOORD 0x02 +.emtcode FRAGMENT_ATTRIB_FOGCOORD 0x03 +.emtcode FRAGMENT_ATTRIB_POSITION 0x04 + +/* vertex attribute binding */ +.emtcode VERTEX_ATTRIB_POSITION 0x01 +.emtcode VERTEX_ATTRIB_WEIGHT 0x02 +.emtcode VERTEX_ATTRIB_NORMAL 0x03 +.emtcode VERTEX_ATTRIB_COLOR 0x04 +.emtcode VERTEX_ATTRIB_FOGCOORD 0x05 +.emtcode VERTEX_ATTRIB_TEXCOORD 0x06 +.emtcode VERTEX_ATTRIB_MATRIXINDEX 0x07 +.emtcode VERTEX_ATTRIB_GENERIC 0x08 + +/* fragment result binding */ +.emtcode FRAGMENT_RESULT_COLOR 0x01 +.emtcode FRAGMENT_RESULT_DEPTH 0x02 + +/* vertex result binding */ +.emtcode VERTEX_RESULT_POSITION 0x01 +.emtcode VERTEX_RESULT_COLOR 0x02 +.emtcode VERTEX_RESULT_FOGCOORD 0x03 +.emtcode VERTEX_RESULT_POINTSIZE 0x04 +.emtcode VERTEX_RESULT_TEXCOORD 0x05 + +/* texture target */ +.emtcode TEXTARGET_1D 0x01 +.emtcode TEXTARGET_2D 0x02 +.emtcode TEXTARGET_3D 0x03 +.emtcode TEXTARGET_RECT 0x04 +.emtcode TEXTARGET_CUBE 0x05 +/* GL_ARB_fragment_program_shadow */ +.emtcode TEXTARGET_SHADOW1D 0x06 +.emtcode TEXTARGET_SHADOW2D 0x07 +.emtcode TEXTARGET_SHADOWRECT 0x08 + +/* face type */ +.emtcode FACE_FRONT 0x00 +.emtcode FACE_BACK 0x01 + +/* color type */ +.emtcode COLOR_PRIMARY 0x00 +.emtcode COLOR_SECONDARY 0x01 + +/* component */ +.emtcode COMPONENT_X 0x00 +.emtcode COMPONENT_Y 0x01 +.emtcode COMPONENT_Z 0x02 +.emtcode COMPONENT_W 0x03 +.emtcode COMPONENT_0 0x04 +.emtcode COMPONENT_1 0x05 + +/* array index type */ +.emtcode ARRAY_INDEX_ABSOLUTE 0x00 +.emtcode ARRAY_INDEX_RELATIVE 0x01 + +/* matrix name */ +.emtcode MATRIX_MODELVIEW 0x01 +.emtcode MATRIX_PROJECTION 0x02 +.emtcode MATRIX_MVP 0x03 +.emtcode MATRIX_TEXTURE 0x04 +.emtcode MATRIX_PALETTE 0x05 +.emtcode MATRIX_PROGRAM 0x06 + +/* matrix modifier */ +.emtcode MATRIX_MODIFIER_IDENTITY 0x00 +.emtcode MATRIX_MODIFIER_INVERSE 0x01 +.emtcode MATRIX_MODIFIER_TRANSPOSE 0x02 +.emtcode MATRIX_MODIFIER_INVTRANS 0x03 + +/* constant type */ +.emtcode CONSTANT_SCALAR 0x01 +.emtcode CONSTANT_VECTOR 0x02 + +/* program param type */ +.emtcode PROGRAM_PARAM_ENV 0x01 +.emtcode PROGRAM_PARAM_LOCAL 0x02 + +/* register type */ +.emtcode REGISTER_ATTRIB 0x01 +.emtcode REGISTER_PARAM 0x02 +.emtcode REGISTER_RESULT 0x03 +.emtcode REGISTER_ESTABLISHED_NAME 0x04 + +/* param binding */ +.emtcode PARAM_NULL 0x00 +.emtcode PARAM_ARRAY_ELEMENT 0x01 +.emtcode PARAM_STATE_ELEMENT 0x02 +.emtcode PARAM_PROGRAM_ELEMENT 0x03 +.emtcode PARAM_PROGRAM_ELEMENTS 0x04 +.emtcode PARAM_CONSTANT 0x05 + +/* param state property */ +.emtcode STATE_MATERIAL 0x01 +.emtcode STATE_LIGHT 0x02 +.emtcode STATE_LIGHT_MODEL 0x03 +.emtcode STATE_LIGHT_PROD 0x04 +.emtcode STATE_FOG 0x05 +.emtcode STATE_MATRIX_ROWS 0x06 +/* GL_ARB_fragment_program */ +.emtcode STATE_TEX_ENV 0x07 +.emtcode STATE_DEPTH 0x08 +/* GL_ARB_vertex_program */ +.emtcode STATE_TEX_GEN 0x09 +.emtcode STATE_CLIP_PLANE 0x0A +.emtcode STATE_POINT 0x0B + +/* state material property */ +.emtcode MATERIAL_AMBIENT 0x01 +.emtcode MATERIAL_DIFFUSE 0x02 +.emtcode MATERIAL_SPECULAR 0x03 +.emtcode MATERIAL_EMISSION 0x04 +.emtcode MATERIAL_SHININESS 0x05 + +/* state light property */ +.emtcode LIGHT_AMBIENT 0x01 +.emtcode LIGHT_DIFFUSE 0x02 +.emtcode LIGHT_SPECULAR 0x03 +.emtcode LIGHT_POSITION 0x04 +.emtcode LIGHT_ATTENUATION 0x05 +.emtcode LIGHT_HALF 0x06 +.emtcode LIGHT_SPOT_DIRECTION 0x07 + +/* state light model property */ +.emtcode LIGHT_MODEL_AMBIENT 0x01 +.emtcode LIGHT_MODEL_SCENECOLOR 0x02 + +/* state light product property */ +.emtcode LIGHT_PROD_AMBIENT 0x01 +.emtcode LIGHT_PROD_DIFFUSE 0x02 +.emtcode LIGHT_PROD_SPECULAR 0x03 + +/* state texture environment property */ +.emtcode TEX_ENV_COLOR 0x01 + +/* state texture generation coord property */ +.emtcode TEX_GEN_EYE 0x01 +.emtcode TEX_GEN_OBJECT 0x02 + +/* state fog property */ +.emtcode FOG_COLOR 0x01 +.emtcode FOG_PARAMS 0x02 + +/* state depth property */ +.emtcode DEPTH_RANGE 0x01 + +/* state point parameters property */ +.emtcode POINT_SIZE 0x01 +.emtcode POINT_ATTENUATION 0x02 + +/* declaration */ +.emtcode ATTRIB 0x01 +.emtcode PARAM 0x02 +.emtcode TEMP 0x03 +.emtcode OUTPUT 0x04 +.emtcode ALIAS 0x05 +/* GL_ARB_vertex_program */ +.emtcode ADDRESS 0x06 + +/* error messages */ +.errtext UNKNOWN_PROGRAM_SIGNATURE "1001: '$e_signature$': unknown program signature" +.errtext MISSING_END_OR_INVALID_STATEMENT "1002: '$e_statement$': invalid statement" +.errtext CODE_AFTER_END "1003: '$e_statement$': code after 'END' keyword" +.errtext INVALID_PROGRAM_OPTION "1004: '$e_identifier$': invalid program option" +.errtext EXT_SWIZ_COMP_EXPECTED "1005: extended swizzle component expected but '$e_token$' found" +.errtext TEX_TARGET_EXPECTED "1006: texture target expected but '$e_token$' found" +.errtext TEXTURE_EXPECTED "1007: 'texture' expected but '$e_identifier$' found" +.errtext SOURCE_REGISTER_EXPECTED "1008: source register expected but '$e_token$' found" +.errtext DESTINATION_REGISTER_EXPECTED "1009: destination register expected but '$e_token$' found" +.errtext INVALID_ADDRESS_COMPONENT "1010: '$e_identifier$': invalid address component" +.errtext INVALID_ADDRESS_WRITEMASK "1011: '$e_identifier$': invalid address writemask" +.errtext INVALID_COMPONENT "1012: '$e_charordigit$': invalid component" +.errtext INVALID_SUFFIX "1013: '$e_identifier$': invalid suffix" +.errtext INVALID_WRITEMASK "1014: '$e_identifier$': invalid writemask" +.errtext FRAGMENT_EXPECTED "1015: 'fragment' expected but '$e_identifier$' found" +.errtext VERTEX_EXPECTED "1016: 'vertex' expected but '$e_identifier$' found" +.errtext INVALID_FRAGMENT_PROPERTY "1017: '$e_identifier$': invalid fragment property" +.errtext INVALID_VERTEX_PROPERTY "1018: '$e_identifier$': invalid vertex property" +.errtext INVALID_STATE_PROPERTY "1019: '$e_identifier$': invalid state property" +.errtext INVALID_MATERIAL_PROPERTY "1020: '$e_identifier$': invalid material property" +.errtext INVALID_LIGHT_PROPERTY "1021: '$e_identifier$': invalid light property" +.errtext INVALID_SPOT_PROPERTY "1022: '$e_identifier$': invalid spot property" +.errtext INVALID_LIGHTMODEL_PROPERTY "1023: '$e_identifier$': invalid light model property" +.errtext INVALID_LIGHTPROD_PROPERTY "1024: '$e_identifier$': invalid light product property" +.errtext INVALID_TEXENV_PROPERTY "1025: '$e_identifier$': invalid texture environment property" +.errtext INVALID_TEXGEN_PROPERTY "1026: '$e_identifier$': invalid texture generating property" +.errtext INVALID_TEXGEN_COORD "1027: '$e_identifier$': invalid texture generating coord" +.errtext INVALID_FOG_PROPERTY "1028: '$e_identifier$': invalid fog property" +.errtext INVALID_DEPTH_PROPERTY "1029: '$e_identifier$': invalid depth property" +.errtext INVALID_CLIPPLANE_PROPERTY "1030: '$e_identifier$': invalid clip plane property" +.errtext INVALID_POINT_PROPERTY "1031: '$e_identifier$': invalid point property" +.errtext MATRIX_ROW_SELECTOR_OR_MODIFIER_EXPECTED "1032: matrix row selector or modifier expected but '$e_token$' found" +.errtext INVALID_MATRIX_NAME "1033: '$e_identifier$': invalid matrix name" +.errtext INVALID_PROGRAM_PROPERTY "1034: '$e_identifier$': invalid program property" +.errtext RESULT_EXPECTED "1035: 'result' expected but '$e_token$' found" +.errtext INVALID_RESULT_PROPERTY "1036: '$e_identifier$': invalid result property" +.errtext INVALID_FACE_PROPERTY "1037: '$e_identifier$': invalid face property" +.errtext INVALID_COLOR_PROPERTY "1038: '$e_identifier$': invalid color property" +.errtext IDENTIFIER_EXPECTED "1039: identifier expected but '$e_token$' found" +.errtext RESERVED_KEYWORD "1040: use of reserved keyword as an identifier" +.errtext INTEGER_EXPECTED "1041: integer value expected but '$e_token$' found" +.errtext MISSING_SEMICOLON "1042: ';' expected but '$e_token$' found" +.errtext MISSING_COMMA "1043: ',' expected but '$e_token$' found" +.errtext MISSING_LBRACKET "1044: '[' expected but '$e_token$' found" +.errtext MISSING_RBRACKET "1045: ']' expected but '$e_token$' found" +.errtext MISSING_DOT "1046: '.' expected but '$e_token$' found" +.errtext MISSING_EQUAL "1047: '=' expected but '$e_token$' found" +.errtext MISSING_LBRACE "1048: '{' expected but '$e_token$' found" +.errtext MISSING_RBRACE "1049: '}' expected but '$e_token$' found" +.errtext MISSING_DOTDOT "1050: '..' expected but '$e_token$' found" +.errtext MISSING_FRACTION_OR_EXPONENT "1051: missing fraction part or exponent" +.errtext MISSING_DOT_OR_EXPONENT "1052: missing '.' or exponent" +.errtext EXPONENT_VALUE_EXPECTED "1053: exponent value expected" +.errtext INTEGER_OUT_OF_RANGE "1054: integer value out of range" +.errtext OPERATION_NEEDS_DESTINATION_VARIABLE "1055: operation needs destination variable" +.errtext OPERATION_NEEDS_SOURCE_VARIABLE "1056: operation needs source variable" +.errtext ADDRESS_REGISTER_EXPECTED "1057: address register expected but '$e_token$' found" +.errtext ADDRESS_REGISTER_OR_INTEGER_EXPECTED "1058: address register or integer literal expected but '$e_token$' found" + +/* extension presence condition registers */ + +/* GL_ARB_vertex_blend */ +/* GL_EXT_vertex_weighting */ +.regbyte vertex_blend 0x00 + +/* GL_ARB_matrix_palette */ +.regbyte matrix_palette 0x00 + +/* GL_ARB_point_parameters */ +/* GL_EXT_point_parameters */ +.regbyte point_parameters 0x00 + +/* GL_EXT_secondary_color */ +.regbyte secondary_color 0x00 + +/* GL_EXT_fog_coord */ +.regbyte fog_coord 0x00 + +/* GL_EXT_texture_rectangle */ +/* GL_NV_texture_rectangle */ +.regbyte texture_rectangle 0x00 + +/* GL_ARB_fragment_program_shadow */ +.regbyte fragment_program_shadow 0x00 + +/* GL_ARB_draw_buffers */ +.regbyte draw_buffers 0x00 + +/* option presence condition registers */ +/* they are all initially set to zero - when a particular OPTION is encountered, the appropriate */ +/* register is set to 1 to indicate that the OPTION was specified. */ + +/* GL_ARB_fragment_program */ +.regbyte ARB_precision_hint_fastest 0x00 +.regbyte ARB_precision_hint_nicest 0x00 +.regbyte ARB_fog_exp 0x00 +.regbyte ARB_fog_exp2 0x00 +.regbyte ARB_fog_linear 0x00 + +/* GL_ARB_vertex_program */ +.regbyte ARB_position_invariant 0x00 + +/* GL_ARB_fragment_program_shadow */ +.regbyte ARB_fragment_program_shadow 0x00 + +/* GL_ARB_draw_buffers */ +.regbyte ARB_draw_buffers 0x00 + +/* program target condition register */ +/* this syntax script deals with two program targets - VERTEX_PROGRAM and FRAGMENT_PROGRAM. */ +/* to distinguish between them we need a register that will store for us the current target. */ +/* the client will typically set the register to apropriate value before parsing a particular */ +/* program. the mapping between program targets and their values is listed below. */ +/* */ +/* program target register value */ +/* ---------------------------------------------- */ +/* FRAGMENT_PROGRAM 0x10 */ +/* VERTEX_PROGRAM 0x20 */ +/* */ +/* the initial value of the register is 0 to catch potential errors with not setting the register */ +/* with the proper value. */ +.regbyte program_target 0x00 + +/* + ::= "END" +*/ +program + programs .error UNKNOWN_PROGRAM_SIGNATURE .emit REVISION; +programs + .if (program_target == 0x10) frag_program_1_0 .emit FRAGMENT_PROGRAM .emit 0x01 .emit 0x00 .or + .if (program_target == 0x20) vert_program_1_0 .emit VERTEX_PROGRAM .emit 0x01 .emit 0x00; +frag_program_1_0 + '!' .and '!' .and 'A' .and 'R' .and 'B' .and 'f' .and 'p' .and '1' .and '.' .and '0' .and + optional_space .and fp_optionSequence .and fp_statementSequence .and + "END" .error MISSING_END_OR_INVALID_STATEMENT .emit END .and optional_space .and + '\0' .error CODE_AFTER_END; +vert_program_1_0 + '!' .and '!' .and 'A' .and 'R' .and 'B' .and 'v' .and 'p' .and '1' .and '.' .and '0' .and + optional_space .and vp_optionSequence .and vp_statementSequence .and + "END" .error MISSING_END_OR_INVALID_STATEMENT .emit END .and optional_space .and + '\0' .error CODE_AFTER_END; + +/* + ::=