diff --git a/src/OpenGL ES 2.0/common/angleutils.h b/src/OpenGL ES 2.0/common/angleutils.h
index 24c766b..1d55111 100644
--- a/src/OpenGL ES 2.0/common/angleutils.h
+++ b/src/OpenGL ES 2.0/common/angleutils.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // angleutils.h: Common ANGLE utilities.
diff --git a/src/OpenGL ES 2.0/common/debug.cpp b/src/OpenGL ES 2.0/common/debug.cpp
index 44f9667..fbc122d 100644
--- a/src/OpenGL ES 2.0/common/debug.cpp
+++ b/src/OpenGL ES 2.0/common/debug.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // debug.cpp: Debugging utilities.
diff --git a/src/OpenGL ES 2.0/common/debug.h b/src/OpenGL ES 2.0/common/debug.h
index 31d8371..bfab636 100644
--- a/src/OpenGL ES 2.0/common/debug.h
+++ b/src/OpenGL ES 2.0/common/debug.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // debug.h: Debugging utilities.
@@ -67,6 +72,7 @@
 #endif
 
 // A macro for code which is not expected to be reached under valid assumptions
+
 #if !defined(NDEBUG)
 #define UNREACHABLE() do { \
     ERR("\t! Unreachable reached: %s(%d)\n", __FUNCTION__, __LINE__); \
diff --git a/src/OpenGL ES 2.0/compiler/BaseTypes.h b/src/OpenGL ES 2.0/compiler/BaseTypes.h
index 9f4a860..3334436 100644
--- a/src/OpenGL ES 2.0/compiler/BaseTypes.h
+++ b/src/OpenGL ES 2.0/compiler/BaseTypes.h
@@ -45,6 +45,7 @@
     EbtGuardSamplerEnd,    // non type:  see implementation of IsSampler()
     EbtStruct,
     EbtAddress,            // should be deprecated??
+    EbtInvariant,          // used as a type when qualifying a previously declared variable as being invariant
 };
 
 inline const char* getBasicString(TBasicType t)
diff --git a/src/OpenGL ES 2.0/compiler/Compiler.cpp b/src/OpenGL ES 2.0/compiler/Compiler.cpp
index 28bebef..bae2db2 100644
--- a/src/OpenGL ES 2.0/compiler/Compiler.cpp
+++ b/src/OpenGL ES 2.0/compiler/Compiler.cpp
@@ -9,7 +9,6 @@
 #include "compiler/ParseHelper.h"
 #include "compiler/ShHandle.h"
 #include "compiler/ValidateLimitations.h"
-#include "compiler/MapLongVariableNames.h"
 
 namespace {
 bool InitializeSymbolTable(
@@ -152,12 +151,6 @@
         if (success && (compileOptions & SH_VALIDATE_LOOP_INDEXING))
             success = validateLimitations(root);
 
-        // Call mapLongVariableNames() before collectAttribsUniforms() so in
-        // collectAttribsUniforms() we already have the mapped symbol names and
-        // we could composite mapped and original variable names.
-        if (success && (compileOptions & SH_MAP_LONG_VARIABLE_NAMES))
-            mapLongVariableNames(root);
-
         if (success && (compileOptions & SH_ATTRIBUTES_UNIFORMS))
             collectAttribsUniforms(root);
 
@@ -227,14 +220,3 @@
     CollectAttribsUniforms collect(attribs, uniforms);
     root->traverse(&collect);
 }
-
-void TCompiler::mapLongVariableNames(TIntermNode* root)
-{
-    MapLongVariableNames map(varyingLongNameMap);
-    root->traverse(&map);
-}
-
-int TCompiler::getMappedNameMaxLength() const
-{
-    return MAX_IDENTIFIER_NAME_SIZE + 1;
-}
diff --git a/src/OpenGL ES 2.0/compiler/Compiler.vcxproj b/src/OpenGL ES 2.0/compiler/Compiler.vcxproj
new file mode 100644
index 0000000..7443422
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/Compiler.vcxproj
@@ -0,0 +1,218 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Profile|Win32">
+      <Configuration>Profile</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{5B3A6DB8-1E7E-40D7-92B9-DA8AAE619FAD}</ProjectGuid>
+    <RootNamespace>compiler</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectName>Compiler</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>NotSet</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>NotSet</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>NotSet</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">$(Platform)\$(Configuration)\</IntDir>
+    <IncludePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\include;$(DXSDK_DIR)\Include;$(VCInstallDir)PlatformSDK\include;$(IncludePath)</IncludePath>
+    <IncludePath Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\include;$(DXSDK_DIR)\Include;$(VCInstallDir)PlatformSDK\include;$(IncludePath)</IncludePath>
+    <IncludePath Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">..\include;$(DXSDK_DIR)\Include;$(VCInstallDir)PlatformSDK\include;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <BrowseInformation>true</BrowseInformation>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <AdditionalIncludeDirectories>$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <AdditionalIncludeDirectories>$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <OmitFramePointers>false</OmitFramePointers>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="Compiler.cpp" />
+    <ClCompile Include="DetectRecursion.cpp" />
+    <ClCompile Include="InfoSink.cpp" />
+    <ClCompile Include="Initialize.cpp" />
+    <ClCompile Include="InitializeDll.cpp" />
+    <ClCompile Include="Intermediate.cpp" />
+    <ClCompile Include="intermOut.cpp" />
+    <ClCompile Include="IntermTraverse.cpp" />
+    <ClCompile Include="ossource_win.cpp" />
+    <ClCompile Include="OutputASM.cpp" />
+    <ClCompile Include="parseConst.cpp" />
+    <ClCompile Include="ParseHelper.cpp" />
+    <ClCompile Include="PoolAlloc.cpp" />
+    <ClCompile Include="QualifierAlive.cpp" />
+    <ClCompile Include="RemoveTree.cpp" />
+    <ClCompile Include="ShaderLang.cpp" />
+    <ClCompile Include="SymbolTable.cpp" />
+    <ClCompile Include="TranslatorASM.cpp" />
+    <ClCompile Include="util.cpp" />
+    <ClCompile Include="ValidateLimitations.cpp" />
+    <ClCompile Include="VariableInfo.cpp" />
+    <ClCompile Include="preprocessor\atom.c" />
+    <ClCompile Include="preprocessor\cpp.c" />
+    <ClCompile Include="preprocessor\cppstruct.c" />
+    <ClCompile Include="preprocessor\memory.c" />
+    <ClCompile Include="preprocessor\scanner.c" />
+    <ClCompile Include="preprocessor\symbols.c" />
+    <ClCompile Include="preprocessor\tokens.c" />
+    <ClCompile Include="glslang_lex.cpp" />
+    <ClCompile Include="glslang_tab.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <CustomBuild Include="glslang.l">
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+      </Message>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+      </Command>
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(AdditionalInputs)</AdditionalInputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(Outputs)</Outputs>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+      </Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+      </Message>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+      </Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+      </Command>
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(AdditionalInputs)</AdditionalInputs>
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">%(AdditionalInputs)</AdditionalInputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">%(Outputs)</Outputs>
+    </CustomBuild>
+    <CustomBuild Include="glslang.y">
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+      </Message>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+      </Command>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(Outputs)</Outputs>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+      </Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+      </Message>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+      </Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">
+      </Command>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Profile|Win32'">%(Outputs)</Outputs>
+    </CustomBuild>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\GLSLANG\ShaderLang.h" />
+    <ClInclude Include="BaseTypes.h" />
+    <ClInclude Include="Common.h" />
+    <ClInclude Include="ConstantUnion.h" />
+    <ClInclude Include="DetectRecursion.h" />
+    <ClInclude Include="InfoSink.h" />
+    <ClInclude Include="Initialize.h" />
+    <ClInclude Include="InitializeDll.h" />
+    <ClInclude Include="InitializeGlobals.h" />
+    <ClInclude Include="InitializeParseContext.h" />
+    <ClInclude Include="intermediate.h" />
+    <ClInclude Include="localintermediate.h" />
+    <ClInclude Include="MMap.h" />
+    <ClInclude Include="osinclude.h" />
+    <ClInclude Include="OutputASM.h" />
+    <ClInclude Include="ParseHelper.h" />
+    <ClInclude Include="PoolAlloc.h" />
+    <ClInclude Include="QualifierAlive.h" />
+    <ClInclude Include="RemoveTree.h" />
+    <ClInclude Include="ShHandle.h" />
+    <ClInclude Include="SymbolTable.h" />
+    <ClInclude Include="TranslatorASM.h" />
+    <ClInclude Include="Types.h" />
+    <ClInclude Include="util.h" />
+    <ClInclude Include="ValidateLimitations.h" />
+    <ClInclude Include="VariableInfo.h" />
+    <ClInclude Include="preprocessor\atom.h" />
+    <ClInclude Include="preprocessor\compile.h" />
+    <ClInclude Include="preprocessor\cpp.h" />
+    <ClInclude Include="preprocessor\memory.h" />
+    <ClInclude Include="preprocessor\parser.h" />
+    <ClInclude Include="preprocessor\preprocess.h" />
+    <ClInclude Include="preprocessor\scanner.h" />
+    <ClInclude Include="preprocessor\slglobals.h" />
+    <ClInclude Include="preprocessor\symbols.h" />
+    <ClInclude Include="preprocessor\tokens.h" />
+    <ClInclude Include="glslang_tab.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/compiler/Compiler.vcxproj.filters b/src/OpenGL ES 2.0/compiler/Compiler.vcxproj.filters
new file mode 100644
index 0000000..574a5e8
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/Compiler.vcxproj.filters
@@ -0,0 +1,238 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Source Files\preprocessor">
+      <UniqueIdentifier>{01ac9b3c-03a5-4ac1-af5a-59fcf0258595}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\generated">
+      <UniqueIdentifier>{1add4406-d193-4c4e-a8ec-c41c8d0bd499}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Header Files\preprocessor">
+      <UniqueIdentifier>{63184d78-5261-4b85-a56c-1c69e626cdf3}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\generated">
+      <UniqueIdentifier>{a56a1771-4799-47ac-ace9-6955dd3f055b}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Compiler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="InfoSink.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Initialize.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="InitializeDll.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Intermediate.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="intermOut.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="IntermTraverse.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ossource_win.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="parseConst.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ParseHelper.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="PoolAlloc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="QualifierAlive.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="RemoveTree.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ShaderLang.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="SymbolTable.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ValidateLimitations.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="VariableInfo.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="preprocessor\atom.c">
+      <Filter>Source Files\preprocessor</Filter>
+    </ClCompile>
+    <ClCompile Include="preprocessor\cpp.c">
+      <Filter>Source Files\preprocessor</Filter>
+    </ClCompile>
+    <ClCompile Include="preprocessor\cppstruct.c">
+      <Filter>Source Files\preprocessor</Filter>
+    </ClCompile>
+    <ClCompile Include="preprocessor\memory.c">
+      <Filter>Source Files\preprocessor</Filter>
+    </ClCompile>
+    <ClCompile Include="preprocessor\scanner.c">
+      <Filter>Source Files\preprocessor</Filter>
+    </ClCompile>
+    <ClCompile Include="preprocessor\symbols.c">
+      <Filter>Source Files\preprocessor</Filter>
+    </ClCompile>
+    <ClCompile Include="preprocessor\tokens.c">
+      <Filter>Source Files\preprocessor</Filter>
+    </ClCompile>
+    <ClCompile Include="glslang_lex.cpp">
+      <Filter>Source Files\generated</Filter>
+    </ClCompile>
+    <ClCompile Include="glslang_tab.cpp">
+      <Filter>Source Files\generated</Filter>
+    </ClCompile>
+    <ClCompile Include="DetectRecursion.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="OutputASM.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="TranslatorASM.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="BaseTypes.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Common.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ConstantUnion.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="InfoSink.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Initialize.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="InitializeDll.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="InitializeGlobals.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="InitializeParseContext.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="intermediate.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="localintermediate.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="MMap.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="osinclude.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ParseHelper.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="PoolAlloc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="QualifierAlive.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="RemoveTree.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ShHandle.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="SymbolTable.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Types.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="util.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ValidateLimitations.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="VariableInfo.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\atom.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\compile.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\cpp.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\memory.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\parser.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\preprocess.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\scanner.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\slglobals.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\symbols.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor\tokens.h">
+      <Filter>Header Files\preprocessor</Filter>
+    </ClInclude>
+    <ClInclude Include="glslang_tab.h">
+      <Filter>Header Files\generated</Filter>
+    </ClInclude>
+    <ClInclude Include="DetectRecursion.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\GLSLANG\ShaderLang.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="OutputASM.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="TranslatorASM.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <CustomBuild Include="glslang.l">
+      <Filter>Source Files</Filter>
+    </CustomBuild>
+    <CustomBuild Include="glslang.y">
+      <Filter>Source Files</Filter>
+    </CustomBuild>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/compiler/ConstantUnion.h b/src/OpenGL ES 2.0/compiler/ConstantUnion.h
index d28a11b..89e83e4 100644
--- a/src/OpenGL ES 2.0/compiler/ConstantUnion.h
+++ b/src/OpenGL ES 2.0/compiler/ConstantUnion.h
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -24,6 +24,19 @@
     float getFConst() const { return fConst; }
     bool getBConst() const { return bConst; }
 
+	float getAsFloat()
+	{
+		const int FFFFFFFFh = 0xFFFFFFFF;
+
+		switch(type)
+		{
+        case EbtInt:   return (float)iConst;
+        case EbtFloat: return fConst;
+		case EbtBool:  return (bConst == true) ? (float&)FFFFFFFFh : 0;
+        default:       return 0;
+        }
+	}
+
     bool operator==(const int i) const
     {
         return i == iConst;
diff --git a/src/OpenGL ES 2.0/compiler/Initialize.cpp b/src/OpenGL ES 2.0/compiler/Initialize.cpp
index 74a2de3..8c33d36 100644
--- a/src/OpenGL ES 2.0/compiler/Initialize.cpp
+++ b/src/OpenGL ES 2.0/compiler/Initialize.cpp
@@ -612,9 +612,9 @@
     switch(type) {
     case SH_FRAGMENT_SHADER: {
             // Set up gl_FragData.  The array size.
-            TType fragData(EbtFloat, EbpMedium, EvqFragColor,   4, false, true);
+            TType fragData(EbtFloat, EbpMedium, EvqFragData, 4, false, true);
             fragData.setArraySize(resources.MaxDrawBuffers);
-            symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData"),    fragData));
+            symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData"), fragData));
         }
         break;
     default: break;
diff --git a/src/OpenGL ES 2.0/compiler/Intermediate.cpp b/src/OpenGL ES 2.0/compiler/Intermediate.cpp
index e1e8da2..d75083d 100644
--- a/src/OpenGL ES 2.0/compiler/Intermediate.cpp
+++ b/src/OpenGL ES 2.0/compiler/Intermediate.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -656,6 +656,7 @@
     // Make a selection node.
     //
     TIntermSelection* node = new TIntermSelection(cond, trueBlock, falseBlock, trueBlock->getType());
+	node->getTypePointer()->setQualifier(EvqTemporary);
     node->setLine(line);
 
     return node;
@@ -845,6 +846,11 @@
 
     setType(operand->getType());
 
+	// Unary operations results in temporary variables unless const.
+    if (operand->getQualifier() != EvqConst) {
+        getTypePointer()->setQualifier(EvqTemporary);
+    }
+
     return true;
 }
 
diff --git a/src/OpenGL ES 2.0/compiler/OutputASM.cpp b/src/OpenGL ES 2.0/compiler/OutputASM.cpp
new file mode 100644
index 0000000..49a1262
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/OutputASM.cpp
@@ -0,0 +1,2196 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "compiler/OutputASM.h"
+
+#include "common/debug.h"
+#include "compiler/InfoSink.h"
+
+#include "libGLESv2/Shader.h"
+
+#define GL_APICALL
+#include <GLES2/gl2.h>
+
+namespace sh
+{
+	static const unsigned char swizzleSize[5] = {0x00, 0x00, 0x54, 0xA4, 0xE4};   // (void), xxxx, xyyy, xyzz, xyzw
+
+	// Integer to TString conversion
+	TString str(int i)
+	{
+		char buffer[20];
+		sprintf(buffer, "%d", i);
+		return buffer;
+	}
+
+	class Temporary : public TIntermSymbol
+	{
+	public:
+		Temporary(OutputASM *assembler) : TIntermSymbol(0, "tmp", TType(EbtFloat, EbpHigh, EvqTemporary, 4, false, false)), assembler(assembler)
+		{
+		}
+
+		~Temporary()
+		{
+			assembler->freeTemporary(this);
+		}
+
+	private:
+		OutputASM *const assembler;
+	};
+
+	class Constant : public TIntermConstantUnion
+	{
+	public:
+		Constant(float x, float y, float z, float w) : TIntermConstantUnion(constants, TType(EbtFloat, EbpHigh, EvqConst, 4, false, false))
+		{
+			constants[0].setFConst(x);
+			constants[1].setFConst(y);
+			constants[2].setFConst(z);
+			constants[3].setFConst(w);
+		}
+
+		Constant(bool b) : TIntermConstantUnion(constants, TType(EbtBool, EbpHigh, EvqConst, 1, false, false))
+		{
+			constants[0].setBConst(b);
+		}
+
+		Constant(int i) : TIntermConstantUnion(constants, TType(EbtInt, EbpHigh, EvqConst, 1, false, false))
+		{
+			constants[0].setIConst(i);
+		}
+
+		~Constant()
+		{
+		}
+
+	private:
+		ConstantUnion constants[4];
+	};
+
+	Uniform::Uniform(GLenum type, const std::string &name, int arraySize, int registerIndex)
+	{
+		this->type = type;
+		this->name = name;
+		this->arraySize = arraySize;
+		this->registerIndex = registerIndex;
+	}
+
+	Attribute::Attribute()
+	{
+		type = GL_NONE;
+		arraySize = 0;
+		registerIndex = 0;
+	}
+
+	Attribute::Attribute(GLenum type, const std::string &name, int arraySize, int registerIndex)
+	{
+		this->type = type;
+		this->name = name;
+		this->arraySize = arraySize;
+		this->registerIndex = registerIndex;
+	}
+
+	OutputASM::OutputASM(TParseContext &context, gl::Shader *shaderObject) : TIntermTraverser(true, true, true), mContext(context), shaderObject(shaderObject)
+	{
+		shader = 0;
+		pixelShader = 0;
+		vertexShader = 0;
+
+		if(shaderObject)
+		{
+			shader = shaderObject->getShader();
+			pixelShader = shaderObject->getPixelShader();
+			vertexShader = shaderObject->getVertexShader();
+		}
+
+		functionArray.push_back(Function(0, "main(", 0, 0));
+		currentFunction = 0;
+	}
+
+	OutputASM::~OutputASM()
+	{
+	}
+
+	void OutputASM::output()
+	{
+		if(shader)
+		{
+			emitShader(GLOBAL);
+
+			if(functionArray.size() > 1)   // Only call main() when there are other functions
+			{
+				Instruction *callMain = emit(sw::Shader::OPCODE_CALL);
+				callMain->dst.type = sw::Shader::PARAMETER_LABEL;
+				callMain->dst.index = 0;   // main()
+
+				emit(sw::Shader::OPCODE_RET);
+			}
+
+			emitShader(FUNCTION);
+		}
+	}
+
+	void OutputASM::emitShader(Scope scope)
+	{
+		emitScope = scope;
+		currentScope = GLOBAL;
+		mContext.treeRoot->traverse(this);
+	}
+
+	void OutputASM::freeTemporary(Temporary *temporary)
+	{
+		free(temporaries, temporary);
+	}
+
+	bool OutputASM::visitBinary(Visit visit, TIntermBinary *node)
+	{
+		if(currentScope != emitScope)
+		{
+			return false;
+		}
+
+		TIntermTyped *result = node;
+		TIntermTyped *left = node->getLeft();
+		TIntermTyped *right = node->getRight();
+		const TType &leftType = left->getType();
+		const TType &rightType = right->getType();
+		const TType &resultType = node->getType();
+		
+		switch(node->getOp())
+		{
+		case EOpAssign:
+			if(visit == PostVisit)
+			{
+				assignLvalue(left, right);
+				copy(result, right);
+			}
+			break;
+		case EOpInitialize:
+			if(visit == PostVisit)
+			{
+				copy(left, right);
+			}
+			break;
+		case EOpMatrixTimesScalarAssign:
+			if(visit == PostVisit)
+			{
+				for(int i = 0; i < leftType.getNominalSize(); i++)
+				{
+					Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+					mul->dst.index += i;
+					argument(mul->src[0], left, i);
+				}
+
+				assignLvalue(left, result);
+			}
+			break;
+		case EOpVectorTimesMatrixAssign:
+			if(visit == PostVisit)
+			{
+				int size = leftType.getNominalSize();
+
+				for(int i = 0; i < size; i++)
+				{
+					Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, left, right);
+					dot->dst.mask = 1 << i;
+					argument(dot->src[1], right, i);
+				}
+
+				assignLvalue(left, result);
+			}
+			break;
+		case EOpMatrixTimesMatrixAssign:
+			if(visit == PostVisit)
+			{
+				int dim = leftType.getNominalSize();
+
+				for(int i = 0; i < dim; i++)
+				{
+					Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+					mul->dst.index += i;
+					argument(mul->src[1], right, i);
+					mul->src[1].swizzle = 0x00;
+
+					for(int j = 1; j < dim; j++)
+					{
+						Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);
+						mad->dst.index += i;
+						argument(mad->src[0], left, j);
+						argument(mad->src[1], right, i);
+						mad->src[1].swizzle = j * 0x55;
+						argument(mad->src[2], result, i);
+					}
+				}
+
+				assignLvalue(left, result);
+			}
+			break;
+		case EOpIndexDirect:
+			if(visit == PostVisit)
+			{
+				int index = right->getAsConstantUnion()->getUnionArrayPointer()->getIConst();
+
+				if(result->isMatrix() || result->isStruct())
+ 				{
+					ASSERT(left->isArray());
+					copy(result, left, index * left->elementRegisterCount());
+ 				}
+				else if(result->isRegister())
+ 				{
+					Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);
+
+					if(left->isRegister())
+					{
+						mov->src[0].swizzle = index;
+					}
+					else if(left->isArray())
+					{
+						argument(mov->src[0], left, index * left->elementRegisterCount());
+					}
+					else if(left->isMatrix())
+					{
+						ASSERT(index < left->getNominalSize());   // FIXME: Report semantic error
+						argument(mov->src[0], left, index);
+					}
+					else UNREACHABLE();
+ 				}
+				else UNREACHABLE();
+			}
+			break;
+		case EOpIndexIndirect:
+			if(visit == PostVisit)
+			{
+				if(left->isArray() || left->isMatrix())
+				{
+					for(int index = 0; index < result->totalRegisterCount(); index++)
+					{
+						Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);
+
+						mov->dst.index += index;
+						argument(mov->src[0], left, index);
+
+						if(left->totalRegisterCount() > 1)
+						{
+							sw::Shader::SourceParameter relativeRegister;
+							argument(relativeRegister, right);
+
+							mov->src[0].rel.type = relativeRegister.type;
+							mov->src[0].rel.index = relativeRegister.index;
+							mov->src[0].rel.scale =	result->totalRegisterCount();
+							mov->src[0].rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);
+						}
+					}
+				}
+				else if(left->isRegister())
+				{
+					emit(sw::Shader::OPCODE_EXTRACT, result, left, right);
+				}
+				else UNREACHABLE();
+			}
+			break;
+		case EOpIndexDirectStruct:
+			if(visit == PostVisit)
+			{
+				ASSERT(leftType.isStruct());
+
+				const TTypeList *structure = leftType.getStruct();
+				const TString &fieldName = rightType.getFieldName();
+				int fieldOffset = 0;
+
+				for(size_t i = 0; i < structure->size(); i++)
+				{
+					const TType &fieldType = *(*structure)[i].type;
+
+					if(fieldType.getFieldName() == fieldName)
+					{
+						break;
+					}
+
+					fieldOffset += fieldType.totalRegisterCount();
+				}
+
+				copy(result, left, fieldOffset);
+			}
+			break;
+		case EOpVectorSwizzle:
+			if(visit == PostVisit)
+			{
+				int swizzle = 0;
+				TIntermAggregate *components = right->getAsAggregate();
+
+				if(components)
+				{
+					TIntermSequence &sequence = components->getSequence();
+					int component = 0;
+
+					for(TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++)
+					{
+						TIntermConstantUnion *element = (*sit)->getAsConstantUnion();
+
+						if(element)
+						{
+							int i = element->getUnionArrayPointer()[0].getIConst();
+							swizzle |= i << (component * 2);
+							component++;
+						}
+						else UNREACHABLE();
+					}
+				}
+				else UNREACHABLE();
+
+				Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);
+				mov->src[0].swizzle = swizzle;
+			}
+			break;
+		case EOpAddAssign:               if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_ADD, result, left, left, right); break;
+		case EOpAdd:                     if(visit == PostVisit) emit(sw::Shader::OPCODE_ADD, result, left, right); break;
+		case EOpSubAssign:               if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_SUB, result, left, left, right); break;
+		case EOpSub:                     if(visit == PostVisit) emit(sw::Shader::OPCODE_SUB, result, left, right); break;
+		case EOpMulAssign:               if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_MUL, result, left, left, right); break;
+		case EOpMul:                     if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, left, right); break;
+		case EOpDivAssign:               if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_DIV, result, left, left, right); break;
+		case EOpDiv:                     if(visit == PostVisit) emit(sw::Shader::OPCODE_DIV, result, left, right); break;
+		case EOpEqual:
+			if(visit == PostVisit)
+			{
+				emitCmp(sw::Shader::CONTROL_EQ, result, left, right);
+
+				for(int index = 1; index < left->totalRegisterCount(); index++)
+				{
+					Temporary equal(this);
+					emitCmp(sw::Shader::CONTROL_EQ, &equal, left, right, index);
+					emit(sw::Shader::OPCODE_AND, result, result, &equal);
+				}
+			}
+			break;
+		case EOpNotEqual:
+			if(visit == PostVisit)
+			{
+				emitCmp(sw::Shader::CONTROL_NE, result, left, right);
+
+				for(int index = 1; index < left->totalRegisterCount(); index++)
+				{
+					Temporary notEqual(this);
+					emitCmp(sw::Shader::CONTROL_NE, &notEqual, left, right, index);
+					emit(sw::Shader::OPCODE_OR, result, result, &notEqual);
+				}
+			}
+			break;
+		case EOpLessThan:                if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, left, right); break;
+		case EOpGreaterThan:             if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, left, right); break;
+		case EOpLessThanEqual:           if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, left, right); break;
+		case EOpGreaterThanEqual:        if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, left, right); break;
+		case EOpVectorTimesScalarAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_MUL, result, left, left, right); break;
+		case EOpVectorTimesScalar:       if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, left, right); break;
+		case EOpMatrixTimesScalar:
+			if(visit == PostVisit)
+			{
+				for(int i = 0; i < leftType.getNominalSize(); i++)
+				{
+					Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+					mul->dst.index += i;
+					argument(mul->src[0], left, i);
+				}
+			}
+			break;
+		case EOpVectorTimesMatrix:
+			if(visit == PostVisit)
+			{
+				int size = leftType.getNominalSize();
+
+				for(int i = 0; i < size; i++)
+				{
+					Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, left, right);
+					dot->dst.mask = 1 << i;
+					argument(dot->src[1], right, i);
+				}
+			}
+			break;
+		case EOpMatrixTimesVector:
+			if(visit == PostVisit)
+			{
+				Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+				mul->src[1].swizzle = 0x00;
+
+				for(int i = 1; i < leftType.getNominalSize(); i++)
+				{
+					Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);
+					argument(mad->src[0], left, i);
+					mad->src[1].swizzle = i * 0x55;
+				}
+			}
+			break;
+		case EOpMatrixTimesMatrix:
+			if(visit == PostVisit)
+			{
+				int dim = leftType.getNominalSize();
+
+				for(int i = 0; i < dim; i++)
+				{
+					Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
+					mul->dst.index += i;
+					argument(mul->src[1], right, i);
+					mul->src[1].swizzle = 0x00;
+
+					for(int j = 1; j < dim; j++)
+					{
+						Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);
+						mad->dst.index += i;
+						argument(mad->src[0], left, j);
+						argument(mad->src[1], right, i);
+						mad->src[1].swizzle = j * 0x55;
+						argument(mad->src[2], result, i);
+					}
+				}
+			}
+			break;
+		case EOpLogicalOr:         if(visit == PostVisit) emit(sw::Shader::OPCODE_OR, result, left, right); break;
+		case EOpLogicalXor:        if(visit == PostVisit) emit(sw::Shader::OPCODE_XOR, result, left, right); break;
+		case EOpLogicalAnd:        if(visit == PostVisit) emit(sw::Shader::OPCODE_AND, result, left, right); break;
+		default: UNREACHABLE();
+		}
+
+		return true;
+	}
+
+	bool OutputASM::visitUnary(Visit visit, TIntermUnary *node)
+	{
+		if(currentScope != emitScope)
+		{
+			return false;
+		}
+
+		TIntermTyped *result = node;
+		TIntermTyped *arg = node->getOperand();
+
+		switch(node->getOp())
+		{
+		case EOpNegative:
+			if(visit == PostVisit)
+			{
+				for(int index = 0; index < arg->totalRegisterCount(); index++)
+				{
+					Instruction *neg = emit(sw::Shader::OPCODE_MOV, result, arg);
+					neg->dst.index += index;
+					argument(neg->src[0], arg, index);
+					neg->src[0].modifier = sw::Shader::MODIFIER_NEGATE;
+				}
+			}
+			break;
+		case EOpVectorLogicalNot: if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;
+		case EOpLogicalNot:       if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;
+		case EOpPostIncrement:
+			if(visit == PostVisit)
+			{
+				copy(result, arg);
+
+				for(int index = 0; index < arg->totalRegisterCount(); index++)
+				{
+					Instruction *add = emit(sw::Shader::OPCODE_ADD, arg, arg, &Constant(1.0f, 1.0f, 1.0f, 1.0f));
+					add->dst.index += index;
+					argument(add->src[0], arg, index);
+				}
+
+				assignLvalue(arg, arg);
+			}
+			break;
+		case EOpPostDecrement:
+			if(visit == PostVisit)
+			{
+				copy(result, arg);
+
+				for(int index = 0; index < arg->totalRegisterCount(); index++)
+				{
+					Instruction *sub = emit(sw::Shader::OPCODE_SUB, arg, arg, &Constant(1.0f, 1.0f, 1.0f, 1.0f));
+					sub->dst.index += index;
+					argument(sub->src[0], arg, index);
+				}
+
+				assignLvalue(arg, arg);
+			}
+			break;
+		case EOpPreIncrement:
+			if(visit == PostVisit)
+			{
+				for(int index = 0; index < arg->totalRegisterCount(); index++)
+				{
+					Instruction *add = emit(sw::Shader::OPCODE_ADD, result, arg, &Constant(1.0f, 1.0f, 1.0f, 1.0f));
+					add->dst.index += index;
+					argument(add->src[0], arg, index);
+				}
+
+				assignLvalue(arg, result);
+			}
+			break;
+		case EOpPreDecrement:
+			if(visit == PostVisit)
+			{
+				for(int index = 0; index < arg->totalRegisterCount(); index++)
+				{
+					Instruction *sub = emit(sw::Shader::OPCODE_SUB, result, arg, &Constant(1.0f, 1.0f, 1.0f, 1.0f));
+					sub->dst.index += index;
+					argument(sub->src[0], arg, index);
+				}
+
+				assignLvalue(arg, result);
+			}
+			break;
+		case EOpConvIntToBool:    if(visit == PostVisit) emit(sw::Shader::OPCODE_F2B, result, arg); break;     // Integers are implemented as float
+		case EOpConvFloatToBool:  if(visit == PostVisit) emit(sw::Shader::OPCODE_F2B, result, arg); break;
+		case EOpConvBoolToFloat:  if(visit == PostVisit) emit(sw::Shader::OPCODE_B2F, result, arg); break;
+		case EOpConvIntToFloat:   if(visit == PostVisit) emit(sw::Shader::OPCODE_MOV, result, arg); break;     // Integers are implemented as float
+		case EOpConvFloatToInt:   if(visit == PostVisit) emit(sw::Shader::OPCODE_TRUNC, result, arg); break;   // Integers are implemented as float
+		case EOpConvBoolToInt:    if(visit == PostVisit) emit(sw::Shader::OPCODE_B2F, result, arg); break;     // Integers are implemented as float
+		case EOpRadians:          if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, &Constant(1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f)); break;
+		case EOpDegrees:          if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, &Constant(5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f)); break;
+		case EOpSin:              if(visit == PostVisit) emit(sw::Shader::OPCODE_SIN, result, arg); break;
+		case EOpCos:              if(visit == PostVisit) emit(sw::Shader::OPCODE_COS, result, arg); break;
+		case EOpTan:              if(visit == PostVisit) emit(sw::Shader::OPCODE_TAN, result, arg); break;
+		case EOpAsin:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ASIN, result, arg); break;
+		case EOpAcos:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOS, result, arg); break;
+		case EOpAtan:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN, result, arg); break;
+		case EOpExp:              if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP, result, arg); break;
+		case EOpLog:              if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG, result, arg); break;
+		case EOpExp2:             if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP2, result, arg); break;
+		case EOpLog2:             if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG2, result, arg); break;
+		case EOpSqrt:             if(visit == PostVisit) emit(sw::Shader::OPCODE_SQRT, result, arg); break;
+		case EOpInverseSqrt:      if(visit == PostVisit) emit(sw::Shader::OPCODE_RSQ, result, arg); break;
+		case EOpAbs:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ABS, result, arg); break;
+		case EOpSign:             if(visit == PostVisit) emit(sw::Shader::OPCODE_SGN, result, arg); break;
+		case EOpFloor:            if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOOR, result, arg); break;
+		case EOpCeil:             if(visit == PostVisit) emit(sw::Shader::OPCODE_CEIL, result, arg, result);	break;
+		case EOpFract:            if(visit == PostVisit) emit(sw::Shader::OPCODE_FRC, result, arg); break;
+		case EOpLength:           if(visit == PostVisit) emit(sw::Shader::OPCODE_LEN(dim(arg)), result, arg); break;
+		case EOpNormalize:        if(visit == PostVisit) emit(sw::Shader::OPCODE_NRM(dim(arg)), result, arg); break;
+		case EOpDFdx:             if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDX, result, arg); break;
+		case EOpDFdy:             if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDY, result, arg); break;
+		case EOpFwidth:           if(visit == PostVisit) emit(sw::Shader::OPCODE_FWIDTH, result, arg); break;
+		case EOpAny:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ANY, result, arg); break;
+		case EOpAll:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ALL, result, arg); break;
+		default: UNREACHABLE();
+		}
+
+		return true;
+	}
+
+	bool OutputASM::visitAggregate(Visit visit, TIntermAggregate *node)
+	{
+		if(currentScope != emitScope && node->getOp() != EOpFunction && node->getOp() != EOpSequence)
+		{
+			return false;
+		}
+
+		TIntermTyped *result = node;
+		const TType &resultType = node->getType();
+		TIntermSequence &arg = node->getSequence();
+		int argumentCount = arg.size();
+
+		switch(node->getOp())
+		{
+		case EOpSequence:           break;
+		case EOpDeclaration:		break;
+		case EOpPrototype:          break;
+		case EOpComma:
+			if(visit == PostVisit)
+			{
+				copy(result, arg[1]);
+			}
+			break;
+		case EOpFunction:
+			if(visit == PreVisit)
+			{
+				const TString &name = node->getName();
+
+				if(emitScope == FUNCTION)
+				{
+					if(functionArray.size() > 1)   // No need for a label when there's only main()
+					{
+						Instruction *label = emit(sw::Shader::OPCODE_LABEL);
+						label->dst.type = sw::Shader::PARAMETER_LABEL;
+
+						const Function &function = findFunction(name);
+						label->dst.index = function.label;
+						currentFunction = function.label;
+					}
+				}
+				else if(emitScope == GLOBAL)
+				{
+					if(name != "main(")
+					{
+						TIntermSequence &arguments = node->getSequence()[0]->getAsAggregate()->getSequence();
+						functionArray.push_back(Function(functionArray.size(), name, &arguments, node));
+					}
+				}
+				else UNREACHABLE();
+
+				currentScope = FUNCTION;
+			}
+			else if(visit == PostVisit)
+			{
+				if(emitScope == FUNCTION)
+				{
+					if(functionArray.size() > 1)   // No need to return when there's only main()
+					{
+						emit(sw::Shader::OPCODE_RET);
+					}
+				}
+
+				currentScope = GLOBAL;
+			}
+			break;
+		case EOpFunctionCall:
+			if(visit == PostVisit)
+			{
+                if(node->isUserDefined())
+                {
+					const TString &name = node->getName();
+					const Function &function = findFunction(name);
+					TIntermSequence &arguments = *function.arg;
+
+					for(int i = 0; i < argumentCount; i++)
+					{
+						TIntermTyped *in = arguments[i]->getAsTyped();
+								
+						if(in->getQualifier() == EvqIn ||
+						   in->getQualifier() == EvqInOut ||
+						   in->getQualifier() == EvqConstReadOnly)
+						{
+							copy(in, arg[i]);
+						}
+					}
+
+					Instruction *call = emit(sw::Shader::OPCODE_CALL);
+					call->dst.type = sw::Shader::PARAMETER_LABEL;
+					call->dst.index = function.label;
+
+					if(function.ret && function.ret->getType().getBasicType() != EbtVoid)
+					{
+						copy(result, function.ret);
+					}
+
+					for(int i = 0; i < argumentCount; i++)
+					{
+						TIntermTyped *argument = arguments[i]->getAsTyped();
+						TIntermTyped *out = arg[i]->getAsTyped();
+								
+						if(argument->getQualifier() == EvqOut ||
+						   argument->getQualifier() == EvqInOut)
+						{
+							copy(out, argument);
+						}
+					}
+				}
+				else
+				{
+					TString name = TFunction::unmangleName(node->getName());
+
+					if(name == "texture2D" || name == "textureCube")
+					{
+						if(argumentCount == 2)
+						{	
+							emit(sw::Shader::OPCODE_TEX, result, arg[1], arg[0]);
+						}
+						else if(argumentCount == 3)   // bias
+						{
+							Temporary uvwb(this);
+							emit(sw::Shader::OPCODE_MOV, &uvwb, arg[1]);
+							Instruction *bias = emit(sw::Shader::OPCODE_MOV, &uvwb, arg[2]);
+							bias->dst.mask = 0x8;
+
+							Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, &uvwb, arg[0]);   // FIXME: Implement an efficient TEXLDB instruction
+							tex->bias = true;
+						}
+						else UNREACHABLE();
+					}
+					else if(name == "texture2DProj")
+                    {
+						TIntermTyped *t = arg[1]->getAsTyped();
+
+                        if(argumentCount == 2)
+						{
+							Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, arg[1], arg[0]);
+							tex->project = true;
+
+							if(t->getNominalSize() == 3)
+							{
+								tex->src[0].swizzle = 0xA4;
+							}
+							else ASSERT(t->getNominalSize() == 4);
+						}
+						else if(argumentCount == 3)   // bias
+						{
+							Temporary proj(this);
+							emit(sw::Shader::OPCODE_MOV, &proj, arg[1]);
+
+							if(t->getNominalSize() == 3)
+							{
+								Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, &proj);
+								div->src[0].swizzle = 0xAA;
+								div->dst.mask = 0x3;
+							}
+							else if(t->getNominalSize() == 4)
+							{
+								Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, &proj);
+								div->src[0].swizzle = 0xFF;
+								div->dst.mask = 0x3;
+							}
+							else UNREACHABLE();
+
+							Instruction *bias = emit(sw::Shader::OPCODE_MOV, &proj, arg[2]);
+							bias->dst.mask = 0x8;
+
+							Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, &proj, arg[0]);
+							tex->bias = true;
+						}
+						else UNREACHABLE();
+                    }
+                    else if(name == "texture2DLod" || name == "textureCubeLod")
+                    {
+						Temporary uvwb(this);
+						emit(sw::Shader::OPCODE_MOV, &uvwb, arg[1]);
+						Instruction *lod = emit(sw::Shader::OPCODE_MOV, &uvwb, arg[2]);
+						lod->dst.mask = 0x8;
+
+						emit(sw::Shader::OPCODE_TEXLDL, result, &uvwb, arg[0]);
+                    }
+                    else if(name == "texture2DProjLod")
+                    {
+                        TIntermTyped *t = arg[1]->getAsTyped();
+
+						Temporary proj(this);
+						emit(sw::Shader::OPCODE_MOV, &proj, arg[1]);
+
+						if(t->getNominalSize() == 3)
+						{
+							Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, &proj);
+							div->src[0].swizzle = 0xAA;
+							div->dst.mask = 0x3;
+						}
+						else if(t->getNominalSize() == 4)
+						{
+							Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, &proj);
+							div->src[0].swizzle = 0xFF;
+							div->dst.mask = 0x3;
+						}
+						else UNREACHABLE();
+
+						Instruction *lod = emit(sw::Shader::OPCODE_MOV, &proj, arg[2]);
+						lod->dst.mask = 0x8;
+
+						emit(sw::Shader::OPCODE_TEXLDL, result, &proj, arg[0]);
+                    }
+					else UNREACHABLE();
+				}
+			}
+			break;
+		case EOpParameters: break;
+		case EOpConstructFloat:
+		case EOpConstructVec2:
+		case EOpConstructVec3:
+		case EOpConstructVec4:
+		case EOpConstructBool:
+		case EOpConstructBVec2:
+		case EOpConstructBVec3:
+		case EOpConstructBVec4:
+		case EOpConstructInt:
+		case EOpConstructIVec2:
+		case EOpConstructIVec3:
+		case EOpConstructIVec4:
+			if(visit == PostVisit)
+			{
+				int component = 0;
+
+				for(int i = 0; i < argumentCount; i++)
+                {
+                    TIntermTyped *argi = arg[i]->getAsTyped();
+					int size = argi->getNominalSize();
+					ASSERT(!argi->isMatrix());
+
+					Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, argi);
+					mov->dst.mask = (0xF << component) & 0xF;
+					mov->src[0].swizzle = swizzleSize[size] << (component * 2);
+
+					component += size;
+				}
+			}
+			break;
+		case EOpConstructMat2:
+		case EOpConstructMat3:
+		case EOpConstructMat4:
+			if(visit == PostVisit)
+			{
+				TIntermTyped *arg0 = arg[0]->getAsTyped();
+				const int dim = result->getNominalSize();
+
+				if(arg0->isMatrix())
+				{
+					for(int i = 0; i < dim; i++)
+					{
+						if(dim > dim2(arg0))
+						{
+							// Initialize to identity matrix
+							Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, &Constant((i == 0 ? 1.0f : 0.0f), (i == 1 ? 1.0f : 0.0f), (i == 2 ? 1.0f : 0.0f), (i == 3 ? 1.0f : 0.0f)));
+							mov->dst.index += i;
+						}
+
+						if(i < dim2(arg0))
+						{
+							Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, arg0);
+							mov->dst.index += i;
+							mov->dst.mask = 0xF >> (4 - dim2(arg0));
+							argument(mov->src[0], arg0, i);
+						}
+					}
+				}
+				else
+				{
+					int column = 0;
+					int row = 0;
+
+					for(int i = 0; i < argumentCount; i++)
+					{
+						TIntermTyped *argi = arg[i]->getAsTyped();
+						int size = argi->getNominalSize();
+						int element = 0;
+
+						while(element < size)
+						{
+							Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, argi);
+							mov->dst.index += column;
+							mov->dst.mask = (0xF << row) & 0xF;
+							mov->src[0].swizzle = (swizzleSize[size] << (row * 2)) + 0x55 * element;
+					
+							int end = row + size - element;
+							column = end >= dim ? column + 1 : column;
+							element = element + dim - row;
+							row = end >= dim ? 0 : end;
+						}
+					}
+				}
+			}
+			break;
+		case EOpConstructStruct:
+			if(visit == PostVisit)
+			{
+				int offset = 0;
+				for(int i = 0; i < argumentCount; i++)
+				{
+					TIntermTyped *argi = arg[i]->getAsTyped();
+					int size = argi->totalRegisterCount();
+
+					for(int index = 0; index < size; index++)
+					{
+						Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, argi);
+						mov->dst.index += index + offset;
+						mov->dst.mask = writeMask(result, offset + index);
+						argument(mov->src[0], argi, index);
+					}
+
+					offset += size;
+				}
+			}
+			break;
+		case EOpLessThan:         if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, arg[0], arg[1]); break;
+		case EOpGreaterThan:      if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, arg[0], arg[1]); break;
+		case EOpLessThanEqual:    if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, arg[0], arg[1]); break;
+		case EOpGreaterThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, arg[0], arg[1]); break;
+		case EOpVectorEqual:      if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_EQ, result, arg[0], arg[1]); break;
+		case EOpVectorNotEqual:   if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_NE, result, arg[0], arg[1]); break;
+		case EOpMod:              if(visit == PostVisit) emit(sw::Shader::OPCODE_MOD, result, arg[0], arg[1]); break;
+		case EOpPow:              if(visit == PostVisit) emit(sw::Shader::OPCODE_POW, result, arg[0], arg[1]); break;
+		case EOpAtan:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN2, result, arg[0], arg[1]); break;
+		case EOpMin:              if(visit == PostVisit) emit(sw::Shader::OPCODE_MIN, result, arg[0], arg[1]); break;
+		case EOpMax:              if(visit == PostVisit) emit(sw::Shader::OPCODE_MAX, result, arg[0], arg[1]); break;
+		case EOpClamp:
+			if(visit == PostVisit)
+			{
+				emit(sw::Shader::OPCODE_MAX, result, arg[0], arg[1]);
+				emit(sw::Shader::OPCODE_MIN, result, result, arg[2]);
+			}
+			break;
+		case EOpMix:         if(visit == PostVisit) emit(sw::Shader::OPCODE_LRP, result, arg[2], arg[1], arg[0]); break;
+		case EOpStep:        if(visit == PostVisit) emit(sw::Shader::OPCODE_STEP, result, arg[0], arg[1]); break;
+		case EOpSmoothStep:  if(visit == PostVisit) emit(sw::Shader::OPCODE_SMOOTH, result, arg[0], arg[1], arg[2]); break;
+		case EOpDistance:    if(visit == PostVisit) emit(sw::Shader::OPCODE_DIST(dim(arg[0])), result, arg[0], arg[1]); break;
+		case EOpDot:         if(visit == PostVisit) emit(sw::Shader::OPCODE_DP(dim(arg[0])), result, arg[0], arg[1]); break;
+		case EOpCross:       if(visit == PostVisit) emit(sw::Shader::OPCODE_CRS, result, arg[0], arg[1]); break;
+		case EOpFaceForward: if(visit == PostVisit) emit(sw::Shader::OPCODE_FORWARD(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;
+		case EOpReflect:     if(visit == PostVisit) emit(sw::Shader::OPCODE_REFLECT(dim(arg[0])), result, arg[0], arg[1]); break;
+		case EOpRefract:     if(visit == PostVisit) emit(sw::Shader::OPCODE_REFRACT(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;
+		case EOpMul:
+			if(visit == PostVisit)
+			{
+				ASSERT(dim2(arg[0]) == dim2(arg[1]));
+
+				for(int i = 0; i < dim2(arg[0]); i++)
+                {
+					Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, arg[0], arg[1]);
+					mul->dst.index += i;
+					argument(mul->src[0], arg[0], i);
+					argument(mul->src[1], arg[1], i);
+				}
+			}
+			break;
+		default: UNREACHABLE();
+		}
+
+		return true;
+	}
+
+	bool OutputASM::visitSelection(Visit visit, TIntermSelection *node)
+	{
+		if(currentScope != emitScope)
+		{
+			return false;
+		}
+
+		TIntermTyped *condition = node->getCondition();
+		TIntermNode *trueBlock = node->getTrueBlock();
+		TIntermNode *falseBlock = node->getFalseBlock();
+		TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();
+
+		condition->traverse(this);
+
+		if(node->usesTernaryOperator())
+		{
+			if(constantCondition)
+			{
+				bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();
+
+				if(trueCondition)
+				{
+					trueBlock->traverse(this);
+					copy(node, trueBlock);
+				}
+				else
+				{
+					falseBlock->traverse(this);
+					copy(node, falseBlock);
+				}
+			}
+			else if(trivial(node, 6))   // Fast to compute both potential results and no side effects
+			{
+				trueBlock->traverse(this);
+				falseBlock->traverse(this);
+				emit(sw::Shader::OPCODE_SELECT, node, condition, trueBlock, falseBlock);
+			}
+			else
+			{
+				emit(sw::Shader::OPCODE_IF, 0, condition);
+
+				if(trueBlock)
+				{
+					trueBlock->traverse(this);
+					copy(node, trueBlock);
+				}
+
+				if(falseBlock)
+				{
+					emit(sw::Shader::OPCODE_ELSE);
+					falseBlock->traverse(this);
+					copy(node, falseBlock);
+				}
+
+				emit(sw::Shader::OPCODE_ENDIF);
+			}
+		}
+		else  // if/else statement
+		{
+			if(constantCondition)
+			{
+				bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();
+
+				if(trueCondition)
+				{
+					if(trueBlock)
+					{
+						trueBlock->traverse(this);
+					}
+				}
+				else
+				{
+					if(falseBlock)
+					{
+						falseBlock->traverse(this);
+					}
+				}
+			}
+			else
+			{
+				emit(sw::Shader::OPCODE_IF, 0, condition);
+
+				if(trueBlock)
+				{
+					trueBlock->traverse(this);
+				}
+
+				if(falseBlock)
+				{
+					emit(sw::Shader::OPCODE_ELSE);
+					falseBlock->traverse(this);
+				}
+
+				emit(sw::Shader::OPCODE_ENDIF);
+			}
+		}
+
+		return false;
+	}
+
+	bool OutputASM::visitLoop(Visit visit, TIntermLoop *node)
+	{
+		if(currentScope != emitScope)
+		{
+			return false;
+		}
+
+		TIntermNode *init = node->getInit();
+		TIntermTyped *condition = node->getCondition();
+		TIntermTyped *expression = node->getExpression();
+		TIntermNode *body = node->getBody();
+
+		if(node->getType() == ELoopDoWhile)
+		{
+			Temporary iterate(this);
+			emit(sw::Shader::OPCODE_MOV, &iterate, &Constant(true));
+
+			emit(sw::Shader::OPCODE_WHILE, 0, &iterate);   // FIXME: Implement real do-while
+
+			if(body)
+			{
+				body->traverse(this);
+			}
+
+			emit(sw::Shader::OPCODE_TEST);
+
+			condition->traverse(this);
+			emit(sw::Shader::OPCODE_MOV, &iterate, condition);
+
+			emit(sw::Shader::OPCODE_ENDWHILE);
+		}
+		else
+		{
+			if(init)
+			{
+				init->traverse(this);
+			}
+
+			condition->traverse(this);
+
+			emit(sw::Shader::OPCODE_WHILE, 0, condition);
+
+			if(body)
+			{
+				body->traverse(this);
+			}
+
+			emit(sw::Shader::OPCODE_TEST);
+
+			if(expression)
+			{
+				expression->traverse(this);
+			}
+
+			condition->traverse(this);
+
+			emit(sw::Shader::OPCODE_ENDWHILE);
+		}
+
+		return false;
+	}
+
+	bool OutputASM::visitBranch(Visit visit, TIntermBranch *node)
+	{
+		if(currentScope != emitScope)
+		{
+			return false;
+		}
+
+		switch(node->getFlowOp())
+		{
+		case EOpKill:      if(visit == PostVisit) emit(sw::Shader::OPCODE_DISCARD); break;
+		case EOpBreak:     if(visit == PostVisit) emit(sw::Shader::OPCODE_BREAK); break;
+		case EOpContinue:  if(visit == PostVisit) emit(sw::Shader::OPCODE_CONTINUE); break;
+		case EOpReturn:
+			if(visit == PostVisit)
+			{
+				TIntermTyped *value = node->getExpression();
+
+				if(value)
+				{
+					copy(functionArray[currentFunction].ret, value);
+				}
+
+				emit(sw::Shader::OPCODE_LEAVE);
+			}
+			break;
+		default: UNREACHABLE();
+		}
+
+		return true;
+	}
+
+	Instruction *OutputASM::emit(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2)
+	{
+		if(dst && registerType(dst) == sw::Shader::PARAMETER_SAMPLER)
+		{
+			op = sw::Shader::OPCODE_NOP;   // Can't assign to a sampler, but this will be hit when indexing sampler arrays
+		}
+
+		Instruction *instruction = new Instruction(op);
+
+		if(dst)
+		{
+			instruction->dst.type = registerType(dst);
+			instruction->dst.index = registerIndex(dst);
+			instruction->dst.mask = writeMask(dst);
+			instruction->dst.integer = (dst->getBasicType() == EbtInt);
+		}
+
+		argument(instruction->src[0], src0);
+		argument(instruction->src[1], src1);
+		argument(instruction->src[2], src2);
+
+		shader->append(instruction);
+
+		return instruction;
+	}
+
+	void OutputASM::emitAssign(sw::Shader::Opcode op, TIntermTyped *result, TIntermTyped *lhs, TIntermTyped *src0, TIntermTyped *src1)
+	{
+		emit(op, result, src0, src1);
+		assignLvalue(lhs, result);
+	}
+
+	void OutputASM::emitCmp(sw::Shader::Control cmpOp, TIntermTyped *dst, TIntermNode *left, TIntermNode *right, int index)
+	{
+		bool boolean = (left->getAsTyped()->getBasicType() == EbtBool);
+		sw::Shader::Opcode opcode = boolean ? sw::Shader::OPCODE_ICMP : sw::Shader::OPCODE_CMP;
+
+		Instruction *cmp = emit(opcode, dst, left, right);
+		cmp->control = cmpOp;
+		argument(cmp->src[0], left, index);
+		argument(cmp->src[1], right, index);
+	}
+
+	int componentCount(const TType &type, int registers)
+	{
+		if(registers == 0)
+		{
+			return 0;
+		}
+
+		if(type.isArray() && registers >= type.elementRegisterCount())
+		{
+			int index = registers / type.elementRegisterCount();
+			registers -= index * type.elementRegisterCount();
+			return index * type.getElementSize() + componentCount(type, registers);
+		}
+
+		if(type.isStruct())
+		{
+			TTypeList *structure = type.getStruct();
+			int elements = 0;
+
+			for(TTypeList::const_iterator field = structure->begin(); field != structure->end(); field++)
+			{
+				const TType &fieldType = *field->type;
+
+				if(fieldType.totalRegisterCount() <= registers)
+				{
+					registers -= fieldType.totalRegisterCount();
+					elements += fieldType.getObjectSize();
+				}
+				else   // Register within this field
+				{
+					return elements + componentCount(fieldType, registers);
+				}
+			}
+		}
+		else if(type.isMatrix())
+		{
+			return registers * type.getNominalSize();
+		}
+		
+		UNREACHABLE();
+		return 0;
+	}
+
+	int registerSize(const TType &type, int registers)
+	{
+		if(registers == 0)
+		{
+			if(type.isStruct())
+			{
+				return registerSize(*type.getStruct()->begin()->type, 0);
+			}
+
+			return type.getNominalSize();
+		}
+
+		if(type.isArray() && registers >= type.elementRegisterCount())
+		{
+			int index = registers / type.elementRegisterCount();
+			registers -= index * type.elementRegisterCount();
+			return registerSize(type, registers);
+		}
+
+		if(type.isStruct())
+		{
+			TTypeList *structure = type.getStruct();
+			int elements = 0;
+
+			for(TTypeList::const_iterator field = structure->begin(); field != structure->end(); field++)
+			{
+				const TType &fieldType = *field->type;
+				
+				if(fieldType.totalRegisterCount() <= registers)
+				{
+					registers -= fieldType.totalRegisterCount();
+					elements += fieldType.getObjectSize();
+				}
+				else   // Register within this field
+				{
+					return registerSize(fieldType, registers);
+				}
+			}
+		}
+		else if(type.isMatrix())
+		{
+			return registerSize(type, 0);
+		}
+		
+		UNREACHABLE();
+		return 0;
+	}
+
+	void OutputASM::argument(sw::Shader::SourceParameter &parameter, TIntermNode *argument, int index)
+	{
+		if(argument)
+		{
+			TIntermTyped *arg = argument->getAsTyped();
+			const TType &type = arg->getType();
+			const TTypeList *structure = type.getStruct();
+			ASSERT(index < arg->totalRegisterCount());
+
+			int size = registerSize(type, index);
+
+			parameter.type = registerType(arg);
+
+			if(arg->getQualifier() == EvqConst)
+			{
+				int component = componentCount(type, index);
+				ConstantUnion *constants = arg->getAsConstantUnion()->getUnionArrayPointer();
+
+				for(int i = 0; i < 4; i++)
+				{
+					if(size == 1)   // Replicate
+					{
+						parameter.value[i] = constants[component + 0].getAsFloat();
+					}
+					else if(i < size)
+					{
+						parameter.value[i] = constants[component + i].getAsFloat();
+					}
+					else
+					{
+						parameter.value[i] = 0.0f;
+					}
+				}
+			}
+			else
+			{
+				parameter.index = registerIndex(arg) + index;
+
+				if(registerType(arg) == sw::Shader::PARAMETER_SAMPLER)
+				{
+					TIntermBinary *binary = argument->getAsBinaryNode();
+
+					if(binary)
+					{
+						TIntermTyped *left = binary->getLeft();
+						TIntermTyped *right = binary->getRight();
+
+						if(binary->getOp() == EOpIndexDirect)
+						{
+							parameter.index += right->getAsConstantUnion()->getUnionArrayPointer()->getIConst();
+						}
+						else if(binary->getOp() == EOpIndexIndirect)
+						{
+							if(left->getArraySize() > 1)
+							{
+								parameter.rel.type = registerType(binary->getRight());
+								parameter.rel.index = registerIndex(binary->getRight());
+								parameter.rel.scale = 1;
+								parameter.rel.deterministic = true;
+							}
+						}
+						else UNREACHABLE();
+					}
+				}
+			}
+
+			if(!IsSampler(arg->getBasicType()))
+			{
+				parameter.swizzle = swizzleSize[size];
+			}
+		}
+	}
+
+	void OutputASM::copy(TIntermTyped *dst, TIntermNode *src, int offset)
+	{
+		for(int index = 0; index < dst->totalRegisterCount(); index++)
+		{
+			Instruction *mov = emit(sw::Shader::OPCODE_MOV, dst, src);
+			mov->dst.index += index;
+			mov->dst.mask = writeMask(dst, index);
+			argument(mov->src[0], src, offset + index);
+		}
+	}
+
+	int swizzleElement(int swizzle, int index)
+	{
+		return (swizzle >> (index * 2)) & 0x03;
+	}
+
+	int swizzleSwizzle(int leftSwizzle, int rightSwizzle)
+	{
+		return (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 0)) << 0) |
+		       (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 1)) << 2) |
+		       (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 2)) << 4) |
+		       (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 3)) << 6);
+	}
+
+	void OutputASM::assignLvalue(TIntermTyped *dst, TIntermNode *src)
+	{
+		TIntermBinary *binary = dst->getAsBinaryNode();
+
+		if(binary && binary->getOp() == EOpIndexIndirect && dst->isScalar())
+		{
+			Instruction *insert = new Instruction(sw::Shader::OPCODE_INSERT);
+			
+			Temporary address(this);
+			lvalue(insert->dst, address, dst);
+
+			insert->src[0].type = insert->dst.type;
+			insert->src[0].index = insert->dst.index;
+			insert->src[0].rel = insert->dst.rel;
+			argument(insert->src[1], src);
+			argument(insert->src[2], binary->getRight());
+
+			shader->append(insert);
+		}
+		else
+		{
+			for(int offset = 0; offset < dst->totalRegisterCount(); offset++)
+			{
+				Instruction *mov = new Instruction(sw::Shader::OPCODE_MOV);
+			
+				Temporary address(this);
+				int swizzle = lvalue(mov->dst, address, dst);
+				mov->dst.index += offset;
+
+				if(offset > 0)
+				{
+					mov->dst.mask = writeMask(dst, offset);
+				}
+
+				argument(mov->src[0], src, offset);
+				mov->src[0].swizzle = swizzleSwizzle(mov->src[0].swizzle, swizzle);
+
+				shader->append(mov);
+			}
+		}
+	}
+
+	int OutputASM::lvalue(sw::Shader::DestinationParameter &dst, Temporary &address, TIntermTyped *node)
+	{
+		TIntermTyped *result = node;
+		TIntermBinary *binary = node->getAsBinaryNode();
+		TIntermSymbol *symbol = node->getAsSymbolNode();
+
+		if(binary)
+		{
+			TIntermTyped *left = binary->getLeft();
+			TIntermTyped *right = binary->getRight();
+
+			int leftSwizzle = lvalue(dst, address, left);   // Resolve the l-value of the left side
+
+			switch(binary->getOp())
+			{
+			case EOpIndexDirect:
+				{
+					int rightIndex = right->getAsConstantUnion()->getUnionArrayPointer()->getIConst();
+
+					if(left->isRegister())
+					{
+						int leftMask = dst.mask;
+						
+						dst.mask = 1;
+						while((leftMask & dst.mask) == 0)
+						{
+							dst.mask = dst.mask << 1;
+						}
+
+						int element = swizzleElement(leftSwizzle, rightIndex);
+						dst.mask = 1 << element;
+						
+						return element;
+					}
+					else if(left->isArray() || left->isMatrix())
+					{
+						dst.index += rightIndex * result->totalRegisterCount();
+						return 0xE4;
+					}
+					else UNREACHABLE();
+				}
+				break;
+			case EOpIndexIndirect:
+				{
+					if(left->isRegister())
+					{
+						// Requires INSERT instruction (handled by calling function)
+					}
+					else if(left->isArray() || left->isMatrix())
+					{
+						int scale = result->totalRegisterCount();
+
+						if(dst.rel.type == sw::Shader::PARAMETER_VOID)   // Use the index register as the relative address directly
+						{
+							if(left->totalRegisterCount() > 1)
+							{
+								sw::Shader::SourceParameter relativeRegister;
+								argument(relativeRegister, right);
+
+								dst.rel.index = relativeRegister.index;
+								dst.rel.type = relativeRegister.type;
+								dst.rel.scale = scale;
+								dst.rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);
+							}
+						}
+						else if(dst.rel.index != registerIndex(&address))   // Move the previous index register to the address register
+						{
+							if(scale == 1)
+							{
+								Instruction *mad = emit(sw::Shader::OPCODE_MAD, &address, &address, &Constant((int)dst.rel.scale), right);
+								mad->src[0].index = dst.rel.index;
+								mad->src[0].type = dst.rel.type;
+							}
+							else
+							{
+								Instruction *mul = emit(sw::Shader::OPCODE_MUL, &address, &address, &Constant((int)dst.rel.scale));
+								mul->src[0].index = dst.rel.index;
+								mul->src[0].type = dst.rel.type;
+
+								emit(sw::Shader::OPCODE_MAD, &address, right, &Constant(scale), &address);
+							}
+
+							dst.rel.type = sw::Shader::PARAMETER_TEMP;
+							dst.rel.index = registerIndex(&address);
+							dst.rel.scale = 1;
+						}
+						else   // Just add the new index to the address register
+						{
+							if(scale == 1)
+							{
+								emit(sw::Shader::OPCODE_ADD, &address, &address, right);
+							}
+							else
+							{
+								emit(sw::Shader::OPCODE_MAD, &address, right, &Constant(scale), &address);
+							}
+						}
+					}
+					else UNREACHABLE();
+				}
+				break;
+			case EOpIndexDirectStruct:
+				{
+					const TTypeList *structure = left->getType().getStruct();
+					const TString &fieldName = right->getType().getFieldName();
+
+					int offset = 0;
+					for(TTypeList::const_iterator field = structure->begin(); field != structure->end(); field++)
+					{
+						if(field->type->getFieldName() == fieldName)
+						{
+							dst.type = registerType(left);
+							dst.index += offset;
+							dst.mask = writeMask(right);
+							
+							return 0xE4;
+						}
+
+						offset += field->type->totalRegisterCount();
+					}
+				}
+				break;
+			case EOpVectorSwizzle:
+				{
+					ASSERT(left->isRegister());
+
+					int leftMask = dst.mask;
+
+					int swizzle = 0;
+					int rightMask = 0;
+
+					TIntermSequence &sequence = right->getAsAggregate()->getSequence();
+
+					for(unsigned int i = 0; i < sequence.size(); i++)
+					{
+						int index = sequence[i]->getAsConstantUnion()->getUnionArrayPointer()->getIConst();
+
+						int element = swizzleElement(leftSwizzle, index);
+						rightMask = rightMask | (1 << element);
+						swizzle = swizzle | swizzleElement(leftSwizzle, i) << (element * 2);
+					}
+					
+					dst.mask = leftMask & rightMask;
+
+					return swizzle;
+				}
+				break;
+			default:
+				UNREACHABLE();   // Not an l-value operator
+				break;
+			}
+		}
+		else if(symbol)
+		{
+			dst.type = registerType(symbol);
+			dst.index = registerIndex(symbol);
+			dst.mask = writeMask(symbol);
+			return 0xE4;
+		}
+
+		return 0xE4;
+	}
+
+	sw::Shader::ParameterType OutputASM::registerType(TIntermTyped *operand)
+	{
+		if(IsSampler(operand->getBasicType()) && (operand->getQualifier() == EvqUniform || operand->getQualifier() == EvqTemporary))   // Function parameters are temporaries
+		{
+			return sw::Shader::PARAMETER_SAMPLER;
+		}
+
+		switch(operand->getQualifier())
+		{
+		case EvqTemporary:           return sw::Shader::PARAMETER_TEMP;
+		case EvqGlobal:              return sw::Shader::PARAMETER_TEMP;
+		case EvqConst:               return sw::Shader::PARAMETER_FLOAT4LITERAL;   // All converted to float
+		case EvqAttribute:           return sw::Shader::PARAMETER_INPUT;
+		case EvqVaryingIn:           return sw::Shader::PARAMETER_INPUT;
+		case EvqVaryingOut:          return sw::Shader::PARAMETER_OUTPUT;
+		case EvqInvariantVaryingIn:  return sw::Shader::PARAMETER_INPUT;    // FIXME: Guarantee invariance at the backend
+		case EvqInvariantVaryingOut: return sw::Shader::PARAMETER_OUTPUT;   // FIXME: Guarantee invariance at the backend 
+		case EvqUniform:             return sw::Shader::PARAMETER_CONST;
+		case EvqIn:                  return sw::Shader::PARAMETER_TEMP;
+		case EvqOut:                 return sw::Shader::PARAMETER_TEMP;
+		case EvqInOut:               return sw::Shader::PARAMETER_TEMP;
+		case EvqConstReadOnly:       return sw::Shader::PARAMETER_TEMP;
+		case EvqPosition:            return sw::Shader::PARAMETER_OUTPUT;
+		case EvqPointSize:           return sw::Shader::PARAMETER_OUTPUT;
+		case EvqFragCoord:           return sw::Shader::PARAMETER_MISCTYPE;
+		case EvqFrontFacing:         return sw::Shader::PARAMETER_MISCTYPE;
+		case EvqPointCoord:          return sw::Shader::PARAMETER_INPUT;
+		case EvqFragColor:           return sw::Shader::PARAMETER_COLOROUT;
+		case EvqFragData:            return sw::Shader::PARAMETER_COLOROUT;
+		default: UNREACHABLE();
+		}
+
+		return sw::Shader::PARAMETER_VOID;
+	}
+
+	int OutputASM::registerIndex(TIntermTyped *operand)
+	{
+		if(registerType(operand) == sw::Shader::PARAMETER_SAMPLER)
+		{
+			return samplerRegister(operand);
+		}
+
+		switch(operand->getQualifier())
+		{
+		case EvqTemporary:           return temporaryRegister(operand);
+		case EvqGlobal:              return temporaryRegister(operand);
+		case EvqConst:               UNREACHABLE();
+		case EvqAttribute:           return attributeRegister(operand);
+		case EvqVaryingIn:           return varyingRegister(operand);
+		case EvqVaryingOut:          return varyingRegister(operand);
+		case EvqInvariantVaryingIn:  return varyingRegister(operand);
+		case EvqInvariantVaryingOut: return varyingRegister(operand);
+		case EvqUniform:             return uniformRegister(operand);
+		case EvqIn:                  return temporaryRegister(operand);
+		case EvqOut:                 return temporaryRegister(operand);
+		case EvqInOut:               return temporaryRegister(operand);
+		case EvqConstReadOnly:       return temporaryRegister(operand);
+		case EvqPosition:            return varyingRegister(operand);
+		case EvqPointSize:           return varyingRegister(operand);
+		case EvqFragCoord:           pixelShader->vPosDeclared = true;  return 0;
+		case EvqFrontFacing:         pixelShader->vFaceDeclared = true; return 1;
+		case EvqPointCoord:          return varyingRegister(operand);
+		case EvqFragColor:           return 0;
+		case EvqFragData:            return 0;
+		default: UNREACHABLE();
+		}
+
+		return 0;
+	}
+
+	int OutputASM::writeMask(TIntermTyped *destination, int index)
+	{
+		if(destination->getQualifier() == EvqPointSize)
+		{
+			return 0x2;   // Point size stored in the y component
+		}
+
+		return 0xF >> (4 - registerSize(destination->getType(), index));
+	}
+
+	// Conservatively checks whether an expression is fast to compute and has no side effects
+	bool OutputASM::trivial(TIntermTyped *expression, int budget)
+	{
+		if(!expression->isRegister())
+		{
+			return false;
+		}
+
+		return cost(expression, budget) >= 0;
+	}
+
+	// Returns the remaining computing budget (if < 0 the expression is too expensive or has side effects)
+	int OutputASM::cost(TIntermNode *expression, int budget)
+	{
+		if(budget < 0)
+		{
+			return budget;
+		}
+
+		if(expression->getAsSymbolNode())
+		{
+			return budget;
+		}
+		else if(expression->getAsConstantUnion())
+		{
+			return budget;
+		}
+		else if(expression->getAsBinaryNode())
+		{
+			TIntermBinary *binary = expression->getAsBinaryNode();
+
+			switch(binary->getOp())
+			{
+			case EOpVectorSwizzle:
+			case EOpIndexDirect:
+			case EOpIndexDirectStruct:
+				return cost(binary->getLeft(), budget - 0);
+			case EOpAdd:
+			case EOpSub:
+			case EOpMul:
+				return cost(binary->getLeft(), cost(binary->getRight(), budget - 1));
+			default:
+				return -1;
+			}
+		}
+		else if(expression->getAsUnaryNode())
+		{
+			TIntermUnary *unary = expression->getAsUnaryNode();
+
+			switch(unary->getOp())
+			{
+			case EOpAbs:
+			case EOpNegative:
+				return cost(unary->getOperand(), budget - 1);
+			default:
+				return -1;
+			}
+		}
+		else if(expression->getAsSelectionNode())
+		{
+			TIntermSelection *selection = expression->getAsSelectionNode();
+
+			if(selection->usesTernaryOperator())
+			{
+				TIntermTyped *condition = selection->getCondition();
+				TIntermNode *trueBlock = selection->getTrueBlock();
+				TIntermNode *falseBlock = selection->getFalseBlock();
+				TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();
+
+				if(constantCondition)
+				{
+					bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();
+
+					if(trueCondition)
+					{
+						return cost(trueBlock, budget - 0);
+					}
+					else
+					{
+						return cost(falseBlock, budget - 0);
+					}
+				}
+				else
+				{
+					return cost(trueBlock, cost(falseBlock, budget - 2));
+				}
+			}
+		}
+
+		return -1;
+	}
+
+	const Function &OutputASM::findFunction(const TString &name)
+	{
+		for(unsigned int f = 0; f < functionArray.size(); f++)
+		{
+			if(functionArray[f].name == name)
+			{
+				return functionArray[f];
+			}
+		}
+
+		UNREACHABLE();
+		return functionArray[0];
+	}
+	
+	int OutputASM::temporaryRegister(TIntermTyped *temporary)
+	{
+		return allocate(temporaries, temporary);
+	}
+
+	int OutputASM::varyingRegister(TIntermTyped *varying)
+	{
+		int var = lookup(varyings, varying);
+
+		if(var == -1)
+		{
+			var = allocate(varyings, varying);
+			const TType &type = varying->getType();
+			int size = varying->getNominalSize();
+
+			if(pixelShader)
+			{
+				if(varying->getQualifier() == EvqPointCoord)
+				{
+					ASSERT(varying->isRegister());
+					if(size >= 1) pixelShader->semantic[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
+					if(size >= 2) pixelShader->semantic[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
+					if(size >= 3) pixelShader->semantic[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
+					if(size >= 4) pixelShader->semantic[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
+				}
+				else
+				{
+					for(int i = 0; i < varying->totalRegisterCount(); i++)
+					{
+						if(size >= 1) pixelShader->semantic[var + i][0] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
+						if(size >= 2) pixelShader->semantic[var + i][1] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
+						if(size >= 3) pixelShader->semantic[var + i][2] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
+						if(size >= 4) pixelShader->semantic[var + i][3] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
+					}
+				}
+			}
+			else if(vertexShader)   // Semantic indexes will be reassigned during program link to match the pixel shader
+			{
+				if(varying->getQualifier() == EvqPosition)
+				{
+					ASSERT(varying->isRegister());
+					vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
+					vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
+					vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
+					vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
+					vertexShader->positionRegister = var;
+				}
+				else if(varying->getQualifier() == EvqPointSize)
+				{
+					ASSERT(varying->isRegister());
+					vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
+					vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
+					vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
+					vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
+					vertexShader->pointSizeRegister = var;
+				}
+			}
+			else UNREACHABLE();
+
+			if(varying->getQualifier() != EvqPointCoord)   // gl_PointCoord does not need linking
+			{
+				gl::VaryingList &activeVaryings = shaderObject->varyings;
+				const char *name = varying->getAsSymbolNode()->getSymbol().c_str();
+				activeVaryings.push_back(gl::Varying(glVariableType(type), name, varying->getArraySize(), var, 0));
+			}
+		}
+
+		return var;
+	}
+
+	int OutputASM::uniformRegister(TIntermTyped *uniform)
+	{
+		const TType &type = uniform->getType();
+		ASSERT(!IsSampler(type.getBasicType()));
+		TIntermSymbol *symbol = uniform->getAsSymbolNode();
+		ASSERT(symbol);
+
+		if(symbol)
+		{
+			int index = lookup(uniforms, uniform);
+
+			if(index == -1)
+			{
+				index = allocate(uniforms, uniform);
+				const TString &name = symbol->getSymbol().c_str();
+
+				declareUniform(type, name, index);
+			}
+
+			return index;
+		}
+
+		return 0;
+	}
+
+	int OutputASM::attributeRegister(TIntermTyped *attribute)
+	{
+		ASSERT(!attribute->isArray());
+		ASSERT(attribute->getBasicType() == EbtFloat);
+
+		int index = lookup(attributes, attribute);
+
+		if(index == -1)
+		{
+			TIntermSymbol *symbol = attribute->getAsSymbolNode();
+			ASSERT(symbol);
+
+			if(symbol)
+			{
+				index = allocate(attributes, attribute);
+				const TType &type = attribute->getType();
+
+				sw::VertexShader *vertexShader = static_cast<sw::VertexShader*>(shader);
+
+				for(int i = 0; i < attribute->totalRegisterCount(); i++)
+				{
+					vertexShader->input[index + i] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, index + i);
+				}
+
+				ActiveAttributes &activeAttributes = shaderObject->activeAttributes;
+
+				const char *name = symbol->getSymbol().c_str();
+				activeAttributes.push_back(Attribute(glVariableType(type), name, 0, index));
+			}
+		}
+
+		return index;
+	}
+
+	int OutputASM::samplerRegister(TIntermTyped *sampler)
+	{
+		const TType &type = sampler->getType();
+		ASSERT(IsSampler(type.getBasicType()));
+		const TTypeList *structure = type.getStruct();
+		TIntermSymbol *symbol = sampler->getAsSymbolNode();
+		TIntermBinary *binary = sampler->getAsBinaryNode();
+
+		if(symbol)
+		{
+			int index = lookup(samplers, sampler);
+
+			if(index == -1)
+			{
+				index = allocate(samplers, sampler);
+				ActiveUniforms &activeUniforms = shaderObject->activeUniforms;
+				const char *name = symbol->getSymbol().c_str();
+				activeUniforms.push_back(Uniform(glVariableType(type), name, sampler->getArraySize(), index));
+
+				for(int i = 0; i < sampler->totalRegisterCount(); i++)
+				{
+					shader->declareSampler(i);
+				}
+			}
+
+			return index;
+		}
+		else if(binary)
+		{
+			ASSERT(binary->getOp() == EOpIndexDirect || binary->getOp() == EOpIndexIndirect);
+
+			return samplerRegister(binary->getLeft());   // Index added later
+		}
+		else UNREACHABLE();
+
+		return 0;
+	}
+
+	int OutputASM::lookup(VariableArray &list, TIntermTyped *variable)
+	{
+		for(unsigned int i = 0; i < list.size(); i++)
+		{
+			if(list[i] == variable)
+			{
+				return i;   // Pointer match
+			}
+		}
+
+		TIntermSymbol *varSymbol = variable->getAsSymbolNode();
+
+		if(varSymbol)
+		{
+			for(unsigned int i = 0; i < list.size(); i++)
+			{
+				if(list[i])
+				{
+					TIntermSymbol *listSymbol = list[i]->getAsSymbolNode();
+
+					if(listSymbol)
+					{
+						if(listSymbol->getId() == varSymbol->getId())
+						{
+							ASSERT(listSymbol->getSymbol() == varSymbol->getSymbol());
+							ASSERT(listSymbol->getType() == varSymbol->getType());
+							ASSERT(listSymbol->getQualifier() == varSymbol->getQualifier());
+
+							return i;
+						}
+					}
+				}
+			}
+		}
+
+		return -1;
+	}
+
+	int OutputASM::allocate(VariableArray &list, TIntermTyped *variable)
+	{
+		int index = lookup(list, variable);
+
+		if(index == -1)
+		{
+			unsigned int registerCount = variable->totalRegisterCount();
+
+			for(unsigned int i = 0; i < list.size(); i++)
+			{
+				if(list[i] == 0)
+				{
+					unsigned int j = 1;
+					for( ; j < registerCount && (i + j) < list.size(); j++)
+					{
+						if(list[i + j] != 0)
+						{
+							break;
+						}
+					}
+
+					if(j == registerCount)   // Found free slots
+					{
+						for(unsigned int j = 0; j < registerCount; j++)
+						{
+							list[i + j] = variable;
+						}
+
+						return i;
+					}
+				}
+			}
+
+			index = list.size();
+
+			for(unsigned int i = 0; i < registerCount; i++)
+			{
+				list.push_back(variable);
+			}
+		}
+
+		return index;
+	}
+
+	void OutputASM::free(VariableArray &list, TIntermTyped *variable)
+	{
+		int index = lookup(list, variable);
+
+		if(index >= 0)
+		{
+			list[index] = 0;
+		}
+	}
+
+	void OutputASM::declareUniform(const TType &type, const TString &name, int index)
+	{
+		const TTypeList *structure = type.getStruct();
+		ActiveUniforms &activeUniforms = shaderObject->activeUniforms;
+
+		if(!structure)
+		{
+			activeUniforms.push_back(Uniform(glVariableType(type), name.c_str(), type.getArraySize(), index));
+		}
+		else
+		{
+			if(type.isArray())
+			{
+				int elementIndex = index;
+
+				for(int i = 0; i < type.getArraySize(); i++)
+				{
+					for(size_t j = 0; j < structure->size(); j++)
+					{
+						const TType &fieldType = *(*structure)[j].type;
+						const TString &fieldName = fieldType.getFieldName();
+
+						const TString uniformName = name + "[" + str(i) + "]." + fieldName;
+						declareUniform(fieldType, uniformName, elementIndex);
+						elementIndex += fieldType.elementRegisterCount();
+					}
+				}
+			}
+			else
+			{
+				int fieldIndex = index;
+
+				for(size_t i = 0; i < structure->size(); i++)
+				{
+					const TType &fieldType = *(*structure)[i].type;
+					const TString &fieldName = fieldType.getFieldName();
+
+					const TString uniformName = name + "." + fieldName;
+					declareUniform(fieldType, uniformName, fieldIndex);
+					fieldIndex += fieldType.totalRegisterCount();
+				}
+			}
+		}
+	}
+
+	GLenum OutputASM::glVariableType(const TType &type)
+	{
+		if(type.getBasicType() == EbtFloat)
+		{
+			if(type.isScalar())
+			{
+				return GL_FLOAT;
+			}
+			else if(type.isVector())
+			{
+				switch(type.getNominalSize())
+				{
+				case 2: return GL_FLOAT_VEC2;
+				case 3: return GL_FLOAT_VEC3;
+				case 4: return GL_FLOAT_VEC4;
+				default: UNREACHABLE();
+				}
+			}
+			else if(type.isMatrix())
+			{
+				switch(type.getNominalSize())
+				{
+				case 2: return GL_FLOAT_MAT2;
+				case 3: return GL_FLOAT_MAT3;
+				case 4: return GL_FLOAT_MAT4;
+				default: UNREACHABLE();
+				}
+			}
+			else UNREACHABLE();
+		}
+		else if(type.getBasicType() == EbtInt)
+		{
+			if(type.isScalar())
+			{
+				return GL_INT;
+			}
+			else if(type.isVector())
+			{
+				switch(type.getNominalSize())
+				{
+				case 2: return GL_INT_VEC2;
+				case 3: return GL_INT_VEC3;
+				case 4: return GL_INT_VEC4;
+				default: UNREACHABLE();
+				}
+			}
+			else UNREACHABLE();
+		}
+		else if(type.getBasicType() == EbtBool)
+		{
+			if(type.isScalar())
+			{
+				return GL_BOOL;
+			}
+			else if(type.isVector())
+			{
+				switch(type.getNominalSize())
+				{
+				case 2: return GL_BOOL_VEC2;
+				case 3: return GL_BOOL_VEC3;
+				case 4: return GL_BOOL_VEC4;
+				default: UNREACHABLE();
+				}
+			}
+			else UNREACHABLE();
+		}
+		else if(type.getBasicType() == EbtInt)
+		{
+			if(type.isScalar())
+			{
+				return GL_INT;
+			}
+			else if(type.isVector())
+			{
+				switch(type.getNominalSize())
+				{
+				case 2: return GL_INT_VEC2;
+				case 3: return GL_INT_VEC3;
+				case 4: return GL_INT_VEC4;
+				default: UNREACHABLE();
+				}
+			}
+			else UNREACHABLE();
+		}
+		else if(type.getBasicType() == EbtBool)
+		{
+			if(type.isScalar())
+			{
+				return GL_BOOL;
+			}
+			else if(type.isVector())
+			{
+				switch(type.getNominalSize())
+				{
+				case 2: return GL_BOOL_VEC2;
+				case 3: return GL_BOOL_VEC3;
+				case 4: return GL_BOOL_VEC4;
+				default: UNREACHABLE();
+				}
+			}
+			else UNREACHABLE();
+		}
+		else if(type.getBasicType() == EbtSampler2D)
+		{
+			return GL_SAMPLER_2D;
+		}
+		else if(type.getBasicType() == EbtSamplerCube)
+		{
+			return GL_SAMPLER_CUBE;
+		}
+		else UNREACHABLE();
+
+		return GL_NONE;
+	}
+
+	int OutputASM::dim(TIntermNode *v)
+	{
+		TIntermTyped *vector = v->getAsTyped();
+		ASSERT(vector && vector->isRegister());
+		return vector->getNominalSize();
+	}
+
+	int OutputASM::dim2(TIntermNode *m)
+	{
+		TIntermTyped *matrix = m->getAsTyped();
+		ASSERT(matrix && matrix->isMatrix() && !matrix->isArray());
+		return matrix->getNominalSize();
+	}
+}
diff --git a/src/OpenGL ES 2.0/compiler/OutputASM.h b/src/OpenGL ES 2.0/compiler/OutputASM.h
new file mode 100644
index 0000000..ab0ba34
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/OutputASM.h
@@ -0,0 +1,160 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef COMPILER_OUTPUTASM_H_
+#define COMPILER_OUTPUTASM_H_
+
+#include "intermediate.h"
+#include "ParseHelper.h"
+#include "Shader/PixelShader.hpp"
+#include "Shader/VertexShader.hpp"
+
+#define GL_APICALL
+#include <GLES2/gl2.h>
+
+#include <list>
+#include <set>
+#include <map>
+
+namespace gl
+{
+	class Shader;
+}
+
+namespace sh
+{
+	struct Uniform
+	{
+		Uniform(GLenum type, const std::string &name, int arraySize, int registerIndex);
+
+		GLenum type;
+		std::string name;
+		int arraySize;
+	
+		int registerIndex;
+	};
+
+	typedef std::vector<Uniform> ActiveUniforms;
+
+	struct Attribute
+	{
+		Attribute();
+		Attribute(GLenum type, const std::string &name, int arraySize, int registerIndex);
+
+		GLenum type;
+		std::string name;
+		int arraySize;
+	
+		int registerIndex;
+	};
+
+	struct Function
+	{
+		Function(int label, const char *name, TIntermSequence *arg, TIntermTyped *ret) : label(label), name(name), arg(arg), ret(ret)
+		{
+		}
+
+		Function(int label, const TString &name, TIntermSequence *arg, TIntermTyped *ret) : label(label), name(name), arg(arg), ret(ret)
+		{
+		}
+
+		const int label;
+		const TString name;
+		TIntermSequence *const arg;
+		TIntermTyped *const ret;
+	};
+	
+	typedef sw::Shader::Instruction Instruction;
+	typedef std::vector<Attribute> ActiveAttributes;
+
+	class Temporary;
+
+	class OutputASM : public TIntermTraverser
+	{
+	public:
+		explicit OutputASM(TParseContext &context, gl::Shader *shaderObject);
+		~OutputASM();
+
+		void output();
+
+		void freeTemporary(Temporary *temporary);
+
+	protected:
+		enum Scope
+		{
+			GLOBAL,
+			FUNCTION
+		};
+
+		void emitShader(Scope scope);
+
+		// Visit AST nodes and output their code to the body stream
+		virtual bool visitBinary(Visit visit, TIntermBinary*);
+		virtual bool visitUnary(Visit visit, TIntermUnary*);
+		virtual bool visitSelection(Visit visit, TIntermSelection*);
+		virtual bool visitAggregate(Visit visit, TIntermAggregate*);
+		virtual bool visitLoop(Visit visit, TIntermLoop*);
+		virtual bool visitBranch(Visit visit, TIntermBranch*);
+
+		Instruction *emit(sw::Shader::Opcode op, TIntermTyped *dst = 0, TIntermNode *src0 = 0, TIntermNode *src1 = 0, TIntermNode *src2 = 0);
+		void emitAssign(sw::Shader::Opcode op, TIntermTyped *result, TIntermTyped *lhs, TIntermTyped *src0, TIntermTyped *src1 = 0);
+		void emitCmp(sw::Shader::Control cmpOp, TIntermTyped *dst, TIntermNode *left, TIntermNode *right, int index = 0);
+		void argument(sw::Shader::SourceParameter &parameter, TIntermNode *argument, int index = 0);
+		void copy(TIntermTyped *dst, TIntermNode *src, int offset = 0);
+		void assignLvalue(TIntermTyped *dst, TIntermNode *src);
+		int lvalue(sw::Shader::DestinationParameter &dst, Temporary &address, TIntermTyped *node);
+		sw::Shader::ParameterType registerType(TIntermTyped *operand);
+		int registerIndex(TIntermTyped *operand);
+		int writeMask(TIntermTyped *destination, int index = 0);
+		bool trivial(TIntermTyped *expression, int budget);   // Fast to compute and no side effects
+		int cost(TIntermNode *expression, int budget);
+		const Function &findFunction(const TString &name);
+
+		int temporaryRegister(TIntermTyped *temporary);
+		int varyingRegister(TIntermTyped *varying);
+		int uniformRegister(TIntermTyped *uniform);
+		int attributeRegister(TIntermTyped *attribute);
+		int samplerRegister(TIntermTyped *sampler);
+
+		typedef std::vector<TIntermTyped*> VariableArray;
+
+		int lookup(VariableArray &list, TIntermTyped *variable);
+		int allocate(VariableArray &list, TIntermTyped *variable);
+		void free(VariableArray &list, TIntermTyped *variable);
+
+		void declareUniform(const TType &type, const TString &name, int index);
+		GLenum glVariableType(const TType &type);
+
+		static int dim(TIntermNode *v);
+		static int dim2(TIntermNode *m);
+
+		gl::Shader *const shaderObject;
+		sw::Shader *shader;
+		sw::PixelShader *pixelShader;
+		sw::VertexShader *vertexShader;
+
+		VariableArray temporaries;
+		VariableArray uniforms;
+		VariableArray varyings;
+		VariableArray attributes;
+		VariableArray samplers;
+
+		Scope emitScope;
+		Scope currentScope;
+
+		int currentFunction;
+		std::vector<Function> functionArray;
+
+		TParseContext &mContext;
+	};
+}
+
+#endif   // COMPILER_OUTPUTASM_H_
diff --git a/src/OpenGL ES 2.0/compiler/ParseHelper.cpp b/src/OpenGL ES 2.0/compiler/ParseHelper.cpp
index ab7c182..2fa9ba5 100644
--- a/src/OpenGL ES 2.0/compiler/ParseHelper.cpp
+++ b/src/OpenGL ES 2.0/compiler/ParseHelper.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -462,10 +462,8 @@
             }
         }
         if (identifier.find("__") != TString::npos) {
-            //error(line, "Two consecutive underscores are reserved for future use.", identifier.c_str(), "", "");
-            //return true;
-            infoSink.info.message(EPrefixWarning, "Two consecutive underscores are reserved for future use.", line);
-            return false;
+            error(line, "identifiers containing two consecutive underscores (__) are reserved as possible future keywords", identifier.c_str(), "", "");
+            return true;
         }
     }
 
@@ -552,7 +550,7 @@
         return true;
     }
 
-    if (!type->isMatrix()) {
+    if (!type->isMatrix() || !matrixInMatrix) {
         if ((op != EOpConstructStruct && size != 1 && size < type->getObjectSize()) ||
             (op == EOpConstructStruct && size < type->getObjectSize())) {
             error(line, "not enough data provided for construction", "constructor", "");
diff --git a/src/OpenGL ES 2.0/compiler/PoolAlloc.h b/src/OpenGL ES 2.0/compiler/PoolAlloc.h
index 55e09db..c33dfd9 100644
--- a/src/OpenGL ES 2.0/compiler/PoolAlloc.h
+++ b/src/OpenGL ES 2.0/compiler/PoolAlloc.h
@@ -253,12 +253,18 @@
     pointer address(reference x) const { return &x; }
     const_pointer address(const_reference x) const { return &x; }
 
-    pool_allocator() : allocator(GlobalPoolAllocator) { }
-    pool_allocator(TPoolAllocator& a) : allocator(a) { }
+    pool_allocator() : allocator(&GlobalPoolAllocator) { }
+    pool_allocator(TPoolAllocator& a) : allocator(&a) { }
     pool_allocator(const pool_allocator<T>& p) : allocator(p.allocator) { }
 
+    template <class Other>
+    pool_allocator<T>& operator=(const pool_allocator<Other>& p) {
+      allocator = p.allocator;
+      return *this;
+    }
+
     template<class Other>
-    pool_allocator(const pool_allocator<Other>& p) : allocator(p.getAllocator()) { }
+    pool_allocator(const pool_allocator<Other>& p) : allocator(&p.getAllocator()) { }
 
 #if defined(__SUNPRO_CC) && !defined(_RWSTD_ALLOCATOR)
     // libCStd on some platforms have a different allocate/deallocate interface.
@@ -290,11 +296,11 @@
     size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
     size_type max_size(int size) const { return static_cast<size_type>(-1) / size; }
 
-    void setAllocator(TPoolAllocator* a) { allocator = *a; }
-    TPoolAllocator& getAllocator() const { return allocator; }
+    void setAllocator(TPoolAllocator *a) { allocator = a; }
+    TPoolAllocator& getAllocator() const { return *allocator; }
 
 protected:
-    TPoolAllocator& allocator;
+    TPoolAllocator *allocator;
 };
 
 #endif // _POOLALLOC_INCLUDED_
diff --git a/src/OpenGL ES 2.0/compiler/ShHandle.h b/src/OpenGL ES 2.0/compiler/ShHandle.h
index 17e2fe0..28263b7 100644
--- a/src/OpenGL ES 2.0/compiler/ShHandle.h
+++ b/src/OpenGL ES 2.0/compiler/ShHandle.h
@@ -57,7 +57,6 @@
     TInfoSink& getInfoSink() { return infoSink; }
     const TVariableInfoList& getAttribs() const { return attribs; }
     const TVariableInfoList& getUniforms() const { return uniforms; }
-    int getMappedNameMaxLength() const;
 
 protected:
     ShShaderType getShaderType() const { return shaderType; }
@@ -73,8 +72,6 @@
     bool validateLimitations(TIntermNode* root);
     // Collect info for all attribs and uniforms.
     void collectAttribsUniforms(TIntermNode* root);
-    // Map long variable names into shorter ones.
-    void mapLongVariableNames(TIntermNode* root);
     // Translate to object code.
     virtual void translate(TIntermNode* root) = 0;
 
diff --git a/src/OpenGL ES 2.0/compiler/ShaderLang.cpp b/src/OpenGL ES 2.0/compiler/ShaderLang.cpp
index 051e4ec..4fd7cae 100644
--- a/src/OpenGL ES 2.0/compiler/ShaderLang.cpp
+++ b/src/OpenGL ES 2.0/compiler/ShaderLang.cpp
@@ -37,8 +37,7 @@
                             int* length,
                             int* size,
                             ShDataType* type,
-                            char* name,
-                            char* mappedName)
+                            char* name)
 {
     if (!handle || !size || !type || !name)
         return;
@@ -60,8 +59,6 @@
     *size = varInfo.size;
     *type = varInfo.type;
     strcpy(name, varInfo.name.c_str());
-    if (mappedName)
-        strcpy(mappedName, varInfo.mappedName.c_str());
 }
 
 //
@@ -197,9 +194,6 @@
     case SH_ACTIVE_ATTRIBUTE_MAX_LENGTH:
         *params = getVariableMaxLength(compiler->getAttribs());
         break;
-    case SH_MAPPED_NAME_MAX_LENGTH:
-        *params = compiler->getMappedNameMaxLength();
-        break;
     default: UNREACHABLE();
     }
 }
@@ -241,11 +235,10 @@
                        int* length,
                        int* size,
                        ShDataType* type,
-                       char* name,
-                       char* mappedName)
+                       char* name)
 {
     getVariableInfo(SH_ACTIVE_ATTRIBUTES,
-                    handle, index, length, size, type, name, mappedName);
+                    handle, index, length, size, type, name);
 }
 
 void ShGetActiveUniform(const ShHandle handle,
@@ -253,9 +246,8 @@
                         int* length,
                         int* size,
                         ShDataType* type,
-                        char* name,
-                        char* mappedName)
+                        char* name)
 {
     getVariableInfo(SH_ACTIVE_UNIFORMS,
-                    handle, index, length, size, type, name, mappedName);
+                    handle, index, length, size, type, name);
 }
diff --git a/src/OpenGL ES 2.0/compiler/SymbolTable.h b/src/OpenGL ES 2.0/compiler/SymbolTable.h
index 38bc657..5789240 100644
--- a/src/OpenGL ES 2.0/compiler/SymbolTable.h
+++ b/src/OpenGL ES 2.0/compiler/SymbolTable.h
@@ -302,6 +302,12 @@
         assert(table.size() >= 2);
         return table[1];
     }
+	
+	TSymbolTableLevel* getOuterLevel() {
+        assert(table.size() >= 2);
+        return table[currentLevel() - 1];
+    }
+
     void relateToOperator(const char* name, TOperator op) {
         table[0]->relateToOperator(name, op);
     }
diff --git a/src/OpenGL ES 2.0/compiler/TranslatorASM.cpp b/src/OpenGL ES 2.0/compiler/TranslatorASM.cpp
new file mode 100644
index 0000000..d1f8093
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/TranslatorASM.cpp
@@ -0,0 +1,42 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "TranslatorASM.h"
+
+TranslatorASM::TranslatorASM(gl::Shader *shaderObject, ShShaderType type, ShShaderSpec spec) : TCompiler(type, spec), shaderObject(shaderObject)
+{
+}
+
+void TranslatorASM::translate(TIntermNode* root)
+{
+    TParseContext& parseContext = *GetGlobalParseContext();
+    sh::OutputASM outputASM(parseContext, shaderObject);
+
+	outputASM.output();
+}
+
+//
+// This function must be provided to create the actual
+// compile object used by higher level code.  It returns
+// a subclass of TCompiler.
+//
+TCompiler* ConstructCompiler(ShShaderType type, ShShaderSpec spec)
+{
+    return new TranslatorASM(0, type, spec);
+}
+
+//
+// Delete the compiler made by ConstructCompiler
+//
+void DeleteCompiler(TCompiler* compiler)
+{
+    delete compiler;
+}
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/compiler/TranslatorASM.h b/src/OpenGL ES 2.0/compiler/TranslatorASM.h
new file mode 100644
index 0000000..1705043
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/TranslatorASM.h
@@ -0,0 +1,37 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef COMPILER_TRANSLATORASM_H_
+#define COMPILER_TRANSLATORASM_H_
+
+#include "ShHandle.h"
+#include "OutputASM.h"
+#include "Shader/PixelShader.hpp"
+#include "Shader/VertexShader.hpp"
+
+namespace gl
+{
+	class Shader;
+}
+
+class TranslatorASM : public TCompiler
+{
+public:
+    TranslatorASM(gl::Shader *shaderObject, ShShaderType type, ShShaderSpec spec);
+
+protected:
+    virtual void translate(TIntermNode* root);
+
+private:
+	gl::Shader *const shaderObject;
+};
+
+#endif  // COMPILER_TRANSLATORASM_H_
diff --git a/src/OpenGL ES 2.0/compiler/Types.h b/src/OpenGL ES 2.0/compiler/Types.h
index d0fcc08..1112c5a 100644
--- a/src/OpenGL ES 2.0/compiler/Types.h
+++ b/src/OpenGL ES 2.0/compiler/Types.h
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -9,7 +9,7 @@
 
 #include "compiler/BaseTypes.h"
 #include "compiler/Common.h"
-#include "compiler/debug.h"
+#include "common/debug.h"
 
 //
 // Need to have association of line numbers to types in a list for building structs.
@@ -168,23 +168,72 @@
     // One-dimensional size of single instance type
     int getNominalSize() const { return size; }
     void setNominalSize(int s) { size = s; }
+
     // Full size of single instance of type
-    int getObjectSize() const
-    {
-        int totalSize;
+	int getObjectSize() const
+	{
+		if(isArray())
+		{
+			return getElementSize() * std::max(getArraySize(), getMaxArraySize());
+		}
+		else
+		{
+			return getElementSize();
+		}
+	}
 
-        if (getBasicType() == EbtStruct)
-            totalSize = getStructSize();
-        else if (matrix)
-            totalSize = size * size;
-        else
-            totalSize = size;
+	int getElementSize() const
+	{
+		if(getBasicType() == EbtStruct)
+		{
+			return getStructSize();
+		}
+		else if(matrix)
+		{
+			return size * size;
+		}
+		else   // Vector or scalar
+		{
+			return size;
+		}
+	}
 
-        if (isArray())
-            totalSize *= std::max(getArraySize(), getMaxArraySize());
+	int elementRegisterCount() const
+	{
+		TTypeList *structure = getStruct();
 
-        return totalSize;
-    }
+		if(structure)
+		{
+			int registerCount = 0;
+
+			for(size_t i = 0; i < structure->size(); i++)
+			{
+				registerCount += (*structure)[i].type->totalRegisterCount();
+			}
+
+			return registerCount;
+		}
+		else if(isMatrix())
+		{
+			return getNominalSize();
+		}
+		else
+		{
+			return 1;
+		}
+	}
+
+	int totalRegisterCount() const
+	{
+		if(array)
+		{
+			return arraySize * elementRegisterCount();
+		}
+		else
+		{
+			return elementRegisterCount();
+		}
+	}
 
     bool isMatrix() const { return matrix ? true : false; }
     void setMatrix(bool m) { matrix = m; }
@@ -200,6 +249,8 @@
 
     bool isVector() const { return size > 1 && !matrix; }
     bool isScalar() const { return size == 1 && !matrix && !structure; }
+	bool isRegister() const { return !matrix && !structure && !array; }   // Fits in a 4-element register
+	bool isStruct() const { return structure != 0; }
 
     TTypeList* getStruct() const { return structure; }
     void setStruct(TTypeList* s) { structure = s; }
diff --git a/src/OpenGL ES 2.0/compiler/VariableInfo.cpp b/src/OpenGL ES 2.0/compiler/VariableInfo.cpp
index a13a896..071d05e 100644
--- a/src/OpenGL ES 2.0/compiler/VariableInfo.cpp
+++ b/src/OpenGL ES 2.0/compiler/VariableInfo.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -70,37 +70,32 @@
 
 static void getBuiltInVariableInfo(const TType& type,
                                    const TString& name,
-                                   const TString& mappedName,
                                    TVariableInfoList& infoList);
 static void getUserDefinedVariableInfo(const TType& type,
                                        const TString& name,
-                                       const TString& mappedName,
                                        TVariableInfoList& infoList);
 
 // Returns info for an attribute or uniform.
 static void getVariableInfo(const TType& type,
                             const TString& name,
-                            const TString& mappedName,
                             TVariableInfoList& infoList)
 {
     if (type.getBasicType() == EbtStruct) {
         if (type.isArray()) {
             for (int i = 0; i < type.getArraySize(); ++i) {
                 TString lname = name + arrayBrackets(i);
-                TString lmappedName = mappedName + arrayBrackets(i);
-                getUserDefinedVariableInfo(type, lname, lmappedName, infoList);
+                getUserDefinedVariableInfo(type, lname, infoList);
             }
         } else {
-            getUserDefinedVariableInfo(type, name, mappedName, infoList);
+            getUserDefinedVariableInfo(type, name, infoList);
         }
     } else {
-        getBuiltInVariableInfo(type, name, mappedName, infoList);
+        getBuiltInVariableInfo(type, name, infoList);
     }
 }
 
 void getBuiltInVariableInfo(const TType& type,
                             const TString& name,
-                            const TString& mappedName,
                             TVariableInfoList& infoList)
 {
     ASSERT(type.getBasicType() != EbtStruct);
@@ -108,11 +103,9 @@
     TVariableInfo varInfo;
     if (type.isArray()) {
         varInfo.name = (name + "[0]").c_str();
-        varInfo.mappedName = (mappedName + "[0]").c_str();
         varInfo.size = type.getArraySize();
     } else {
         varInfo.name = name.c_str();
-        varInfo.mappedName = mappedName.c_str();
         varInfo.size = 1;
     }
     varInfo.type = getVariableDataType(type);
@@ -121,7 +114,6 @@
 
 void getUserDefinedVariableInfo(const TType& type,
                                 const TString& name,
-                                const TString& mappedName,
                                 TVariableInfoList& infoList)
 {
     ASSERT(type.getBasicType() == EbtStruct);
@@ -131,7 +123,6 @@
         const TType* fieldType = (*structure)[i].type;
         getVariableInfo(*fieldType,
                         name + "." + fieldType->getFieldName(),
-                        mappedName + "." + fieldType->getFieldName(),
                         infoList);
     }
 }
@@ -195,7 +186,6 @@
                 // TIntermSymbol nodes in the sequence.
                 ASSERT(variable != NULL);
                 getVariableInfo(variable->getType(),
-                                variable->getOriginalSymbol(),
                                 variable->getSymbol(),
                                 infoList);
             }
diff --git a/src/OpenGL ES 2.0/compiler/VariableInfo.h b/src/OpenGL ES 2.0/compiler/VariableInfo.h
index 667acaf..77902d9 100644
--- a/src/OpenGL ES 2.0/compiler/VariableInfo.h
+++ b/src/OpenGL ES 2.0/compiler/VariableInfo.h
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -14,7 +14,6 @@
 // It is currently being used to store info about active attribs and uniforms.
 struct TVariableInfo {
     TPersistString name;
-    TPersistString mappedName;
     ShDataType type;
     int size;
 };
diff --git a/src/OpenGL ES 2.0/compiler/debug.cpp b/src/OpenGL ES 2.0/compiler/debug.cpp
deleted file mode 100644
index 9642e1e..0000000
--- a/src/OpenGL ES 2.0/compiler/debug.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// debug.cpp: Debugging utilities.
-
-#include "compiler/debug.h"
-
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "compiler/ParseHelper.h"
-
-static const int kTraceBufferLen = 1024;
-
-#ifdef TRACE_ENABLED
-extern "C" {
-void Trace(const char *format, ...) {
-    if (!format) return;
-
-    TParseContext* parseContext = GetGlobalParseContext();
-    if (parseContext) {
-        char buf[kTraceBufferLen];
-        va_list args;
-        va_start(args, format);
-        vsnprintf(buf, kTraceBufferLen, format, args);
-        va_end(args);
-
-        parseContext->infoSink.debug << buf;
-    }
-}
-}  // extern "C"
-#endif  // TRACE_ENABLED
-
diff --git a/src/OpenGL ES 2.0/compiler/debug.h b/src/OpenGL ES 2.0/compiler/debug.h
deleted file mode 100644
index 7a37151..0000000
--- a/src/OpenGL ES 2.0/compiler/debug.h
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// debug.h: Debugging utilities.
-
-#ifndef COMPILER_DEBUG_H_
-#define COMPILER_DEBUG_H_
-
-#include <assert.h>
-
-#ifdef _DEBUG
-#define TRACE_ENABLED  // define to enable debug message tracing
-#endif  // _DEBUG
-
-// Outputs text to the debug log
-#ifdef TRACE_ENABLED
-
-#ifdef  __cplusplus
-extern "C" {
-#endif  // __cplusplus
-void Trace(const char* format, ...);
-#ifdef  __cplusplus
-}
-#endif  // __cplusplus
-
-#else   // TRACE_ENABLED
-
-#define Trace(...) ((void)0)
-
-#endif  // TRACE_ENABLED
-
-// A macro asserting a condition and outputting failures to the debug log
-#define ASSERT(expression) do { \
-    if(!(expression)) \
-        Trace("Assert failed: %s(%d): "#expression"\n", __FUNCTION__, __LINE__); \
-    assert(expression); \
-} while(0)
-
-#define UNIMPLEMENTED() do { \
-    Trace("Unimplemented invoked: %s(%d)\n", __FUNCTION__, __LINE__); \
-    assert(false); \
-} while(0)
-
-#define UNREACHABLE() do { \
-    Trace("Unreachable reached: %s(%d)\n", __FUNCTION__, __LINE__); \
-    assert(false); \
-} while(0)
-
-#endif   // COMPILER_DEBUG_H_
-
diff --git a/src/OpenGL ES 2.0/compiler/generate_parser.sh b/src/OpenGL ES 2.0/compiler/generate_parser.sh
new file mode 100644
index 0000000..e472191
--- /dev/null
+++ b/src/OpenGL ES 2.0/compiler/generate_parser.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+# Copyright (c) 2010 The ANGLE Project Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# Generates GLSL ES parser - glslang_lex.cpp, glslang_tab.h, and glslang_tab.cpp
+
+run_flex()
+{
+input_file=$script_dir/$1.l
+output_source=$script_dir/$1_lex.cpp
+flex --noline --nounistd --outfile=$output_source $input_file
+}
+
+run_bison()
+{
+input_file=$script_dir/$1.y
+output_header=$script_dir/$1_tab.h
+output_source=$script_dir/$1_tab.cpp
+bison --no-lines --skeleton=yacc.c --defines=$output_header --output=$output_source $input_file
+}
+
+script_dir=$(dirname $0)
+
+# Generate Parser
+run_flex glslang
+run_bison glslang
diff --git a/src/OpenGL ES 2.0/compiler/glslang.l b/src/OpenGL ES 2.0/compiler/glslang.l
index 5a7c5d5..166610f 100644
--- a/src/OpenGL ES 2.0/compiler/glslang.l
+++ b/src/OpenGL ES 2.0/compiler/glslang.l
@@ -1,6 +1,6 @@
 /*
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -9,18 +9,30 @@
 Based on ANSI C grammar, Lex specification:
 http://www.lysator.liu.se/c/ANSI-C-grammar-l.html
 
-IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_glslang_lexer.sh,
+IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh,
 WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp).
 */
 
 %top{
 //
-// Copyright (c) 2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 
-// This file is auto-generated by generate_glslang_lexer.sh. DO NOT EDIT!
+// This file is auto-generated by generate_parser.sh. DO NOT EDIT!
+
+// Ignore errors in auto-generated code.
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#elif defined(_MSC_VER)
+#pragma warning(disable: 4065)
+#pragma warning(disable: 4189)
+#pragma warning(disable: 4505)
+#pragma warning(disable: 4701)
+#endif
 }
 
 %{
@@ -145,6 +157,7 @@
 "extern"       { return reserved_word(yyscanner); }
 "external"     { return reserved_word(yyscanner); }
 "interface"    { return reserved_word(yyscanner); }
+"flat"         { return reserved_word(yyscanner); }
 
 "long"         { return reserved_word(yyscanner); }
 "short"        { return reserved_word(yyscanner); }
@@ -152,6 +165,7 @@
 "half"         { return reserved_word(yyscanner); }
 "fixed"        { return reserved_word(yyscanner); }
 "unsigned"     { return reserved_word(yyscanner); }
+"superp"       { return reserved_word(yyscanner); }
 
 "input"        { return reserved_word(yyscanner); }
 "output"       { return reserved_word(yyscanner); }
@@ -159,12 +173,22 @@
 "hvec2"        { return reserved_word(yyscanner); }
 "hvec3"        { return reserved_word(yyscanner); }
 "hvec4"        { return reserved_word(yyscanner); }
-"fvec2"        { return reserved_word(yyscanner); }
-"fvec3"        { return reserved_word(yyscanner); }
-"fvec4"        { return reserved_word(yyscanner); }
 "dvec2"        { return reserved_word(yyscanner); }
 "dvec3"        { return reserved_word(yyscanner); }
 "dvec4"        { return reserved_word(yyscanner); }
+"fvec2"        { return reserved_word(yyscanner); }
+"fvec3"        { return reserved_word(yyscanner); }
+"fvec4"        { return reserved_word(yyscanner); }
+
+"sampler1D"    { return reserved_word(yyscanner); }
+"sampler3D"    { return reserved_word(yyscanner); }
+
+"sampler1DShadow" { return reserved_word(yyscanner); }
+"sampler2DShadow" { return reserved_word(yyscanner); }
+
+"sampler2DRect" { return reserved_word(yyscanner); }
+"sampler3DRect" { return reserved_word(yyscanner); }
+"sampler2DRectShadow" { return reserved_word(yyscanner); }
 
 "sizeof"       { return reserved_word(yyscanner); }
 "cast"         { return reserved_word(yyscanner); }
@@ -480,6 +504,8 @@
                 msg = TString("extension '") + extName + "' is not supported";
                 context->infoSink.info.message(EPrefixWarning, msg.c_str(), yylineno); 
                 break;
+            default:
+                break;
             }
             return;
         } else
diff --git a/src/OpenGL ES 2.0/compiler/glslang.y b/src/OpenGL ES 2.0/compiler/glslang.y
index b6fa163..69c35e7 100644
--- a/src/OpenGL ES 2.0/compiler/glslang.y
+++ b/src/OpenGL ES 2.0/compiler/glslang.y
@@ -129,7 +129,7 @@
 %type <interm.intermNode> declaration external_declaration
 %type <interm.intermNode> for_init_statement compound_statement_no_new_scope
 %type <interm.nodePair> selection_rest_statement for_rest_statement
-%type <interm.intermNode> iteration_statement jump_statement statement_no_new_scope
+%type <interm.intermNode> iteration_statement jump_statement statement_no_new_scope statement_with_scope
 %type <interm> single_declaration init_declarator_list
 
 %type <interm> parameter_declaration parameter_declarator parameter_type_specifier
@@ -975,6 +975,8 @@
         
         prototype->setOp(EOpPrototype);
         $$ = prototype;
+
+		context->symbolTable.pop();
     }
     | init_declarator_list SEMICOLON {
         if ($1.intermAggregate)
@@ -1019,7 +1021,9 @@
         $$.function = $1;
         $$.line = $2.line;
 
-        context->symbolTable.insert(*$$.function);
+        // We're at the inner scope level of the function's arguments and body statement.
+        // Add the function prototype to the surrounding scope instead.
+        context->symbolTable.getOuterLevel()->insert(*$$.function);
     }
     ;
 
@@ -1077,6 +1081,8 @@
         TType type($1);
         function = new TFunction($2.string, type);
         $$ = function;
+
+		context->symbolTable.push();
     }
     ;
 
@@ -1185,6 +1191,12 @@
         }
     }
     | init_declarator_list COMMA IDENTIFIER {
+        if ($1.type.type == EbtInvariant && !$3.symbol)
+        {
+            context->error($3.line, "undeclared identifier declared as invariant", $3.string->c_str(), "");
+            context->recover();
+        }
+
         TIntermSymbol* symbol = context->intermediate.addSymbol(0, *$3.string, TType($1.type), $3.line);
         $$.intermAggregate = context->intermediate.growAggregate($1.intermNode, symbol, $3.line);
         
@@ -1349,8 +1361,21 @@
     }
     | INVARIANT IDENTIFIER {
         VERTEX_ONLY("invariant declaration", $1.line);
-        $$.qualifier = EvqInvariantVaryingOut;
-        $$.intermAggregate = 0;
+        if (context->globalErrorCheck($1.line, context->symbolTable.atGlobalLevel(), "invariant varying"))
+            context->recover();
+        $$.type.setBasic(EbtInvariant, EvqInvariantVaryingOut, $2.line);
+        if (!$2.symbol)
+        {
+            context->error($2.line, "undeclared identifier declared as invariant", $2.string->c_str(), "");
+            context->recover();
+            
+            $$.intermAggregate = 0;
+        }
+        else
+        {
+            TIntermSymbol *symbol = context->intermediate.addSymbol(0, *$2.string, TType($$.type), $2.line);
+            $$.intermAggregate = context->intermediate.makeAggregate(symbol, $2.line);
+        }
     }
 
 //
@@ -1782,6 +1807,11 @@
     | simple_statement                { $$ = $1; }
     ;
 
+statement_with_scope
+    : { context->symbolTable.push(); } compound_statement_no_new_scope { context->symbolTable.pop(); $$ = $2; }
+    | { context->symbolTable.push(); } simple_statement                { context->symbolTable.pop(); $$ = $2; }
+    ;
+
 compound_statement_no_new_scope
     // Statement that doesn't create a new scope, for selection_statement, iteration_statement
     : LEFT_BRACE RIGHT_BRACE {
@@ -1819,11 +1849,11 @@
     ;
 
 selection_rest_statement
-    : statement ELSE statement {
+    : statement_with_scope ELSE statement_with_scope {
         $$.node1 = $1;
         $$.node2 = $3;
     }
-    | statement {
+    | statement_with_scope {
         $$.node1 = $1;
         $$.node2 = 0;
     }
@@ -1860,7 +1890,7 @@
         $$ = context->intermediate.addLoop(ELoopWhile, 0, $4, 0, $6, $1.line);
         --context->loopNestingLevel;
     }
-    | DO { ++context->loopNestingLevel; } statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON {
+    | DO { ++context->loopNestingLevel; } statement_with_scope WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON {
         if (context->boolErrorCheck($8.line, $6))
             context->recover();
 
@@ -1997,11 +2027,6 @@
         }
 
         //
-        // New symbol table scope for body of function plus its arguments
-        //
-        context->symbolTable.push();
-
-        //
         // Remember the return type for later checking for RETURN statements.
         //
         context->currentFunctionType = &(prevDec->getReturnType());
@@ -2053,7 +2078,7 @@
             context->error($1.line, "function does not return a value:", "", $1.function->getName().c_str());
             context->recover();
         }
-        context->symbolTable.pop();
+        
         $$ = context->intermediate.growAggregate($1.intermAggregate, $3, 0);
         context->intermediate.setAggregateOperator($$, EOpFunction, $1.line);
         $$->getAsAggregate()->setName($1.function->getMangledName().c_str());
@@ -2067,6 +2092,8 @@
 
         if ($3 && $3->getAsAggregate())
             $$->getAsAggregate()->setEndLine($3->getAsAggregate()->getEndLine());
+
+		context->symbolTable.pop();
     }
     ;
 
diff --git a/src/OpenGL ES 2.0/compiler/glslang_lex.cpp b/src/OpenGL ES 2.0/compiler/glslang_lex.cpp
index 9d5f53f..19acca5 100644
--- a/src/OpenGL ES 2.0/compiler/glslang_lex.cpp
+++ b/src/OpenGL ES 2.0/compiler/glslang_lex.cpp
@@ -1,15 +1,27 @@
-#line 17 "compiler/glslang.l"
+#line 17 "./glslang.l"
 //
-// Copyright (c) 2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 
-// This file is auto-generated by generate_glslang_lexer.sh. DO NOT EDIT!
+// This file is auto-generated by generate_parser.sh. DO NOT EDIT!
+
+// Ignore errors in auto-generated code.
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#elif defined(_MSC_VER)
+#pragma warning(disable: 4065)
+#pragma warning(disable: 4189)
+#pragma warning(disable: 4505)
+#pragma warning(disable: 4701)
+#endif
 
 
 
-#line 13 "compiler/glslang_lex.cpp"
+#line 25 "./glslang_lex.cpp"
 
 #define  YY_INT_ALIGNED short int
 
@@ -371,8 +383,8 @@
 	*yy_cp = '\0'; \
 	yyg->yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 145
-#define YY_END_OF_BUFFER 146
+#define YY_NUM_RULES 154
+#define YY_END_OF_BUFFER 155
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -380,53 +392,57 @@
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static yyconst flex_int16_t yy_accept[411] =
+static yyconst flex_int16_t yy_accept[448] =
     {   0,
-        0,    0,    0,    0,    0,    0,  146,  144,  143,  143,
-      128,  134,  139,  123,  124,  132,  131,  120,  129,  127,
-      133,   92,   92,  121,  117,  135,  122,  136,  140,   88,
-      125,  126,  138,   88,   88,   88,   88,   88,   88,   88,
-       88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
-       88,   88,   88,  118,  137,  119,  130,    3,    4,    3,
-      142,  145,  141,  114,  100,  119,  108,  103,   98,  106,
-       96,  107,   97,   95,    2,    1,   99,   94,   90,   91,
-        0,    0,   92,  126,  118,  125,  115,  111,  113,  112,
-      116,   88,  104,  110,   88,   88,   88,   88,   88,   88,
+        0,    0,    0,    0,    0,    0,  155,  153,  152,  152,
+      137,  143,  148,  132,  133,  141,  140,  129,  138,  136,
+      142,  101,  101,  130,  126,  144,  131,  145,  149,   97,
+      134,  135,  147,   97,   97,   97,   97,   97,   97,   97,
+       97,   97,   97,   97,   97,   97,   97,   97,   97,   97,
+       97,   97,   97,  127,  146,  128,  139,    3,    4,    3,
+      151,  154,  150,  123,  109,  128,  117,  112,  107,  115,
+      105,  116,  106,  104,    2,    1,  108,  103,   99,  100,
+        0,    0,  101,  135,  127,  134,  124,  120,  122,  121,
+      125,   97,  113,  119,   97,   97,   97,   97,   97,   97,
 
-       88,   88,   88,   88,   17,   88,   88,   88,   88,   88,
-       88,   88,   88,   88,   88,   88,   88,   88,   20,   22,
-       88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
-       88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
-       88,   88,   88,   88,   88,   88,  105,  109,    5,  141,
-        0,    1,   94,    0,    0,   93,   89,  101,  102,   48,
-       88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
-       88,   88,   88,   88,   88,   88,   88,   18,   88,   88,
-       88,   88,   88,   88,   88,   88,   26,   88,   88,   88,
-       88,   88,   88,   88,   88,   23,   88,   88,   88,   88,
+       97,   97,   97,   97,   17,   97,   97,   97,   97,   97,
+       97,   97,   97,   97,   97,   97,   97,   97,   20,   22,
+       97,   97,   97,   97,   97,   97,   97,   97,   97,   97,
+       97,   97,   97,   97,   97,   97,   97,   97,   97,   97,
+       97,   97,   97,   97,   97,   97,   97,  114,  118,    5,
+      150,    0,    1,  103,    0,    0,  102,   98,  110,  111,
+       48,   97,   97,   97,   97,   97,   97,   97,   97,   97,
+       97,   97,   97,   97,   97,   97,   97,   97,   97,   18,
+       97,   97,   97,   97,   97,   97,   97,   97,   26,   97,
+       97,   97,   97,   97,   97,   97,   97,   23,   97,   97,
 
-       88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
-       88,   88,   88,   88,   88,   88,   88,   88,    0,   95,
-        0,   94,   88,   28,   88,   88,   85,   88,   88,   88,
-       88,   88,   88,   88,   21,   51,   88,   88,   88,   88,
-       88,   56,   70,   88,   88,   88,   88,   88,   88,   88,
-       88,   67,    9,   33,   34,   35,   88,   88,   88,   88,
-       88,   88,   88,   88,   88,   88,   88,   88,   88,   88,
-       88,   54,   29,   88,   88,   88,   88,   88,   88,   36,
-       37,   38,   27,   88,   88,   88,   15,   42,   43,   44,
-       49,   12,   88,   88,   88,   88,   81,   82,   83,   88,
+       97,   97,   97,   97,   97,   97,   97,   97,   97,   97,
+       97,   97,   97,   97,   97,   97,   97,   97,   97,   97,
+       97,    0,  104,    0,  103,   97,   28,   97,   97,   94,
+       97,   97,   97,   97,   97,   97,   97,   21,   51,   97,
+       97,   97,   67,   97,   97,   56,   71,   97,   97,   97,
+       97,   97,   97,   97,   97,   68,    9,   33,   34,   35,
+       97,   97,   97,   97,   97,   97,   97,   97,   97,   97,
+       97,   97,   97,   97,   97,   97,   54,   29,   97,   97,
+       97,   97,   97,   97,   36,   37,   38,   27,   97,   97,
+       97,   15,   42,   43,   44,   49,   12,   97,   97,   97,
 
-       30,   71,   25,   78,   79,   80,    7,   75,   76,   77,
-       88,   24,   73,   88,   88,   39,   40,   41,   88,   88,
-       88,   88,   88,   88,   88,   88,   88,   68,   88,   88,
-       88,   88,   88,   88,   88,   50,   88,   87,   88,   88,
-       19,   88,   88,   88,   88,   69,   64,   59,   88,   88,
-       88,   88,   88,   74,   55,   88,   62,   32,   88,   84,
-       63,   47,   57,   88,   88,   88,   88,   88,   88,   88,
-       88,   58,   31,   88,   88,   88,    8,   88,   88,   88,
-       88,   88,   52,   13,   88,   14,   88,   88,   16,   65,
-       88,   88,   88,   60,   88,   88,   88,   53,   72,   61,
+       97,   80,   81,   82,   97,   30,   72,   25,   83,   84,
+       85,    7,   77,   78,   79,   97,   24,   75,   97,   97,
+       39,   40,   41,   97,   97,   97,   97,   97,   97,   97,
+       97,   97,   69,   97,   97,   97,   97,   97,   97,   97,
+       97,   50,   97,   96,   97,   97,   19,   97,   97,   97,
+       97,   70,   64,   59,   97,   97,   97,   97,   97,   76,
+       55,   97,   62,   32,   97,   93,   63,   47,   74,   57,
+       97,   97,   97,   97,   97,   97,   97,   97,   58,   31,
+       97,   97,   97,    8,   97,   97,   97,   97,   97,   52,
+       13,   97,   14,   97,   97,   16,   65,   97,   97,   97,
 
-       11,   66,    6,   86,   10,   45,   88,   88,   46,    0
+       60,   97,   97,   97,   97,   97,   53,   73,   61,   11,
+       66,    6,   95,   10,   86,   45,   87,   97,   97,   97,
+       97,   97,   97,   97,   97,   97,   97,   46,   97,   97,
+       97,   97,   97,   90,   97,   91,   97,   97,   97,   88,
+       97,   89,   97,   97,   97,   92,    0
     } ;
 
 static yyconst flex_int32_t yy_ec[256] =
@@ -436,15 +452,15 @@
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    2,    4,    1,    1,    1,    5,    6,    1,    7,
         8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
-       18,   19,   16,   16,   16,   20,   20,   21,   22,   23,
-       24,   25,   26,    1,   27,   27,   28,   29,   30,   27,
-       31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
-       31,   31,   31,   31,   31,   31,   31,   32,   31,   31,
-       33,    1,   34,   35,   31,    1,   36,   37,   38,   39,
+       18,   19,   20,   20,   20,   21,   21,   22,   23,   24,
+       25,   26,   27,    1,   28,   28,   29,   30,   31,   28,
+       32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
+       32,   33,   34,   32,   32,   32,   32,   35,   32,   32,
+       36,    1,   37,   38,   32,    1,   39,   40,   41,   42,
 
-       40,   41,   42,   43,   44,   31,   45,   46,   47,   48,
-       49,   50,   31,   51,   52,   53,   54,   55,   56,   57,
-       58,   59,   60,   61,   62,   63,    1,    1,    1,    1,
+       43,   44,   45,   46,   47,   32,   48,   49,   50,   51,
+       52,   53,   32,   54,   55,   56,   57,   58,   59,   60,
+       61,   62,   63,   64,   65,   66,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -461,195 +477,209 @@
         1,    1,    1,    1,    1
     } ;
 
-static yyconst flex_int32_t yy_meta[64] =
+static yyconst flex_int32_t yy_meta[67] =
     {   0,
         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    3,    3,    3,    3,    3,    3,
-        1,    1,    1,    1,    1,    1,    3,    3,    3,    3,
-        4,    4,    1,    1,    1,    3,    3,    3,    3,    3,
-        3,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        4,    4,    4,    4,    4,    4,    4,    4,    4,    1,
-        1,    1,    1
+        1,    1,    3,    1,    4,    4,    4,    4,    4,    4,
+        4,    1,    1,    1,    1,    1,    1,    5,    5,    5,
+        4,    6,    6,    6,    6,    1,    1,    1,    5,    5,
+        5,    5,    4,    5,    6,    6,    6,    6,    6,    6,
+        6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
+        6,    6,    1,    1,    1,    1
     } ;
 
-static yyconst flex_int16_t yy_base[416] =
+static yyconst flex_int16_t yy_base[455] =
     {   0,
-        0,    0,   61,   62,   71,    0,  606,  607,  607,  607,
-      581,   42,  129,  607,  607,  580,  126,  607,  125,  123,
-      137,  149,  157,  578,  607,  175,  578,   44,  607,    0,
-      607,  607,  120,   95,  103,  142,  146,  136,  156,  552,
-      168,  162,  551,  120,  158,  545,  173,  558,  172,  178,
-      111,  186,  554,  607,  159,  607,  607,  607,  607,  582,
-      607,  607,    0,  607,  607,  607,  607,  607,  607,  607,
-      607,  607,  607,  222,  607,    0,  607,  228,  254,  262,
-      281,    0,  290,  607,  607,  607,  571,  607,  607,  607,
-      570,    0,  607,  607,  546,  539,  542,  550,  549,  536,
+        0,    0,   64,   65,   74,    0,  649,  650,  650,  650,
+      623,   44,  135,  650,  650,  622,  132,  650,  131,  129,
+      144,  157,  148,  620,  650,  158,  620,   46,  650,    0,
+      650,  650,  126,   99,  113,  145,  138,  138,  154,  592,
+      160,  108,  591,  165,  163,  585,  156,  598,  175,  181,
+      154,  177,  594,  650,  161,  650,  650,  650,  650,  625,
+      650,  650,    0,  650,  650,  650,  650,  650,  650,  650,
+      650,  650,  650,  228,  650,    0,  650,  235,  176,  226,
+      264,    0,  227,  650,  650,  650,  613,  650,  650,  650,
+      612,    0,  650,  650,  586,  579,  582,  590,  589,  576,
 
-      551,  538,  544,  532,  529,  542,  529,  526,  526,  532,
-      520,  527,  524,  534,  520,  526,  529,  530,    0,  204,
-      529,  207,  515,  528,  519,  521,  511,  525,  522,  524,
-      507,  512,  509,  498,  183,  512,  508,  510,  499,  502,
-      212,  507,  499,  511,  186,  504,  607,  607,  607,    0,
-      306,    0,  316,  332,  270,  342,    0,  607,  607,    0,
-      496,  500,  509,  506,  490,  490,  161,  505,  502,  502,
-      500,  497,  489,  495,  482,  493,  496,    0,  493,  481,
-      488,  485,  489,  482,  471,  470,  483,  486,  483,  478,
-      469,  294,  474,  477,  468,  465,  469,  475,  466,  457,
+      591,  578,  584,  572,  569,  582,  569,  566,  566,  572,
+      560,  189,  565,  575,  561,  567,  570,  571,    0,  237,
+      570,  179,  556,  569,  560,  562,  552,  566,  563,  565,
+      548,  553,  550,  539,  221,  547,  552,  548,  550,  539,
+      542,  217,  547,  539,  551,  214,  544,  650,  650,  650,
+        0,  282,    0,  289,  306,  318,  325,    0,  650,  650,
+        0,  536,  540,  549,  546,  530,  530,  212,  545,  542,
+      542,  540,  537,  529,  535,  522,  533,  519,  535,    0,
+      532,  520,  527,  524,  528,  521,  510,  509,  522,  525,
+      522,  517,  508,  294,  513,  516,  507,  504,  508,  514,
 
-      460,  458,  468,  454,  452,  452,  454,  451,  462,  461,
-      278,  456,  451,  440,  320,  458,  460,  449,  348,  354,
-      360,  366,  450,    0,  448,  336,    0,  440,  438,  446,
-      435,  452,  441,  370,    0,    0,  435,  445,  445,  430,
-      373,    0,    0,  432,  376,  433,  427,  426,  427,  426,
-      379,    0,    0,    0,    0,    0,  422,  423,  428,  419,
-      432,  427,  426,  418,  422,  414,  417,  421,  426,  425,
-      416,    0,    0,  422,  411,  411,  416,  415,  412,    0,
-        0,    0,    0,  402,  414,  416,    0,    0,    0,    0,
-        0,    0,  404,  405,  399,  409,    0,    0,    0,  400,
+      505,  496,  499,  497,  507,  493,  491,  504,  490,  492,
+      489,  500,  499,  221,  494,  489,  478,  311,  496,  498,
+      487,  332,  339,  346,  353,  488,    0,  486,  358,    0,
+      478,  476,  484,  473,  490,  479,  361,    0,    0,  473,
+      483,  483,    0,  468,  364,    0,    0,  470,  367,  471,
+      465,  464,  465,  464,  370,    0,    0,    0,    0,    0,
+      460,  461,  466,  457,  470,  465,  464,  456,  460,  452,
+      455,  459,  464,  450,  462,  453,    0,    0,  459,  448,
+      448,  453,  452,  449,    0,    0,    0,    0,  439,  451,
+      453,    0,    0,    0,    0,    0,    0,  441,  442,  436,
 
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-      407,    0,    0,  405,  401,    0,    0,    0,  397,  393,
-      398,  388,  401,  387,  400,  389,  396,    0,  394,  396,
-      380,  389,  395,  390,  378,    0,  380,    0,  379,  382,
-        0,  371,  370,  370,  383,    0,  385,    0,  384,  383,
-      368,  381,  368,    0,    0,  371,    0,    0,  363,    0,
-        0,    0,    0,  360,  371,  364,  368,  303,  297,  288,
-      300,    0,    0,  283,  290,  269,    0,  277,  274,  255,
-      232,  255,    0,    0,  244,    0,  236,  226,    0,    0,
-      225,  208,  211,    0,  185,  202,  131,    0,    0,    0,
+      446,    0,    0,    0,  437,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,  444,    0,    0,  442,  438,
+        0,    0,    0,  434,  430,  435,  425,  438,  424,  437,
+      426,  433,    0,  431,  433,  417,  419,  425,  431,  426,
+      414,    0,  416,    0,  415,  418,    0,  407,  406,  406,
+      419,    0,  421,    0,  420,  419,  404,  417,  404,    0,
+        0,  407,    0,    0,  399,    0,    0,    0,    0,    0,
+      396,  407,  400,  406,  403,  398,  390,  402,    0,    0,
+      395,  402,  391,    0,  400,  397,  387,  374,  395,    0,
+        0,  395,    0,  393,  392,    0,    0,  391,  377,  389,
 
-        0,    0,    0,    0,    0,    0,  134,  117,    0,  607,
-      398,  400,  402,  406,  142
+        0,  380,  400,  399,  398,  362,    0,    0,    0,    0,
+        0,    0,    0,    0,  368,  254,  368,  360,  353,  355,
+      351,  353,  352,  355,  352,  292,  278,    0,  275,  259,
+      272,  240,  239,  243,  210,    0,  178,  187,  167,    0,
+      184,    0,  177,  116,  103,    0,  650,  403,  407,  408,
+      411,  417,  421,  422
     } ;
 
-static yyconst flex_int16_t yy_def[416] =
+static yyconst flex_int16_t yy_def[455] =
     {   0,
-      410,    1,  411,  411,  410,    5,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  412,
-      410,  410,  410,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  413,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  414,  410,  410,  410,  410,
-      410,  415,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  412,  410,  410,  412,  412,  412,  412,  412,  412,
+      447,    1,  448,  448,  447,    5,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  449,  447,  447,  447,  447,  447,  447,  450,
+      447,  447,  447,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  451,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  452,  447,  447,   22,  453,
+      447,  454,  449,  447,  447,  447,  447,  447,  447,  447,
+      447,  450,  447,  447,  450,  450,  450,  450,  450,  450,
 
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  410,  410,  410,  413,
-      410,  414,  410,  410,  410,  410,  415,  410,  410,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  447,  447,  447,
+      451,  447,  452,  447,  447,  447,  447,  454,  447,  447,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
 
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  410,  410,
-      410,  410,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  447,  447,  447,  447,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
 
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  412,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
 
-      412,  412,  412,  412,  412,  412,  412,  412,  412,    0,
-      410,  410,  410,  410,  410
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  450,    0,  447,  447,  447,
+      447,  447,  447,  447
     } ;
 
-static yyconst flex_int16_t yy_nxt[671] =
+static yyconst flex_int16_t yy_nxt[717] =
     {   0,
         8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
        18,   19,   20,   21,   22,   23,   23,   23,   23,   23,
-       24,   25,   26,   27,   28,   29,   30,   30,   30,   30,
-       30,   30,   31,   32,   33,   34,   35,   36,   37,   38,
-       39,   40,   41,   42,   30,   43,   44,   45,   46,   47,
-       48,   49,   50,   51,   52,   53,   30,   30,   30,   54,
-       55,   56,   57,   59,   59,   65,   66,   90,   91,   60,
-       60,    8,   61,   62,    8,    8,    8,    8,    8,    8,
+       23,   24,   25,   26,   27,   28,   29,   30,   30,   30,
+       30,   30,   30,   30,   30,   31,   32,   33,   34,   35,
+       36,   37,   38,   39,   40,   41,   42,   30,   43,   44,
+       45,   46,   47,   48,   49,   50,   51,   52,   53,   30,
+       30,   30,   54,   55,   56,   57,   59,   59,   65,   66,
+       90,   91,   60,   60,    8,   61,   62,    8,    8,    8,
         8,    8,    8,    8,    8,    8,    8,    8,    8,    8,
-        8,    8,    8,    8,    8,    8,    8,   63,   63,   63,
+        8,    8,    8,    8,    8,    8,    8,    8,    8,    8,
 
-       63,   63,   63,    8,    8,    8,   63,   63,   63,   63,
+        8,   63,   63,   63,   63,   63,   63,   63,   63,    8,
+        8,    8,   63,   63,   63,   63,   63,   63,   63,   63,
        63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
-       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
-        8,    8,    8,    8,   67,   70,   72,   74,   74,   74,
-       74,   74,   74,   93,  157,   75,   95,   96,   73,   71,
-       76,   97,   68,   98,   94,  123,  409,   99,  141,  124,
-       77,   78,  142,   79,   79,   79,   79,   79,   80,   78,
-      408,   83,   83,   83,   83,   83,   83,  100,   81,   85,
-       82,  107,  147,  108,  407,  103,   81,  101,   81,  104,
-      102,  110,  109,  125,  105,   86,   81,   87,   88,  111,
+       63,   63,   63,   63,   63,   63,    8,    8,    8,    8,
+       67,   70,   72,   74,   74,   74,   74,   74,   74,   74,
+       93,  119,   75,   95,   96,   73,   71,   76,  120,   68,
+       78,  446,   85,   94,   97,  121,   98,  445,   77,   78,
+       99,   79,   79,   79,   79,   79,   79,   80,   81,   86,
+      103,   87,   88,  100,  104,  148,  107,   81,  108,  105,
+       81,   82,  110,  101,  128,  106,  102,  109,  116,   81,
 
-      106,  112,  119,  116,  113,   82,  126,  132,  128,  120,
-      114,  117,  229,  230,  133,  134,  121,  137,  204,  148,
-      138,  143,  118,  129,  135,  144,  130,  136,  139,  216,
-      406,  217,  405,  205,  145,  140,   74,   74,   74,   74,
-       74,   74,  153,  153,  153,  153,  153,  153,  396,  184,
-      404,  151,  185,  186,  190,  211,  187,  154,  188,  397,
-      403,  151,  191,  212,  402,  401,   78,  154,   79,   79,
-       79,   79,   79,   80,   78,  400,   80,   80,   80,   80,
-       80,   80,  399,   81,  156,  156,  156,  156,  156,  156,
-      155,   81,  155,   81,  398,  156,  156,  156,  156,  156,
+      111,  125,  112,  123,  142,  113,  117,  124,  143,  129,
+      447,  114,  130,  132,  126,  144,   82,  118,  444,  145,
+      133,  134,  443,  138,  149,  442,  139,  178,  146,  192,
+      135,  136,  441,  137,  140,  447,  440,  193,   78,   78,
+      179,  141,   74,   74,   74,   74,   74,   74,   74,  154,
+      154,  154,  154,  154,  154,  154,   81,   81,  152,  206,
+      219,  439,  220,  214,  280,  155,  232,  233,   81,   81,
+      152,  215,  281,  156,  207,  156,  438,  155,  157,  157,
+      157,  157,  157,  157,  157,  186,  420,  421,  187,  188,
+      437,  222,  189,  222,  190,  436,  223,  223,  223,  223,
 
-      156,   81,   78,  395,   83,   83,   83,   83,   83,   83,
-      254,  255,  256,  394,  393,  219,  392,  219,  275,   81,
-      220,  220,  220,  220,  220,  220,  276,  391,  390,   81,
-      153,  153,  153,  153,  153,  153,  280,  281,  282,  389,
-      388,  221,  387,  221,  386,  154,  222,  222,  222,  222,
-      222,  222,  288,  289,  290,  154,  156,  156,  156,  156,
-      156,  156,  220,  220,  220,  220,  220,  220,  220,  220,
-      220,  220,  220,  220,  222,  222,  222,  222,  222,  222,
-      222,  222,  222,  222,  222,  222,  297,  298,  299,  304,
-      305,  306,  308,  309,  310,  316,  317,  318,   58,   58,
+      223,  223,  223,  154,  154,  154,  154,  154,  154,  154,
+      258,  259,  260,  435,  434,  224,  433,  224,  432,  155,
+      225,  225,  225,  225,  225,  225,  225,  285,  286,  287,
+      431,  155,  157,  157,  157,  157,  157,  157,  157,  157,
+      157,  157,  157,  157,  157,  157,  223,  223,  223,  223,
+      223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
+      225,  225,  225,  225,  225,  225,  225,  225,  225,  225,
+      225,  225,  225,  225,  293,  294,  295,  302,  303,  304,
+      309,  310,  311,  313,  314,  315,  321,  322,  323,  403,
+      404,  405,  430,  429,  428,  427,  426,  425,  424,  423,
 
-       58,   58,   92,   92,  150,  150,  152,  385,  152,  152,
-      384,  383,  382,  381,  380,  379,  378,  377,  376,  375,
-      374,  373,  372,  371,  370,  369,  368,  367,  366,  365,
-      364,  363,  362,  361,  360,  359,  358,  357,  356,  355,
-      354,  353,  352,  351,  350,  349,  348,  347,  346,  345,
-      344,  343,  342,  341,  340,  339,  338,  337,  336,  335,
-      334,  333,  332,  331,  330,  329,  328,  327,  326,  325,
-      324,  323,  322,  321,  320,  319,  315,  314,  313,  312,
-      311,  307,  303,  302,  301,  300,  296,  295,  294,  293,
-      292,  291,  287,  286,  285,  284,  283,  279,  278,  277,
+      422,  419,  406,   58,   58,   58,   58,   58,   58,   83,
+       83,   92,   92,   92,  151,  151,  151,  153,  418,  153,
+      153,  153,  153,   80,   80,  158,  158,  417,  416,  415,
+      414,  413,  412,  411,  410,  409,  408,  407,  402,  401,
+      400,  399,  398,  397,  396,  395,  394,  393,  392,  391,
+      390,  389,  388,  387,  386,  385,  384,  383,  382,  381,
+      380,  379,  378,  377,  376,  375,  374,  373,  372,  371,
+      370,  369,  368,  367,  366,  365,  364,  363,  362,  361,
+      360,  359,  358,  357,  356,  355,  354,  353,  352,  351,
+      350,  349,  348,  347,  346,  345,  344,  343,  342,  341,
 
-      274,  273,  272,  271,  270,  269,  268,  267,  266,  265,
-      264,  263,  262,  261,  260,  259,  258,  257,  253,  252,
-      251,  250,  249,  248,  247,  246,  245,  244,  243,  242,
-      241,  240,  239,  238,  237,  236,  235,  234,  233,  232,
-      231,  228,  227,  226,  225,  224,  223,  218,  215,  214,
-      213,  210,  209,  208,  207,  206,  203,  202,  201,  200,
-      199,  198,  197,  196,  195,  194,  193,  192,  189,  183,
-      182,  181,  180,  179,  178,  177,  176,  175,  174,  173,
-      172,  171,  170,  169,  168,  167,  166,  165,  164,  163,
-      162,  161,  160,  159,  158,  149,  146,  131,  127,  122,
+      340,  339,  338,  337,  336,  335,  334,  333,  332,  331,
+      330,  329,  328,  327,  326,  325,  324,  320,  319,  318,
+      317,  316,  312,  308,  307,  306,  305,  301,  300,  299,
+      298,  297,  296,  292,  291,  290,  289,  288,  284,  283,
+      282,  279,  278,  277,  276,  275,  274,  273,  272,  271,
+      270,  269,  268,  267,  266,  265,  264,  263,  262,  261,
+      257,  256,  255,  254,  253,  252,  251,  250,  249,  248,
+      247,  246,  245,  244,  243,  242,  241,  240,  239,  238,
+      237,  236,  235,  234,  231,  230,  229,  228,  227,  226,
+      221,  218,  217,  216,  213,  212,  211,  210,  209,  208,
 
-      115,   89,   84,   69,   64,  410,    7,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410
+      205,  204,  203,  202,  201,  200,  199,  198,  197,  196,
+      195,  194,  191,  185,  184,  183,  182,  181,  180,  177,
+      176,  175,  174,  173,  172,  171,  170,  169,  168,  167,
+      166,  165,  164,  163,  162,  161,  160,  159,  150,  147,
+      131,  127,  122,  115,   89,   84,   69,   64,  447,    7,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447
     } ;
 
-static yyconst flex_int16_t yy_chk[671] =
+static yyconst flex_int16_t yy_chk[717] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -657,77 +687,83 @@
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    3,    4,   12,   12,   28,   28,    3,
-        4,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+        1,    1,    1,    1,    1,    1,    3,    4,   12,   12,
+       28,   28,    3,    4,    5,    5,    5,    5,    5,    5,
         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 
         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,   13,   17,   19,   20,   20,   20,
-       20,   20,   20,   33,  415,   21,   34,   34,   19,   17,
-       21,   35,   13,   35,   33,   44,  408,   35,   51,   44,
-       21,   22,   51,   22,   22,   22,   22,   22,   22,   23,
-      407,   23,   23,   23,   23,   23,   23,   36,   22,   26,
-       22,   38,   55,   38,  397,   37,   23,   36,   22,   37,
-       36,   39,   38,   45,   37,   26,   23,   26,   26,   39,
+        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+       13,   17,   19,   20,   20,   20,   20,   20,   20,   20,
+       33,   42,   21,   34,   34,   19,   17,   21,   42,   13,
+       23,  445,   26,   33,   35,   42,   35,  444,   21,   22,
+       35,   22,   22,   22,   22,   22,   22,   22,   23,   26,
+       37,   26,   26,   36,   37,   55,   38,   22,   38,   37,
+       23,   22,   39,   36,   47,   37,   36,   38,   41,   22,
 
-       37,   39,   42,   41,   39,   22,   45,   49,   47,   42,
-       39,   41,  167,  167,   49,   49,   42,   50,  135,   55,
-       50,   52,   41,   47,   49,   52,   47,   49,   50,  145,
-      396,  145,  395,  135,   52,   50,   74,   74,   74,   74,
-       74,   74,   78,   78,   78,   78,   78,   78,  381,  120,
-      393,   74,  120,  120,  122,  141,  120,   78,  120,  381,
-      392,   74,  122,  141,  391,  388,   79,   78,   79,   79,
-       79,   79,   79,   79,   80,  387,   80,   80,   80,   80,
-       80,   80,  385,   79,  155,  155,  155,  155,  155,  155,
-       81,   80,   81,   79,  382,   81,   81,   81,   81,   81,
+       39,   45,   39,   44,   51,   39,   41,   44,   51,   47,
+       79,   39,   47,   49,   45,   52,   22,   41,  443,   52,
+       49,   49,  441,   50,   55,  439,   50,  112,   52,  122,
+       49,   49,  438,   49,   50,   79,  437,  122,   80,   83,
+      112,   50,   74,   74,   74,   74,   74,   74,   74,   78,
+       78,   78,   78,   78,   78,   78,   80,   83,   74,  135,
+      146,  435,  146,  142,  214,   78,  168,  168,   80,   83,
+       74,  142,  214,   81,  135,   81,  434,   78,   81,   81,
+       81,   81,   81,   81,   81,  120,  416,  416,  120,  120,
+      433,  152,  120,  152,  120,  432,  152,  152,  152,  152,
 
-       81,   80,   83,  380,   83,   83,   83,   83,   83,   83,
-      192,  192,  192,  379,  378,  151,  376,  151,  211,   83,
-      151,  151,  151,  151,  151,  151,  211,  375,  374,   83,
-      153,  153,  153,  153,  153,  153,  215,  215,  215,  371,
-      370,  154,  369,  154,  368,  153,  154,  154,  154,  154,
-      154,  154,  226,  226,  226,  153,  156,  156,  156,  156,
-      156,  156,  219,  219,  219,  219,  219,  219,  220,  220,
-      220,  220,  220,  220,  221,  221,  221,  221,  221,  221,
-      222,  222,  222,  222,  222,  222,  234,  234,  234,  241,
-      241,  241,  245,  245,  245,  251,  251,  251,  411,  411,
+      152,  152,  152,  154,  154,  154,  154,  154,  154,  154,
+      194,  194,  194,  431,  430,  155,  429,  155,  427,  154,
+      155,  155,  155,  155,  155,  155,  155,  218,  218,  218,
+      426,  154,  156,  156,  156,  156,  156,  156,  156,  157,
+      157,  157,  157,  157,  157,  157,  222,  222,  222,  222,
+      222,  222,  222,  223,  223,  223,  223,  223,  223,  223,
+      224,  224,  224,  224,  224,  224,  224,  225,  225,  225,
+      225,  225,  225,  225,  229,  229,  229,  237,  237,  237,
+      245,  245,  245,  249,  249,  249,  255,  255,  255,  388,
+      388,  388,  425,  424,  423,  422,  421,  420,  419,  418,
 
-      411,  411,  412,  412,  413,  413,  414,  367,  414,  414,
-      366,  365,  364,  359,  356,  353,  352,  351,  350,  349,
-      347,  345,  344,  343,  342,  340,  339,  337,  335,  334,
-      333,  332,  331,  330,  329,  327,  326,  325,  324,  323,
-      322,  321,  320,  319,  315,  314,  311,  300,  296,  295,
-      294,  293,  286,  285,  284,  279,  278,  277,  276,  275,
-      274,  271,  270,  269,  268,  267,  266,  265,  264,  263,
-      262,  261,  260,  259,  258,  257,  250,  249,  248,  247,
-      246,  244,  240,  239,  238,  237,  233,  232,  231,  230,
-      229,  228,  225,  223,  218,  217,  216,  214,  213,  212,
+      417,  415,  388,  448,  448,  448,  448,  448,  448,  449,
+      449,  450,  450,  450,  451,  451,  451,  452,  406,  452,
+      452,  452,  452,  453,  453,  454,  454,  405,  404,  403,
+      402,  400,  399,  398,  395,  394,  392,  389,  387,  386,
+      385,  383,  382,  381,  378,  377,  376,  375,  374,  373,
+      372,  371,  365,  362,  359,  358,  357,  356,  355,  353,
+      351,  350,  349,  348,  346,  345,  343,  341,  340,  339,
+      338,  337,  336,  335,  334,  332,  331,  330,  329,  328,
+      327,  326,  325,  324,  320,  319,  316,  305,  301,  300,
+      299,  298,  291,  290,  289,  284,  283,  282,  281,  280,
 
-      210,  209,  208,  207,  206,  205,  204,  203,  202,  201,
-      200,  199,  198,  197,  196,  195,  194,  193,  191,  190,
-      189,  188,  187,  186,  185,  184,  183,  182,  181,  180,
-      179,  177,  176,  175,  174,  173,  172,  171,  170,  169,
-      168,  166,  165,  164,  163,  162,  161,  146,  144,  143,
-      142,  140,  139,  138,  137,  136,  134,  133,  132,  131,
-      130,  129,  128,  127,  126,  125,  124,  123,  121,  118,
-      117,  116,  115,  114,  113,  112,  111,  110,  109,  108,
-      107,  106,  105,  104,  103,  102,  101,  100,   99,   98,
-       97,   96,   95,   91,   87,   60,   53,   48,   46,   43,
+      279,  276,  275,  274,  273,  272,  271,  270,  269,  268,
+      267,  266,  265,  264,  263,  262,  261,  254,  253,  252,
+      251,  250,  248,  244,  242,  241,  240,  236,  235,  234,
+      233,  232,  231,  228,  226,  221,  220,  219,  217,  216,
+      215,  213,  212,  211,  210,  209,  208,  207,  206,  205,
+      204,  203,  202,  201,  200,  199,  198,  197,  196,  195,
+      193,  192,  191,  190,  189,  188,  187,  186,  185,  184,
+      183,  182,  181,  179,  178,  177,  176,  175,  174,  173,
+      172,  171,  170,  169,  167,  166,  165,  164,  163,  162,
+      147,  145,  144,  143,  141,  140,  139,  138,  137,  136,
 
-       40,   27,   24,   16,   11,    7,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410
+      134,  133,  132,  131,  130,  129,  128,  127,  126,  125,
+      124,  123,  121,  118,  117,  116,  115,  114,  113,  111,
+      110,  109,  108,  107,  106,  105,  104,  103,  102,  101,
+      100,   99,   98,   97,   96,   95,   91,   87,   60,   53,
+       48,   46,   43,   40,   27,   24,   16,   11,    7,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+
+      447,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+      447,  447,  447,  447,  447,  447
     } ;
 
 /* Table of booleans, true if rule could match eol. */
-static yyconst flex_int32_t yy_rule_can_match_eol[146] =
+static yyconst flex_int32_t yy_rule_can_match_eol[155] =
     {   0,
 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
@@ -736,7 +772,7 @@
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 1, 0, 0,     };
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,     };
 
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
@@ -747,7 +783,7 @@
 #define YY_RESTORE_YY_MORE_OFFSET
 /*
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -756,7 +792,7 @@
 Based on ANSI C grammar, Lex specification:
 http://www.lysator.liu.se/c/ANSI-C-grammar-l.html
 
-IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_glslang_lexer.sh,
+IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh,
 WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp).
 */
 
@@ -1062,13 +1098,13 @@
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 411 )
+				if ( yy_current_state >= 448 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			++yy_cp;
 			}
-		while ( yy_current_state != 410 );
+		while ( yy_current_state != 447 );
 		yy_cp = yyg->yy_last_accepting_cpos;
 		yy_current_state = yyg->yy_last_accepting_state;
 
@@ -1449,233 +1485,269 @@
 	YY_BREAK
 case 88:
 YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+	YY_BREAK
+case 89:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+	YY_BREAK
+case 90:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+	YY_BREAK
+case 91:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+	YY_BREAK
+case 92:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+	YY_BREAK
+case 93:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+	YY_BREAK
+case 94:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+	YY_BREAK
+case 95:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+	YY_BREAK
+case 96:
+YY_RULE_SETUP
+{ return reserved_word(yyscanner); }
+	YY_BREAK
+case 97:
+YY_RULE_SETUP
 {
    yylval->lex.string = NewPoolTString(yytext); 
    return check_type(yyscanner);
 }
 	YY_BREAK
-case 89:
-YY_RULE_SETUP
-{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
-	YY_BREAK
-case 90:
-YY_RULE_SETUP
-{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
-	YY_BREAK
-case 91:
-YY_RULE_SETUP
-{ context->error(yylineno, "Invalid Octal number.", yytext, "", ""); context->recover(); return 0;}
-	YY_BREAK
-case 92:
-YY_RULE_SETUP
-{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
-	YY_BREAK
-case 93:
-YY_RULE_SETUP
-{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
-	YY_BREAK
-case 94:
-YY_RULE_SETUP
-{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
-	YY_BREAK
-case 95:
-YY_RULE_SETUP
-{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
-	YY_BREAK
-case 96:
-YY_RULE_SETUP
-{  return(ADD_ASSIGN); }
-	YY_BREAK
-case 97:
-YY_RULE_SETUP
-{  return(SUB_ASSIGN); }
-	YY_BREAK
 case 98:
 YY_RULE_SETUP
-{  return(MUL_ASSIGN); }
+{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
 	YY_BREAK
 case 99:
 YY_RULE_SETUP
-{  return(DIV_ASSIGN); }
+{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
 	YY_BREAK
 case 100:
 YY_RULE_SETUP
-{  return(MOD_ASSIGN); }
+{ context->error(yylineno, "Invalid Octal number.", yytext, "", ""); context->recover(); return 0;}
 	YY_BREAK
 case 101:
 YY_RULE_SETUP
-{  return(LEFT_ASSIGN); }
+{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
 	YY_BREAK
 case 102:
 YY_RULE_SETUP
-{  return(RIGHT_ASSIGN); }
+{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
 	YY_BREAK
 case 103:
 YY_RULE_SETUP
-{  return(AND_ASSIGN); }
+{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
 	YY_BREAK
 case 104:
 YY_RULE_SETUP
-{  return(XOR_ASSIGN); }
+{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
 	YY_BREAK
 case 105:
 YY_RULE_SETUP
-{  return(OR_ASSIGN); }
+{  return(ADD_ASSIGN); }
 	YY_BREAK
 case 106:
 YY_RULE_SETUP
-{  return(INC_OP); }
+{  return(SUB_ASSIGN); }
 	YY_BREAK
 case 107:
 YY_RULE_SETUP
-{  return(DEC_OP); }
+{  return(MUL_ASSIGN); }
 	YY_BREAK
 case 108:
 YY_RULE_SETUP
-{  return(AND_OP); }
+{  return(DIV_ASSIGN); }
 	YY_BREAK
 case 109:
 YY_RULE_SETUP
-{  return(OR_OP); }
+{  return(MOD_ASSIGN); }
 	YY_BREAK
 case 110:
 YY_RULE_SETUP
-{  return(XOR_OP); }
+{  return(LEFT_ASSIGN); }
 	YY_BREAK
 case 111:
 YY_RULE_SETUP
-{  return(LE_OP); }
+{  return(RIGHT_ASSIGN); }
 	YY_BREAK
 case 112:
 YY_RULE_SETUP
-{  return(GE_OP); }
+{  return(AND_ASSIGN); }
 	YY_BREAK
 case 113:
 YY_RULE_SETUP
-{  return(EQ_OP); }
+{  return(XOR_ASSIGN); }
 	YY_BREAK
 case 114:
 YY_RULE_SETUP
-{  return(NE_OP); }
+{  return(OR_ASSIGN); }
 	YY_BREAK
 case 115:
 YY_RULE_SETUP
-{  return(LEFT_OP); }
+{  return(INC_OP); }
 	YY_BREAK
 case 116:
 YY_RULE_SETUP
-{  return(RIGHT_OP); }
+{  return(DEC_OP); }
 	YY_BREAK
 case 117:
 YY_RULE_SETUP
-{ context->lexAfterType = false; return(SEMICOLON); }
+{  return(AND_OP); }
 	YY_BREAK
 case 118:
 YY_RULE_SETUP
-{ context->lexAfterType = false; return(LEFT_BRACE); }
+{  return(OR_OP); }
 	YY_BREAK
 case 119:
 YY_RULE_SETUP
-{ return(RIGHT_BRACE); }
+{  return(XOR_OP); }
 	YY_BREAK
 case 120:
 YY_RULE_SETUP
-{ if (context->inTypeParen) context->lexAfterType = false; return(COMMA); }
+{  return(LE_OP); }
 	YY_BREAK
 case 121:
 YY_RULE_SETUP
-{ return(COLON); }
+{  return(GE_OP); }
 	YY_BREAK
 case 122:
 YY_RULE_SETUP
-{ context->lexAfterType = false; return(EQUAL); }
+{  return(EQ_OP); }
 	YY_BREAK
 case 123:
 YY_RULE_SETUP
-{ context->lexAfterType = false; context->inTypeParen = true; return(LEFT_PAREN); }
+{  return(NE_OP); }
 	YY_BREAK
 case 124:
 YY_RULE_SETUP
-{ context->inTypeParen = false; return(RIGHT_PAREN); }
+{  return(LEFT_OP); }
 	YY_BREAK
 case 125:
 YY_RULE_SETUP
-{ return(LEFT_BRACKET); }
+{  return(RIGHT_OP); }
 	YY_BREAK
 case 126:
 YY_RULE_SETUP
-{ return(RIGHT_BRACKET); }
+{ context->lexAfterType = false; return(SEMICOLON); }
 	YY_BREAK
 case 127:
 YY_RULE_SETUP
-{ BEGIN(FIELDS);  return(DOT); }
+{ context->lexAfterType = false; return(LEFT_BRACE); }
 	YY_BREAK
 case 128:
 YY_RULE_SETUP
-{ return(BANG); }
+{ return(RIGHT_BRACE); }
 	YY_BREAK
 case 129:
 YY_RULE_SETUP
-{ return(DASH); }
+{ if (context->inTypeParen) context->lexAfterType = false; return(COMMA); }
 	YY_BREAK
 case 130:
 YY_RULE_SETUP
-{ return(TILDE); }
+{ return(COLON); }
 	YY_BREAK
 case 131:
 YY_RULE_SETUP
-{ return(PLUS); }
+{ context->lexAfterType = false; return(EQUAL); }
 	YY_BREAK
 case 132:
 YY_RULE_SETUP
-{ return(STAR); }
+{ context->lexAfterType = false; context->inTypeParen = true; return(LEFT_PAREN); }
 	YY_BREAK
 case 133:
 YY_RULE_SETUP
-{ return(SLASH); }
+{ context->inTypeParen = false; return(RIGHT_PAREN); }
 	YY_BREAK
 case 134:
 YY_RULE_SETUP
-{ return(PERCENT); }
+{ return(LEFT_BRACKET); }
 	YY_BREAK
 case 135:
 YY_RULE_SETUP
-{ return(LEFT_ANGLE); }
+{ return(RIGHT_BRACKET); }
 	YY_BREAK
 case 136:
 YY_RULE_SETUP
-{ return(RIGHT_ANGLE); }
+{ BEGIN(FIELDS);  return(DOT); }
 	YY_BREAK
 case 137:
 YY_RULE_SETUP
-{ return(VERTICAL_BAR); }
+{ return(BANG); }
 	YY_BREAK
 case 138:
 YY_RULE_SETUP
-{ return(CARET); }
+{ return(DASH); }
 	YY_BREAK
 case 139:
 YY_RULE_SETUP
-{ return(AMPERSAND); }
+{ return(TILDE); }
 	YY_BREAK
 case 140:
 YY_RULE_SETUP
-{ return(QUESTION); }
+{ return(PLUS); }
 	YY_BREAK
 case 141:
 YY_RULE_SETUP
+{ return(STAR); }
+	YY_BREAK
+case 142:
+YY_RULE_SETUP
+{ return(SLASH); }
+	YY_BREAK
+case 143:
+YY_RULE_SETUP
+{ return(PERCENT); }
+	YY_BREAK
+case 144:
+YY_RULE_SETUP
+{ return(LEFT_ANGLE); }
+	YY_BREAK
+case 145:
+YY_RULE_SETUP
+{ return(RIGHT_ANGLE); }
+	YY_BREAK
+case 146:
+YY_RULE_SETUP
+{ return(VERTICAL_BAR); }
+	YY_BREAK
+case 147:
+YY_RULE_SETUP
+{ return(CARET); }
+	YY_BREAK
+case 148:
+YY_RULE_SETUP
+{ return(AMPERSAND); }
+	YY_BREAK
+case 149:
+YY_RULE_SETUP
+{ return(QUESTION); }
+	YY_BREAK
+case 150:
+YY_RULE_SETUP
 { 
     BEGIN(INITIAL);
     yylval->lex.string = NewPoolTString(yytext); 
     return FIELD_SELECTION;
 }
 	YY_BREAK
-case 142:
+case 151:
 YY_RULE_SETUP
 {}
 	YY_BREAK
-case 143:
-/* rule 143 can match eol */
+case 152:
+/* rule 152 can match eol */
 YY_RULE_SETUP
 {  }
 	YY_BREAK
@@ -1684,11 +1756,11 @@
 case YY_STATE_EOF(FIELDS):
 { context->AfterEOF = true; yyterminate(); }
 	YY_BREAK
-case 144:
+case 153:
 YY_RULE_SETUP
 { context->warning(yylineno, "Unknown char", yytext, ""); return 0; }
 	YY_BREAK
-case 145:
+case 154:
 YY_RULE_SETUP
 ECHO;
 	YY_BREAK
@@ -1984,7 +2056,7 @@
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 411 )
+			if ( yy_current_state >= 448 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -2013,11 +2085,11 @@
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 411 )
+		if ( yy_current_state >= 448 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 410);
+	yy_is_jam = (yy_current_state == 447);
 
 	return yy_is_jam ? 0 : yy_current_state;
 }
@@ -3096,6 +3168,8 @@
                 msg = TString("extension '") + extName + "' is not supported";
                 context->infoSink.info.message(EPrefixWarning, msg.c_str(), yylineno); 
                 break;
+            default:
+                break;
             }
             return;
         } else
diff --git a/src/OpenGL ES 2.0/compiler/glslang_tab.cpp b/src/OpenGL ES 2.0/compiler/glslang_tab.cpp
index 83ac524..1396583 100644
--- a/src/OpenGL ES 2.0/compiler/glslang_tab.cpp
+++ b/src/OpenGL ES 2.0/compiler/glslang_tab.cpp
@@ -1,24 +1,22 @@
-/* A Bison parser, made by GNU Bison 2.3.  */
+/* A Bison parser, made by GNU Bison 2.4.2.  */
 
 /* Skeleton implementation for Bison's Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
+   
+      Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software
+   Foundation, Inc.
+   
+   This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+   
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-
+   
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* As a special exception, you may create a larger work that contains
    part or all of the Bison parser skeleton and distribute that work
@@ -29,7 +27,7 @@
    special exception, which will cause the skeleton and the resulting
    Bison output files to be licensed under the GNU General Public
    License without this special exception.
-
+   
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
@@ -47,7 +45,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.3"
+#define YYBISON_VERSION "2.4.2"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -55,11 +53,55 @@
 /* Pure parsers.  */
 #define YYPURE 1
 
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
 /* Using locations.  */
 #define YYLSP_NEEDED 0
 
 
 
+/* Copy the first part of user declarations.  */
+
+
+//
+// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// This file is auto-generated by generate_glslang_parser.sh. DO NOT EDIT!
+
+#include "compiler/SymbolTable.h"
+#include "compiler/ParseHelper.h"
+#include "GLSLANG/ShaderLang.h"
+
+#define YYLEX_PARAM context->scanner
+
+
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+
 /* Tokens.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
@@ -159,142 +201,14 @@
      QUESTION = 348
    };
 #endif
-/* Tokens.  */
-#define INVARIANT 258
-#define HIGH_PRECISION 259
-#define MEDIUM_PRECISION 260
-#define LOW_PRECISION 261
-#define PRECISION 262
-#define ATTRIBUTE 263
-#define CONST_QUAL 264
-#define BOOL_TYPE 265
-#define FLOAT_TYPE 266
-#define INT_TYPE 267
-#define BREAK 268
-#define CONTINUE 269
-#define DO 270
-#define ELSE 271
-#define FOR 272
-#define IF 273
-#define DISCARD 274
-#define RETURN 275
-#define BVEC2 276
-#define BVEC3 277
-#define BVEC4 278
-#define IVEC2 279
-#define IVEC3 280
-#define IVEC4 281
-#define VEC2 282
-#define VEC3 283
-#define VEC4 284
-#define MATRIX2 285
-#define MATRIX3 286
-#define MATRIX4 287
-#define IN_QUAL 288
-#define OUT_QUAL 289
-#define INOUT_QUAL 290
-#define UNIFORM 291
-#define VARYING 292
-#define STRUCT 293
-#define VOID_TYPE 294
-#define WHILE 295
-#define SAMPLER2D 296
-#define SAMPLERCUBE 297
-#define IDENTIFIER 298
-#define TYPE_NAME 299
-#define FLOATCONSTANT 300
-#define INTCONSTANT 301
-#define BOOLCONSTANT 302
-#define FIELD_SELECTION 303
-#define LEFT_OP 304
-#define RIGHT_OP 305
-#define INC_OP 306
-#define DEC_OP 307
-#define LE_OP 308
-#define GE_OP 309
-#define EQ_OP 310
-#define NE_OP 311
-#define AND_OP 312
-#define OR_OP 313
-#define XOR_OP 314
-#define MUL_ASSIGN 315
-#define DIV_ASSIGN 316
-#define ADD_ASSIGN 317
-#define MOD_ASSIGN 318
-#define LEFT_ASSIGN 319
-#define RIGHT_ASSIGN 320
-#define AND_ASSIGN 321
-#define XOR_ASSIGN 322
-#define OR_ASSIGN 323
-#define SUB_ASSIGN 324
-#define LEFT_PAREN 325
-#define RIGHT_PAREN 326
-#define LEFT_BRACKET 327
-#define RIGHT_BRACKET 328
-#define LEFT_BRACE 329
-#define RIGHT_BRACE 330
-#define DOT 331
-#define COMMA 332
-#define COLON 333
-#define EQUAL 334
-#define SEMICOLON 335
-#define BANG 336
-#define DASH 337
-#define TILDE 338
-#define PLUS 339
-#define STAR 340
-#define SLASH 341
-#define PERCENT 342
-#define LEFT_ANGLE 343
-#define RIGHT_ANGLE 344
-#define VERTICAL_BAR 345
-#define CARET 346
-#define AMPERSAND 347
-#define QUESTION 348
 
 
 
-
-/* Copy the first part of user declarations.  */
-
-
-//
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// This file is auto-generated by generate_glslang_parser.sh. DO NOT EDIT!
-
-#include "compiler/SymbolTable.h"
-#include "compiler/ParseHelper.h"
-#include "GLSLANG/ShaderLang.h"
-
-#define YYLEX_PARAM context->scanner
-
-
-/* Enabling traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-
-/* Enabling verbose error messages.  */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 0
-#endif
-
-/* Enabling the token table.  */
-#ifndef YYTOKEN_TABLE
-# define YYTOKEN_TABLE 0
-#endif
-
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
-
 {
+
+
     struct {
         TSourceLoc line;
         union {
@@ -324,17 +238,16 @@
             TTypeList* typeList;
         };
     } interm;
-}
-/* Line 193 of yacc.c.  */
 
-	YYSTYPE;
+
+
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 
-
 /* Copy the second part of user declarations.  */
 
 
@@ -364,8 +277,6 @@
 }
 
 
-/* Line 216 of yacc.c.  */
-
 
 #ifdef short
 # undef short
@@ -440,14 +351,14 @@
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static int
-YYID (int i)
+YYID (int yyi)
 #else
 static int
-YYID (i)
-    int i;
+YYID (yyi)
+    int yyi;
 #endif
 {
-  return i;
+  return yyi;
 }
 #endif
 
@@ -528,9 +439,9 @@
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
-  yytype_int16 yyss;
-  YYSTYPE yyvs;
-  };
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;
+};
 
 /* The size of the maximum gap between one aligned stack and the next.  */
 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
@@ -564,12 +475,12 @@
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */
-# define YYSTACK_RELOCATE(Stack)					\
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
     do									\
       {									\
 	YYSIZE_T yynewbytes;						\
-	YYCOPY (&yyptr->Stack, Stack, yysize);				\
-	Stack = &yyptr->Stack;						\
+	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
+	Stack = &yyptr->Stack_alloc;					\
 	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 	yyptr += yynewbytes / sizeof (*yyptr);				\
       }									\
@@ -580,16 +491,16 @@
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  69
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   1334
+#define YYLAST   1419
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  94
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  78
+#define YYNNTS  81
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  193
+#define YYNRULES  197
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  296
+#define YYNSTATES  300
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
@@ -659,16 +570,16 @@
      368,   370,   372,   374,   376,   378,   380,   386,   391,   393,
      396,   400,   402,   406,   408,   413,   415,   417,   419,   421,
      423,   425,   427,   429,   431,   434,   435,   436,   442,   444,
-     446,   449,   453,   455,   458,   460,   463,   469,   473,   475,
-     477,   482,   483,   490,   491,   500,   501,   509,   511,   513,
-     515,   516,   519,   523,   526,   529,   532,   536,   539,   541,
-     544,   546,   548,   549
+     446,   447,   450,   451,   454,   457,   461,   463,   466,   468,
+     471,   477,   481,   483,   485,   490,   491,   498,   499,   508,
+     509,   517,   519,   521,   523,   524,   527,   531,   534,   537,
+     540,   544,   547,   549,   552,   554,   556,   557
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int16 yyrhs[] =
 {
-     168,     0,    -1,    43,    -1,    95,    -1,    46,    -1,    45,
+     171,     0,    -1,    43,    -1,    95,    -1,    46,    -1,    45,
       -1,    47,    -1,    70,   122,    71,    -1,    96,    -1,    97,
       72,    98,    73,    -1,    99,    -1,    97,    76,    48,    -1,
       97,    51,    -1,    97,    52,    -1,   122,    -1,   100,    -1,
@@ -710,20 +621,21 @@
       -1,   143,    -1,   142,   143,    -1,   137,   144,    80,    -1,
      145,    -1,   144,    77,   145,    -1,    43,    -1,    43,    72,
      123,    73,    -1,   120,    -1,   124,    -1,   150,    -1,   149,
-      -1,   147,    -1,   156,    -1,   157,    -1,   160,    -1,   167,
-      -1,    74,    75,    -1,    -1,    -1,    74,   151,   155,   152,
-      75,    -1,   154,    -1,   149,    -1,    74,    75,    -1,    74,
-     155,    75,    -1,   148,    -1,   155,   148,    -1,    80,    -1,
-     122,    80,    -1,    18,    70,   122,    71,   158,    -1,   148,
-      16,   148,    -1,   148,    -1,   122,    -1,   135,    43,    79,
-     146,    -1,    -1,    40,    70,   161,   159,    71,   153,    -1,
-      -1,    15,   162,   148,    40,    70,   122,    71,    80,    -1,
-      -1,    17,    70,   163,   164,   166,    71,   153,    -1,   156,
-      -1,   147,    -1,   159,    -1,    -1,   165,    80,    -1,   165,
-      80,   122,    -1,    14,    80,    -1,    13,    80,    -1,    20,
-      80,    -1,    20,   122,    80,    -1,    19,    80,    -1,   169,
-      -1,   168,   169,    -1,   170,    -1,   124,    -1,    -1,   125,
-     171,   154,    -1
+      -1,   147,    -1,   159,    -1,   160,    -1,   163,    -1,   170,
+      -1,    74,    75,    -1,    -1,    -1,    74,   151,   158,   152,
+      75,    -1,   157,    -1,   149,    -1,    -1,   155,   157,    -1,
+      -1,   156,   149,    -1,    74,    75,    -1,    74,   158,    75,
+      -1,   148,    -1,   158,   148,    -1,    80,    -1,   122,    80,
+      -1,    18,    70,   122,    71,   161,    -1,   154,    16,   154,
+      -1,   154,    -1,   122,    -1,   135,    43,    79,   146,    -1,
+      -1,    40,    70,   164,   162,    71,   153,    -1,    -1,    15,
+     165,   154,    40,    70,   122,    71,    80,    -1,    -1,    17,
+      70,   166,   167,   169,    71,   153,    -1,   159,    -1,   147,
+      -1,   162,    -1,    -1,   168,    80,    -1,   168,    80,   122,
+      -1,    14,    80,    -1,    13,    80,    -1,    20,    80,    -1,
+      20,   122,    80,    -1,    19,    80,    -1,   172,    -1,   171,
+     172,    -1,   173,    -1,   124,    -1,    -1,   125,   174,   157,
+      -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
@@ -736,19 +648,19 @@
      755,   766,   770,   771,   781,   791,   801,   814,   815,   825,
      838,   842,   846,   850,   851,   864,   865,   878,   879,   892,
      893,   910,   911,   924,   925,   926,   927,   928,   932,   935,
-     946,   954,   979,   984,   991,  1027,  1030,  1037,  1045,  1066,
-    1085,  1096,  1125,  1130,  1140,  1145,  1155,  1158,  1161,  1164,
-    1170,  1177,  1187,  1203,  1221,  1245,  1268,  1272,  1290,  1298,
-    1330,  1350,  1426,  1435,  1458,  1461,  1467,  1475,  1483,  1491,
-    1494,  1501,  1504,  1507,  1513,  1516,  1531,  1535,  1539,  1543,
-    1552,  1557,  1562,  1567,  1572,  1577,  1582,  1587,  1592,  1597,
-    1603,  1609,  1615,  1620,  1625,  1630,  1643,  1656,  1664,  1667,
-    1682,  1713,  1717,  1723,  1731,  1747,  1751,  1755,  1756,  1762,
-    1763,  1764,  1765,  1766,  1770,  1771,  1771,  1771,  1781,  1782,
-    1787,  1790,  1800,  1803,  1809,  1810,  1814,  1822,  1826,  1836,
-    1841,  1858,  1858,  1863,  1863,  1870,  1870,  1878,  1881,  1887,
-    1890,  1896,  1900,  1907,  1914,  1921,  1928,  1939,  1948,  1952,
-    1959,  1962,  1968,  1968
+     946,   954,   981,   986,   993,  1031,  1034,  1041,  1049,  1070,
+    1091,  1102,  1131,  1136,  1146,  1151,  1161,  1164,  1167,  1170,
+    1176,  1183,  1193,  1215,  1233,  1257,  1280,  1284,  1302,  1310,
+    1342,  1362,  1451,  1460,  1483,  1486,  1492,  1500,  1508,  1516,
+    1519,  1526,  1529,  1532,  1538,  1541,  1556,  1560,  1564,  1568,
+    1577,  1582,  1587,  1592,  1597,  1602,  1607,  1612,  1617,  1622,
+    1628,  1634,  1640,  1645,  1650,  1655,  1668,  1681,  1689,  1692,
+    1707,  1738,  1742,  1748,  1756,  1772,  1776,  1780,  1781,  1787,
+    1788,  1789,  1790,  1791,  1795,  1796,  1796,  1796,  1806,  1807,
+    1811,  1811,  1812,  1812,  1817,  1820,  1830,  1833,  1839,  1840,
+    1844,  1852,  1856,  1866,  1871,  1888,  1888,  1893,  1893,  1900,
+    1900,  1908,  1911,  1917,  1920,  1926,  1930,  1937,  1944,  1951,
+    1958,  1969,  1978,  1982,  1989,  1992,  1998,  1998
 };
 #endif
 
@@ -795,13 +707,13 @@
   "struct_declaration_list", "struct_declaration",
   "struct_declarator_list", "struct_declarator", "initializer",
   "declaration_statement", "statement", "simple_statement",
-  "compound_statement", "@1", "@2", "statement_no_new_scope",
-  "compound_statement_no_new_scope", "statement_list",
-  "expression_statement", "selection_statement",
-  "selection_rest_statement", "condition", "iteration_statement", "@3",
-  "@4", "@5", "for_init_statement", "conditionopt", "for_rest_statement",
+  "compound_statement", "$@1", "$@2", "statement_no_new_scope",
+  "statement_with_scope", "$@3", "$@4", "compound_statement_no_new_scope",
+  "statement_list", "expression_statement", "selection_statement",
+  "selection_rest_statement", "condition", "iteration_statement", "$@5",
+  "$@6", "$@7", "for_init_statement", "conditionopt", "for_rest_statement",
   "jump_statement", "translation_unit", "external_declaration",
-  "function_definition", "@6", 0
+  "function_definition", "$@8", 0
 };
 #endif
 
@@ -842,10 +754,10 @@
      140,   140,   140,   140,   140,   140,   141,   141,   142,   142,
      143,   144,   144,   145,   145,   146,   147,   148,   148,   149,
      149,   149,   149,   149,   150,   151,   152,   150,   153,   153,
-     154,   154,   155,   155,   156,   156,   157,   158,   158,   159,
-     159,   161,   160,   162,   160,   163,   160,   164,   164,   165,
-     165,   166,   166,   167,   167,   167,   167,   167,   168,   168,
-     169,   169,   171,   170
+     155,   154,   156,   154,   157,   157,   158,   158,   159,   159,
+     160,   161,   161,   162,   162,   164,   163,   165,   163,   166,
+     163,   167,   167,   168,   168,   169,   169,   170,   170,   170,
+     170,   170,   171,   171,   172,   172,   174,   173
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -867,10 +779,10 @@
        1,     1,     1,     1,     1,     1,     5,     4,     1,     2,
        3,     1,     3,     1,     4,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     2,     0,     0,     5,     1,     1,
-       2,     3,     1,     2,     1,     2,     5,     3,     1,     1,
-       4,     0,     6,     0,     8,     0,     7,     1,     1,     1,
-       0,     2,     3,     2,     2,     2,     3,     2,     1,     2,
-       1,     1,     0,     3
+       0,     2,     0,     2,     2,     3,     1,     2,     1,     2,
+       5,     3,     1,     1,     4,     0,     6,     0,     8,     0,
+       7,     1,     1,     1,     0,     2,     3,     2,     2,     2,
+       3,     2,     1,     2,     1,     1,     0,     3
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -881,33 +793,33 @@
        0,     0,   111,   112,   113,     0,   105,   104,   119,   117,
      118,   123,   124,   125,   126,   127,   128,   120,   121,   122,
      129,   130,   131,   108,   106,     0,   116,   132,   133,   135,
-     191,   192,     0,    76,    86,     0,    91,    96,     0,   102,
-       0,   109,   114,   134,     0,   188,   190,   107,   101,     0,
+     195,   196,     0,    76,    86,     0,    91,    96,     0,   102,
+       0,   109,   114,   134,     0,   192,   194,   107,   101,     0,
        0,     0,    71,     0,    74,    86,     0,    87,    88,    89,
       77,     0,    86,     0,    72,    97,   103,   110,     0,     1,
-     189,     0,     0,     0,     0,   138,     0,   193,    78,    83,
+     193,     0,     0,     0,     0,   138,     0,   197,    78,    83,
       85,    90,     0,    92,    79,     0,     0,     2,     5,     4,
        6,    27,     0,     0,     0,    34,    33,    32,     3,     8,
       28,    10,    15,    16,     0,     0,    21,     0,    35,     0,
       38,    41,    42,    47,    50,    51,    52,    53,    55,    57,
       59,    70,     0,    25,    73,     0,   143,     0,   141,   137,
-     139,     0,     0,   173,     0,     0,     0,     0,     0,   155,
-     160,   164,    35,    61,    68,     0,   146,     0,   102,   149,
-     162,   148,   147,     0,   150,   151,   152,   153,    80,    82,
+     139,     0,     0,   177,     0,     0,     0,     0,     0,   155,
+     164,   168,    35,    61,    68,     0,   146,     0,   102,   149,
+     166,   148,   147,     0,   150,   151,   152,   153,    80,    82,
       84,     0,     0,    98,     0,   145,   100,    29,    30,     0,
       12,    13,     0,     0,    19,    18,     0,   116,    22,    24,
       31,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,   115,   136,     0,     0,   140,
-     184,   183,     0,   175,     0,   187,   185,     0,   171,   154,
-       0,    64,    65,    66,    67,    63,     0,     0,   165,   161,
-     163,     0,    93,     0,    95,    99,     7,     0,    14,    26,
+     188,   187,   162,   179,     0,   191,   189,     0,   175,   154,
+       0,    64,    65,    66,    67,    63,     0,     0,   169,   165,
+     167,     0,    93,     0,    95,    99,     7,     0,    14,    26,
       11,    17,    23,    36,    37,    40,    39,    45,    46,    43,
       44,    48,    49,    54,    56,    58,     0,     0,   142,     0,
-       0,     0,   186,     0,   156,    62,    69,     0,    94,     9,
-       0,   144,     0,   178,   177,   180,     0,   169,     0,     0,
-       0,    81,    60,     0,   179,     0,     0,   168,   166,     0,
-       0,   157,     0,   181,     0,     0,     0,   159,   172,   158,
-       0,   182,   176,   167,   170,   174
+       0,     0,     0,     0,   190,     0,   156,    62,    69,     0,
+      94,     9,     0,   144,     0,   161,   163,   182,   181,   184,
+     162,   173,     0,     0,     0,    81,    60,     0,   183,     0,
+       0,   172,   170,     0,     0,   157,     0,   185,     0,   162,
+       0,   159,   176,   158,     0,   186,   180,   171,   174,   178
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
@@ -918,301 +830,298 @@
      116,   117,   118,   119,   120,   143,   144,   216,   145,   122,
      146,   147,    32,    33,    34,    79,    60,    61,    80,    35,
       36,    37,    38,   123,    40,    41,    42,    43,    74,    75,
-     127,   128,   166,   149,   150,   151,   152,   210,   270,   288,
-     289,   153,   154,   155,   278,   269,   156,   253,   202,   250,
-     265,   275,   276,   157,    44,    45,    46,    53
+     127,   128,   166,   149,   150,   151,   152,   210,   274,   292,
+     249,   250,   251,   293,   153,   154,   155,   282,   273,   156,
+     255,   202,   252,   269,   279,   280,   157,    44,    45,    46,
+      53
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -250
+#define YYPACT_NINF -258
 static const yytype_int16 yypact[] =
 {
-    1225,    36,  -250,  -250,  -250,   150,  -250,  -250,  -250,  -250,
-    -250,  -250,  -250,  -250,  -250,  -250,  -250,  -250,  -250,  -250,
-    -250,  -250,  -250,  -250,  -250,   -33,  -250,  -250,  -250,  -250,
-    -250,   -60,   -22,   -17,    21,   -62,  -250,    22,  1266,  -250,
-    1290,  -250,    11,  -250,  1138,  -250,  -250,  -250,  -250,  1290,
-      14,  1266,  -250,    27,  -250,    34,    41,  -250,  -250,  -250,
-    -250,  1266,   129,    61,  -250,    17,  -250,  -250,   908,  -250,
-    -250,    31,  1266,    72,  1042,  -250,   283,  -250,  -250,  -250,
-    -250,    90,  1266,   -46,  -250,   194,   908,    65,  -250,  -250,
-    -250,  -250,   908,   908,   908,  -250,  -250,  -250,  -250,  -250,
-     -40,  -250,  -250,  -250,    80,   -25,   975,    87,  -250,   908,
-      35,    13,  -250,   -26,    68,  -250,  -250,  -250,   110,   109,
-     -54,  -250,    96,  -250,  -250,  1083,    98,    33,  -250,  -250,
-    -250,    91,    92,  -250,   104,   107,    99,   760,   108,   105,
-    -250,  -250,    24,  -250,  -250,    37,  -250,   -60,   112,  -250,
-    -250,  -250,  -250,   365,  -250,  -250,  -250,  -250,   111,  -250,
-    -250,   827,   908,  -250,   113,  -250,  -250,  -250,  -250,     4,
-    -250,  -250,   908,  1179,  -250,  -250,   908,   114,  -250,  -250,
-    -250,   908,   908,   908,   908,   908,   908,   908,   908,   908,
-     908,   908,   908,   908,   908,  -250,  -250,   908,    72,  -250,
-    -250,  -250,   447,  -250,   908,  -250,  -250,    42,  -250,  -250,
-     447,  -250,  -250,  -250,  -250,  -250,   908,   908,  -250,  -250,
-    -250,   908,  -250,   115,  -250,  -250,  -250,   116,   117,  -250,
-     120,  -250,  -250,  -250,  -250,    35,    35,  -250,  -250,  -250,
-    -250,   -26,   -26,  -250,   110,   109,    51,   119,  -250,   144,
-     611,    23,  -250,   693,   447,  -250,  -250,   122,  -250,  -250,
-     908,  -250,   123,  -250,  -250,   693,   447,   117,   153,   126,
-     128,  -250,  -250,   908,  -250,   127,   137,   171,  -250,   130,
-     529,  -250,    28,   908,   529,   447,   908,  -250,  -250,  -250,
-     131,   117,  -250,  -250,  -250,  -250
+    1310,    46,  -258,  -258,  -258,   123,  -258,  -258,  -258,  -258,
+    -258,  -258,  -258,  -258,  -258,  -258,  -258,  -258,  -258,  -258,
+    -258,  -258,  -258,  -258,  -258,    -9,  -258,  -258,  -258,  -258,
+    -258,   -47,   -34,   -57,    21,    24,  -258,    17,  1351,  -258,
+    1375,  -258,     3,  -258,  1223,  -258,  -258,  -258,  -258,  1375,
+      11,  1351,  -258,    56,  -258,    33,    96,  -258,  -258,  -258,
+    -258,  1351,   121,   106,  -258,    14,  -258,  -258,   993,  -258,
+    -258,    71,  1351,   114,  1127,  -258,   286,  -258,  -258,  -258,
+    -258,   120,  1351,    16,  -258,   197,   993,    95,  -258,  -258,
+    -258,  -258,   993,   993,   993,  -258,  -258,  -258,  -258,  -258,
+     -33,  -258,  -258,  -258,    97,    23,  1060,    99,  -258,   993,
+     -70,   -11,  -258,   -26,    65,  -258,  -258,  -258,   109,   108,
+     -41,  -258,    98,  -258,  -258,  1168,   100,    37,  -258,  -258,
+    -258,    90,    93,  -258,   104,   105,   101,   845,   110,   107,
+    -258,  -258,    18,  -258,  -258,    38,  -258,   -47,   113,  -258,
+    -258,  -258,  -258,   368,  -258,  -258,  -258,  -258,   112,  -258,
+    -258,   912,   993,  -258,   115,  -258,  -258,  -258,  -258,    25,
+    -258,  -258,   993,  1264,  -258,  -258,   993,   116,  -258,  -258,
+    -258,   993,   993,   993,   993,   993,   993,   993,   993,   993,
+     993,   993,   993,   993,   993,  -258,  -258,   993,   114,  -258,
+    -258,  -258,   111,  -258,   993,  -258,  -258,    42,  -258,  -258,
+     450,  -258,  -258,  -258,  -258,  -258,   993,   993,  -258,  -258,
+    -258,   993,  -258,   117,  -258,  -258,  -258,   118,   102,  -258,
+     119,  -258,  -258,  -258,  -258,   -70,   -70,  -258,  -258,  -258,
+    -258,   -26,   -26,  -258,   109,   108,    82,   122,  -258,   152,
+      56,   614,   696,    28,  -258,   778,   450,  -258,  -258,   124,
+    -258,  -258,   993,  -258,   128,  -258,  -258,  -258,  -258,   778,
+     111,   102,   150,   129,   131,  -258,  -258,   993,  -258,   132,
+     133,   178,  -258,   134,   532,  -258,    35,   993,   532,   111,
+     993,  -258,  -258,  -258,   135,   102,  -258,  -258,  -258,  -258
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -250,  -250,  -250,  -250,  -250,  -250,  -250,    39,  -250,  -250,
-    -250,  -250,   -45,  -250,   -18,  -250,   -79,   -30,  -250,  -250,
-    -250,    38,    52,    20,  -250,   -63,   -85,  -250,   -92,   -71,
-       6,     9,  -250,  -250,  -250,   132,   172,   166,   148,  -250,
-    -250,  -246,   -21,     0,   226,   -24,  -250,  -250,   162,   -66,
-    -250,    45,  -159,    -3,  -136,  -249,  -250,  -250,  -250,   -36,
-     196,    46,     1,  -250,  -250,   -13,  -250,  -250,  -250,  -250,
-    -250,  -250,  -250,  -250,  -250,   211,  -250,  -250
+    -258,  -258,  -258,  -258,  -258,  -258,  -258,    41,  -258,  -258,
+    -258,  -258,   -45,  -258,   -60,  -258,   -77,   -28,  -258,  -258,
+    -258,    20,    39,    40,  -258,   -63,   -85,  -258,   -91,   -71,
+       6,     9,  -258,  -258,  -258,   148,   161,   155,   164,  -258,
+    -258,  -244,   -24,     0,   227,   -14,  -258,  -258,   162,   -66,
+    -258,    49,  -155,   -15,  -149,  -239,  -258,  -258,  -258,   -38,
+    -257,  -258,  -258,   -51,    43,     2,  -258,  -258,   -12,  -258,
+    -258,  -258,  -258,  -258,  -258,  -258,  -258,  -258,   214,  -258,
+    -258
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
    If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -76
+#define YYTABLE_NINF -161
 static const yytype_int16 yytable[] =
 {
-      39,   165,   169,   224,   193,   121,    30,   268,   130,    31,
-      50,   170,   171,    62,   164,    63,    67,   220,    64,   268,
-      52,   178,   121,   108,    56,    71,   161,   185,   186,     6,
-       7,   287,   172,   162,    62,   287,   173,    56,    66,   194,
-     108,    51,     6,     7,    39,   207,   175,   167,   168,    54,
-      30,    73,   176,    31,    57,    58,    59,    23,    24,   130,
-      55,    81,   187,   188,   180,    65,   249,    57,    58,    59,
-      23,    24,    73,    47,    73,   226,   148,   165,    47,    48,
-     228,   217,    81,    68,   211,   212,   213,    84,    72,    85,
-     223,   232,   -75,   214,   266,   183,    86,   184,   121,   290,
-     217,    76,   246,   215,    83,   217,   237,   238,   239,   240,
-     198,   124,   251,   199,   217,   126,   108,   218,   220,   217,
-     181,   182,   252,   189,   190,    73,   247,   294,   217,   260,
-     277,   255,   256,   158,   121,   -26,   233,   234,   108,   108,
-     108,   108,   108,   108,   108,   108,   108,   108,   108,   293,
-     257,   174,   108,   148,     2,     3,     4,   179,   121,   241,
-     242,   267,    57,    58,    59,   235,   236,   191,   192,   195,
-     197,   200,   201,   267,   203,   272,   108,   204,   208,   205,
-     209,   282,   -25,   221,   262,   -20,   225,   285,   258,   259,
-     -27,   291,   261,   273,   217,   271,   279,   280,     2,     3,
-       4,   165,   148,   281,     8,     9,    10,   283,   284,   286,
-     148,   295,   231,   245,   159,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    78,    82,   243,
-     160,    49,    25,    26,   125,    27,    28,    87,    29,    88,
-      89,    90,    91,   248,   244,    92,    93,   263,   292,    77,
-     148,   264,   274,   148,   148,    70,   254,     0,     0,     0,
-       0,     0,     0,     0,    94,   148,   148,   163,     0,     0,
-       0,     0,     0,     0,     0,    95,    96,     0,    97,     0,
-     148,     0,     0,     0,   148,   148,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,   131,   132,   133,     0,
-     134,   135,   136,   137,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,     0,     0,     0,    23,
-      24,    25,    26,   138,    27,    28,    87,    29,    88,    89,
-      90,    91,     0,     0,    92,    93,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,     0,     0,     0,   139,   140,     0,
-       0,     0,     0,   141,    95,    96,     0,    97,     1,     2,
-       3,     4,     5,     6,     7,     8,     9,    10,   131,   132,
-     133,     0,   134,   135,   136,   137,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,     0,     0,
-       0,    23,    24,    25,    26,   138,    27,    28,    87,    29,
-      88,    89,    90,    91,     0,     0,    92,    93,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    94,     0,     0,     0,   139,
-     219,     0,     0,     0,     0,   141,    95,    96,     0,    97,
-       1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
-     131,   132,   133,     0,   134,   135,   136,   137,    11,    12,
+      39,   165,    77,   169,   220,   121,    30,   224,   130,    31,
+      62,   272,   266,   281,   164,   181,   182,   193,   170,   171,
+      55,   178,   121,   108,    56,   272,    67,   185,   186,     6,
+       7,    62,   297,    52,    50,    71,    56,    54,    66,   172,
+     108,     6,     7,   173,    39,   291,   207,   167,   168,   291,
+      30,    73,   194,    31,    57,    58,    59,    23,    24,   130,
+      65,    81,   187,   188,   180,    51,    57,    58,    59,    23,
+      24,   183,    73,   184,    73,    68,   148,   165,   211,   212,
+     213,   228,    81,    47,    84,    72,    85,   214,   161,    48,
+     223,   232,   -75,    86,   175,   162,   226,   215,   121,   270,
+     176,    63,   217,   246,    64,   217,   294,   220,   237,   238,
+     239,   240,   217,   253,   198,   217,   108,   199,   218,   217,
+     189,   190,   254,   235,   236,    73,   247,     2,     3,     4,
+      76,   257,   258,    47,   121,   298,   233,   234,   108,   108,
+     108,   108,   108,   108,   108,   108,   108,   108,   108,    83,
+     259,   124,   108,   148,    57,    58,    59,   126,   121,   217,
+     262,   241,   242,   158,   271,   -26,   191,   192,   174,   179,
+     200,   195,   197,   201,   203,   204,   108,   276,   271,   217,
+     208,   205,   209,   -25,   221,  -160,   286,   -20,   225,   -27,
+     260,   261,   264,   283,   289,   263,   295,   275,   277,   265,
+     284,     2,     3,     4,   288,   165,   285,     8,     9,    10,
+     148,   243,   287,   290,   231,   299,    78,    82,    11,    12,
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-       0,     0,     0,    23,    24,    25,    26,   138,    27,    28,
-      87,    29,    88,    89,    90,    91,     0,     0,    92,    93,
+     159,   244,    49,   245,   125,    25,    26,   267,    27,    28,
+      87,    29,    88,    89,    90,    91,   160,   248,    92,    93,
+     296,   148,   148,   256,   268,   148,   148,   278,    70,     0,
+       0,     0,     0,     0,     0,     0,     0,    94,     0,   148,
+     163,     0,     0,     0,     0,     0,     0,     0,    95,    96,
+       0,    97,     0,     0,   148,     0,     0,     0,   148,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,   131,
+     132,   133,     0,   134,   135,   136,   137,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,     0,
+       0,     0,    23,    24,    25,    26,   138,    27,    28,    87,
+      29,    88,    89,    90,    91,     0,     0,    92,    93,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,     0,     0,
-       0,   139,     0,     0,     0,     0,     0,   141,    95,    96,
-       0,    97,     1,     2,     3,     4,     5,     6,     7,     8,
-       9,    10,   131,   132,   133,     0,   134,   135,   136,   137,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,     0,     0,     0,    23,    24,    25,    26,   138,
-      27,    28,    87,    29,    88,    89,    90,    91,     0,     0,
-      92,    93,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    94,
-       0,     0,     0,    76,     0,     0,     0,     0,     0,   141,
-      95,    96,     0,    97,     1,     2,     3,     4,     5,     6,
-       7,     8,     9,    10,     0,     0,     0,     0,     0,     0,
-       0,     0,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,     0,     0,     0,    23,    24,    25,
-      26,     0,    27,    28,    87,    29,    88,    89,    90,    91,
-       0,     0,    92,    93,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    94,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   141,    95,    96,     0,    97,    56,     2,     3,     4,
-       0,     6,     7,     8,     9,    10,     0,     0,     0,     0,
-       0,     0,     0,     0,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,     0,     0,     0,    23,
-      24,    25,    26,     0,    27,    28,    87,    29,    88,    89,
-      90,    91,     0,     0,    92,    93,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    94,     2,     3,     4,     0,     0,     0,
-       8,     9,    10,     0,    95,    96,     0,    97,     0,     0,
-       0,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,     0,     0,     0,     0,     0,    25,    26,
-       0,    27,    28,    87,    29,    88,    89,    90,    91,     0,
+       0,     0,     0,     0,     0,     0,    94,     0,     0,     0,
+     139,   140,     0,     0,     0,     0,   141,    95,    96,     0,
+      97,     1,     2,     3,     4,     5,     6,     7,     8,     9,
+      10,   131,   132,   133,     0,   134,   135,   136,   137,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,     0,     0,     0,    23,    24,    25,    26,   138,    27,
+      28,    87,    29,    88,    89,    90,    91,     0,     0,    92,
+      93,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    94,     0,
+       0,     0,   139,   219,     0,     0,     0,     0,   141,    95,
+      96,     0,    97,     1,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,   131,   132,   133,     0,   134,   135,   136,
+     137,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,     0,     0,     0,    23,    24,    25,    26,
+     138,    27,    28,    87,    29,    88,    89,    90,    91,     0,
        0,    92,    93,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      94,     2,     3,     4,     0,     0,     0,     8,     9,    10,
-     206,    95,    96,     0,    97,     0,     0,     0,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
-       0,     0,     0,     0,     0,    25,    26,     0,    27,    28,
-      87,    29,    88,    89,    90,    91,     0,     0,    92,    93,
+      94,     0,     0,     0,   139,     0,     0,     0,     0,     0,
+     141,    95,    96,     0,    97,     1,     2,     3,     4,     5,
+       6,     7,     8,     9,    10,   131,   132,   133,     0,   134,
+     135,   136,   137,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    21,    22,     0,     0,     0,    23,    24,
+      25,    26,   138,    27,    28,    87,    29,    88,    89,    90,
+      91,     0,     0,    92,    93,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    94,     0,     0,
-     222,     0,     0,     0,     0,     0,     0,     0,    95,    96,
-       0,    97,     2,     3,     4,     0,     0,     0,     8,     9,
+       0,     0,    94,     0,     0,     0,    76,     0,     0,     0,
+       0,     0,   141,    95,    96,     0,    97,     1,     2,     3,
+       4,     5,     6,     7,     8,     9,    10,   131,   132,   133,
+       0,   134,   135,   136,   137,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,     0,     0,     0,
+      23,    24,    25,    26,   138,    27,    28,    87,    29,    88,
+      89,    90,    91,     0,     0,    92,    93,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    94,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   141,    95,    96,     0,    97,     1,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,     0,
+       0,     0,     0,     0,     0,     0,     0,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,     0,
+       0,     0,    23,    24,    25,    26,     0,    27,    28,    87,
+      29,    88,    89,    90,    91,     0,     0,    92,    93,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    94,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   141,    95,    96,     0,
+      97,    56,     2,     3,     4,     0,     6,     7,     8,     9,
       10,     0,     0,     0,     0,     0,     0,     0,     0,    11,
       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,     0,     0,     0,     0,     0,    25,    26,     0,    27,
+      22,     0,     0,     0,    23,    24,    25,    26,     0,    27,
       28,    87,    29,    88,    89,    90,    91,     0,     0,    92,
       93,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,    94,     2,
        3,     4,     0,     0,     0,     8,     9,    10,     0,    95,
       96,     0,    97,     0,     0,     0,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,     0,     0,
-       0,     0,     0,    25,   177,     0,    27,    28,    87,    29,
+       0,     0,     0,    25,    26,     0,    27,    28,    87,    29,
       88,    89,    90,    91,     0,     0,    92,    93,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,    94,     2,     3,     4,     0,
-       0,     0,     8,     9,    10,     0,    95,    96,     0,    97,
+       0,     0,     8,     9,    10,   206,    95,    96,     0,    97,
        0,     0,     0,    11,    12,    13,    14,    15,    16,    17,
       18,    19,    20,    21,    22,     0,     0,     0,     0,     0,
-      25,    26,     0,    27,    28,     0,    29,     2,     3,     4,
+      25,    26,     0,    27,    28,    87,    29,    88,    89,    90,
+      91,     0,     0,    92,    93,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    94,     0,     0,   222,     0,     0,     0,     0,
+       0,     0,     0,    95,    96,     0,    97,     2,     3,     4,
        0,     0,     0,     8,     9,    10,     0,     0,     0,     0,
        0,     0,     0,     0,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    20,    21,    22,     0,   129,     0,     0,
-       0,    25,    26,     0,    27,    28,     0,    29,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    69,     0,
-       0,     1,     2,     3,     4,     5,     6,     7,     8,     9,
-      10,     0,     0,     0,     0,     0,     0,     0,   196,    11,
+      17,    18,    19,    20,    21,    22,     0,     0,     0,     0,
+       0,    25,    26,     0,    27,    28,    87,    29,    88,    89,
+      90,    91,     0,     0,    92,    93,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    94,     2,     3,     4,     0,     0,     0,
+       8,     9,    10,     0,    95,    96,     0,    97,     0,     0,
+       0,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,     0,     0,     0,     0,     0,    25,   177,
+       0,    27,    28,    87,    29,    88,    89,    90,    91,     0,
+       0,    92,    93,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      94,     2,     3,     4,     0,     0,     0,     8,     9,    10,
+       0,    95,    96,     0,    97,     0,     0,     0,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+       0,     0,     0,     0,     0,    25,    26,     0,    27,    28,
+       0,    29,     2,     3,     4,     0,     0,     0,     8,     9,
+      10,     0,     0,     0,     0,     0,     0,     0,     0,    11,
       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,     0,     0,     0,    23,    24,    25,    26,     0,    27,
-      28,     0,    29,     2,     3,     4,     0,     0,     0,     8,
-       9,    10,     0,     0,     0,     0,     0,     0,     0,     0,
-      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,     0,     0,     0,     0,     0,    25,    26,     0,
-      27,    28,   229,    29,     0,     0,     0,   230,     1,     2,
-       3,     4,     5,     6,     7,     8,     9,    10,     0,     0,
-       0,     0,     0,     0,     0,     0,    11,    12,    13,    14,
+      22,     0,   129,     0,     0,     0,    25,    26,     0,    27,
+      28,     0,    29,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    69,     0,     0,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,     0,     0,     0,     0,
+       0,     0,     0,   196,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,     0,     0,     0,    23,
+      24,    25,    26,     0,    27,    28,     0,    29,     2,     3,
+       4,     0,     0,     0,     8,     9,    10,     0,     0,     0,
+       0,     0,     0,     0,     0,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,     0,     0,     0,
+       0,     0,    25,    26,     0,    27,    28,   229,    29,     0,
+       0,     0,   230,     1,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,     0,     0,     0,     0,     0,     0,     0,
+       0,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,     0,     0,     0,    23,    24,    25,    26,
+       0,    27,    28,     0,    29,     2,     3,     4,     0,     0,
+       0,     8,     9,    10,     0,     0,     0,     0,     0,     0,
+       0,     0,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,     0,     8,     9,    10,     0,    25,
+      26,     0,    27,    28,     0,    29,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,     0,     0,
-       0,    23,    24,    25,    26,     0,    27,    28,     0,    29,
-       2,     3,     4,     0,     0,     0,     8,     9,    10,     0,
-       0,     0,     0,     0,     0,     0,     0,    11,    12,    13,
-      14,    15,    16,    17,    18,    19,    20,    21,    22,     0,
-       8,     9,    10,     0,    25,    26,     0,    27,    28,     0,
-      29,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,     0,     0,     0,     0,     0,    25,    26,
-       0,    27,    28,     0,    29
+       0,     0,     0,    25,    26,     0,    27,    28,     0,    29
 };
 
 static const yytype_int16 yycheck[] =
 {
-       0,    86,    94,   162,    58,    68,     0,   253,    74,     0,
-      43,    51,    52,    34,    85,    77,    40,   153,    80,   265,
-      80,   106,    85,    68,     3,    49,    72,    53,    54,     8,
-       9,   280,    72,    79,    55,   284,    76,     3,    38,    93,
-      85,    74,     8,     9,    44,   137,    71,    92,    93,    71,
-      44,    51,    77,    44,    33,    34,    35,    36,    37,   125,
-      77,    61,    88,    89,   109,    43,   202,    33,    34,    35,
-      36,    37,    72,    37,    74,    71,    76,   162,    37,    43,
-     172,    77,    82,    72,    60,    61,    62,    70,    74,    72,
-     161,   176,    71,    69,    71,    82,    79,    84,   161,    71,
-      77,    74,   194,    79,    43,    77,   185,   186,   187,   188,
-      77,    80,   204,    80,    77,    43,   161,    80,   254,    77,
-      85,    86,    80,    55,    56,   125,   197,   286,    77,    78,
-     266,   216,   217,    43,   197,    70,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   285,
-     221,    71,   197,   153,     4,     5,     6,    70,   221,   189,
-     190,   253,    33,    34,    35,   183,   184,    57,    59,    73,
-      72,    80,    80,   265,    70,   260,   221,    70,    70,    80,
-      75,   273,    70,    72,    40,    71,    73,    16,    73,    73,
-      70,   283,    73,    70,    77,    73,    43,    71,     4,     5,
-       6,   286,   202,    75,    10,    11,    12,    80,    71,    79,
-     210,    80,   173,   193,    82,    21,    22,    23,    24,    25,
-      26,    27,    28,    29,    30,    31,    32,    55,    62,   191,
-      82,     5,    38,    39,    72,    41,    42,    43,    44,    45,
-      46,    47,    48,   198,   192,    51,    52,   250,   284,    53,
-     250,   250,   265,   253,   254,    44,   210,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    70,   265,   266,    73,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    81,    82,    -1,    84,    -1,
-     280,    -1,    -1,    -1,   284,   285,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    -1,
-      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    -1,    -1,    -1,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    48,    -1,    -1,    51,    52,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    74,    75,    -1,
-      -1,    -1,    -1,    80,    81,    82,    -1,    84,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    -1,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    -1,    -1,
-      -1,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    -1,    -1,    51,    52,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,    74,
-      75,    -1,    -1,    -1,    -1,    80,    81,    82,    -1,    84,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    -1,    17,    18,    19,    20,    21,    22,
+       0,    86,    53,    94,   153,    68,     0,   162,    74,     0,
+      34,   255,   251,   270,    85,    85,    86,    58,    51,    52,
+      77,   106,    85,    68,     3,   269,    40,    53,    54,     8,
+       9,    55,   289,    80,    43,    49,     3,    71,    38,    72,
+      85,     8,     9,    76,    44,   284,   137,    92,    93,   288,
+      44,    51,    93,    44,    33,    34,    35,    36,    37,   125,
+      43,    61,    88,    89,   109,    74,    33,    34,    35,    36,
+      37,    82,    72,    84,    74,    72,    76,   162,    60,    61,
+      62,   172,    82,    37,    70,    74,    72,    69,    72,    43,
+     161,   176,    71,    79,    71,    79,    71,    79,   161,    71,
+      77,    77,    77,   194,    80,    77,    71,   256,   185,   186,
+     187,   188,    77,   204,    77,    77,   161,    80,    80,    77,
+      55,    56,    80,   183,   184,   125,   197,     4,     5,     6,
+      74,   216,   217,    37,   197,   290,   181,   182,   183,   184,
+     185,   186,   187,   188,   189,   190,   191,   192,   193,    43,
+     221,    80,   197,   153,    33,    34,    35,    43,   221,    77,
+      78,   189,   190,    43,   255,    70,    57,    59,    71,    70,
+      80,    73,    72,    80,    70,    70,   221,   262,   269,    77,
+      70,    80,    75,    70,    72,    74,   277,    71,    73,    70,
+      73,    73,    40,    43,    16,    73,   287,    73,    70,   250,
+      71,     4,     5,     6,    71,   290,    75,    10,    11,    12,
+     210,   191,    80,    79,   173,    80,    55,    62,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      -1,    -1,    -1,    36,    37,    38,    39,    40,    41,    42,
-      43,    44,    45,    46,    47,    48,    -1,    -1,    51,    52,
+      82,   192,     5,   193,    72,    38,    39,   252,    41,    42,
+      43,    44,    45,    46,    47,    48,    82,   198,    51,    52,
+     288,   251,   252,   210,   252,   255,   256,   269,    44,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    -1,   269,
+      73,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    81,    82,
+      -1,    84,    -1,    -1,   284,    -1,    -1,    -1,   288,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    -1,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    -1,
+      -1,    -1,    36,    37,    38,    39,    40,    41,    42,    43,
+      44,    45,    46,    47,    48,    -1,    -1,    51,    52,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    -1,    -1,
-      -1,    74,    -1,    -1,    -1,    -1,    -1,    80,    81,    82,
-      -1,    84,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    -1,    17,    18,    19,    20,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    -1,    -1,    -1,    36,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    48,    -1,    -1,
-      51,    52,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
-      -1,    -1,    -1,    74,    -1,    -1,    -1,    -1,    -1,    80,
-      81,    82,    -1,    84,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    21,    22,    23,    24,    25,    26,    27,    28,
-      29,    30,    31,    32,    -1,    -1,    -1,    36,    37,    38,
-      39,    -1,    41,    42,    43,    44,    45,    46,    47,    48,
-      -1,    -1,    51,    52,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    80,    81,    82,    -1,    84,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    -1,    -1,    -1,    36,
-      37,    38,    39,    -1,    41,    42,    43,    44,    45,    46,
-      47,    48,    -1,    -1,    51,    52,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    70,     4,     5,     6,    -1,    -1,    -1,
-      10,    11,    12,    -1,    81,    82,    -1,    84,    -1,    -1,
-      -1,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-      30,    31,    32,    -1,    -1,    -1,    -1,    -1,    38,    39,
-      -1,    41,    42,    43,    44,    45,    46,    47,    48,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,
+      74,    75,    -1,    -1,    -1,    -1,    80,    81,    82,    -1,
+      84,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    -1,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    -1,    -1,    -1,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    -1,    -1,    51,
+      52,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    -1,
+      -1,    -1,    74,    75,    -1,    -1,    -1,    -1,    80,    81,
+      82,    -1,    84,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    -1,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    -1,    -1,    -1,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    -1,
       -1,    51,    52,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      70,     4,     5,     6,    -1,    -1,    -1,    10,    11,    12,
-      80,    81,    82,    -1,    84,    -1,    -1,    -1,    21,    22,
-      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      -1,    -1,    -1,    -1,    -1,    38,    39,    -1,    41,    42,
-      43,    44,    45,    46,    47,    48,    -1,    -1,    51,    52,
+      70,    -1,    -1,    -1,    74,    -1,    -1,    -1,    -1,    -1,
+      80,    81,    82,    -1,    84,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,    15,    -1,    17,
+      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    -1,    -1,    -1,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    -1,    -1,    51,    52,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    -1,    -1,
-      73,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    81,    82,
-      -1,    84,     4,     5,     6,    -1,    -1,    -1,    10,    11,
+      -1,    -1,    70,    -1,    -1,    -1,    74,    -1,    -1,    -1,
+      -1,    -1,    80,    81,    82,    -1,    84,     3,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      -1,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    32,    -1,    -1,    -1,
+      36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
+      46,    47,    48,    -1,    -1,    51,    52,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    80,    81,    82,    -1,    84,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    -1,
+      -1,    -1,    36,    37,    38,    39,    -1,    41,    42,    43,
+      44,    45,    46,    47,    48,    -1,    -1,    51,    52,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    80,    81,    82,    -1,
+      84,     3,     4,     5,     6,    -1,     8,     9,    10,    11,
       12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    21,
       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    -1,    -1,    -1,    -1,    -1,    38,    39,    -1,    41,
+      32,    -1,    -1,    -1,    36,    37,    38,    39,    -1,    41,
       42,    43,    44,    45,    46,    47,    48,    -1,    -1,    51,
       52,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,     4,
@@ -1223,35 +1132,56 @@
       45,    46,    47,    48,    -1,    -1,    51,    52,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    70,     4,     5,     6,    -1,
-      -1,    -1,    10,    11,    12,    -1,    81,    82,    -1,    84,
+      -1,    -1,    10,    11,    12,    80,    81,    82,    -1,    84,
       -1,    -1,    -1,    21,    22,    23,    24,    25,    26,    27,
       28,    29,    30,    31,    32,    -1,    -1,    -1,    -1,    -1,
-      38,    39,    -1,    41,    42,    -1,    44,     4,     5,     6,
+      38,    39,    -1,    41,    42,    43,    44,    45,    46,    47,
+      48,    -1,    -1,    51,    52,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    70,    -1,    -1,    73,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    81,    82,    -1,    84,     4,     5,     6,
       -1,    -1,    -1,    10,    11,    12,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    21,    22,    23,    24,    25,    26,
-      27,    28,    29,    30,    31,    32,    -1,    75,    -1,    -1,
-      -1,    38,    39,    -1,    41,    42,    -1,    44,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     0,    -1,
-      -1,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    75,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    -1,    -1,    -1,    36,    37,    38,    39,    -1,    41,
-      42,    -1,    44,     4,     5,     6,    -1,    -1,    -1,    10,
-      11,    12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-      31,    32,    -1,    -1,    -1,    -1,    -1,    38,    39,    -1,
-      41,    42,    43,    44,    -1,    -1,    -1,    48,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    -1,    -1,
-      -1,    36,    37,    38,    39,    -1,    41,    42,    -1,    44,
-       4,     5,     6,    -1,    -1,    -1,    10,    11,    12,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    21,    22,    23,
-      24,    25,    26,    27,    28,    29,    30,    31,    32,    -1,
-      10,    11,    12,    -1,    38,    39,    -1,    41,    42,    -1,
-      44,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      27,    28,    29,    30,    31,    32,    -1,    -1,    -1,    -1,
+      -1,    38,    39,    -1,    41,    42,    43,    44,    45,    46,
+      47,    48,    -1,    -1,    51,    52,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    70,     4,     5,     6,    -1,    -1,    -1,
+      10,    11,    12,    -1,    81,    82,    -1,    84,    -1,    -1,
+      -1,    21,    22,    23,    24,    25,    26,    27,    28,    29,
       30,    31,    32,    -1,    -1,    -1,    -1,    -1,    38,    39,
-      -1,    41,    42,    -1,    44
+      -1,    41,    42,    43,    44,    45,    46,    47,    48,    -1,
+      -1,    51,    52,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      70,     4,     5,     6,    -1,    -1,    -1,    10,    11,    12,
+      -1,    81,    82,    -1,    84,    -1,    -1,    -1,    21,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      -1,    -1,    -1,    -1,    -1,    38,    39,    -1,    41,    42,
+      -1,    44,     4,     5,     6,    -1,    -1,    -1,    10,    11,
+      12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    21,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    -1,    75,    -1,    -1,    -1,    38,    39,    -1,    41,
+      42,    -1,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,     0,    -1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    75,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    -1,    -1,    -1,    36,
+      37,    38,    39,    -1,    41,    42,    -1,    44,     4,     5,
+       6,    -1,    -1,    -1,    10,    11,    12,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    21,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    32,    -1,    -1,    -1,
+      -1,    -1,    38,    39,    -1,    41,    42,    43,    44,    -1,
+      -1,    -1,    48,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    -1,    -1,    -1,    36,    37,    38,    39,
+      -1,    41,    42,    -1,    44,     4,     5,     6,    -1,    -1,
+      -1,    10,    11,    12,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    -1,    10,    11,    12,    -1,    38,
+      39,    -1,    41,    42,    -1,    44,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    -1,    -1,
+      -1,    -1,    -1,    38,    39,    -1,    41,    42,    -1,    44
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -1262,10 +1192,10 @@
       12,    21,    22,    23,    24,    25,    26,    27,    28,    29,
       30,    31,    32,    36,    37,    38,    39,    41,    42,    44,
      124,   125,   126,   127,   128,   133,   134,   135,   136,   137,
-     138,   139,   140,   141,   168,   169,   170,    37,    43,   138,
-      43,    74,    80,   171,    71,    77,     3,    33,    34,    35,
+     138,   139,   140,   141,   171,   172,   173,    37,    43,   138,
+      43,    74,    80,   174,    71,    77,     3,    33,    34,    35,
      130,   131,   136,    77,    80,    43,   137,   139,    72,     0,
-     169,   139,    74,   137,   142,   143,    74,   154,   130,   129,
+     172,   139,    74,   137,   142,   143,    74,   157,   130,   129,
      132,   137,   131,    43,    70,    72,    79,    43,    45,    46,
       47,    48,    51,    52,    70,    81,    82,    84,    95,    96,
       97,    99,   100,   101,   102,   103,   104,   105,   106,   107,
@@ -1273,21 +1203,21 @@
      118,   119,   123,   137,    80,   142,    43,   144,   145,    75,
      143,    13,    14,    15,    17,    18,    19,    20,    40,    74,
       75,    80,   106,   119,   120,   122,   124,   125,   137,   147,
-     148,   149,   150,   155,   156,   157,   160,   167,    43,   129,
+     148,   149,   150,   158,   159,   160,   163,   170,    43,   129,
      132,    72,    79,    73,   123,   120,   146,   106,   106,   122,
       51,    52,    72,    76,    71,    71,    77,    39,   120,    70,
      106,    85,    86,    82,    84,    53,    54,    88,    89,    55,
       56,    57,    59,    58,    93,    73,    75,    72,    77,    80,
-      80,    80,   162,    70,    70,    80,    80,   122,    70,    75,
+      80,    80,   165,    70,    70,    80,    80,   122,    70,    75,
      151,    60,    61,    62,    69,    79,   121,    77,    80,    75,
      148,    72,    73,   123,   146,    73,    71,    98,   122,    43,
       48,   101,   120,   106,   106,   108,   108,   110,   110,   110,
-     110,   111,   111,   115,   116,   117,   122,   123,   145,   148,
-     163,   122,    80,   161,   155,   120,   120,   123,    73,    73,
-      78,    73,    40,   147,   156,   164,    71,   122,   135,   159,
-     152,    73,   120,    70,   159,   165,   166,   148,   158,    43,
-      71,    75,   122,    80,    71,    16,    79,   149,   153,   154,
-      71,   122,   153,   148,   146,    80
+     110,   111,   111,   115,   116,   117,   122,   123,   145,   154,
+     155,   156,   166,   122,    80,   164,   158,   120,   120,   123,
+      73,    73,    78,    73,    40,   157,   149,   147,   159,   167,
+      71,   122,   135,   162,   152,    73,   120,    70,   162,   168,
+     169,   154,   161,    43,    71,    75,   122,    80,    71,    16,
+      79,   149,   153,   157,    71,   122,   153,   154,   146,    80
 };
 
 #define yyerrok		(yyerrstatus = 0)
@@ -1302,9 +1232,18 @@
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  */
+   Once GCC version 2 has supplanted version 1, this can go.  However,
+   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
+   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
+   discussed.  */
 
 #define YYFAIL		goto yyerrlab
+#if defined YYFAIL
+  /* This is here to suppress warnings from the GCC cpp's
+     -Wunused-macros.  Normally we don't worry about that warning, but
+     some users do, and we want to make it easy for users to remove
+     YYFAIL uses, which will produce warnings from Bison 2.5.  */
+#endif
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
@@ -1475,17 +1414,20 @@
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
 #else
 static void
-yy_stack_print (bottom, top)
-    yytype_int16 *bottom;
-    yytype_int16 *top;
+yy_stack_print (yybottom, yytop)
+    yytype_int16 *yybottom;
+    yytype_int16 *yytop;
 #endif
 {
   YYFPRINTF (stderr, "Stack now");
-  for (; bottom <= top; ++bottom)
-    YYFPRINTF (stderr, " %d", *bottom);
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
   YYFPRINTF (stderr, "\n");
 }
 
@@ -1520,11 +1462,11 @@
   /* The symbols being reduced.  */
   for (yyi = 0; yyi < yynrhs; yyi++)
     {
-      fprintf (stderr, "   $%d = ", yyi + 1);
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 		       &(yyvsp[(yyi + 1) - (yynrhs)])
 		       		       , context);
-      fprintf (stderr, "\n");
+      YYFPRINTF (stderr, "\n");
     }
 }
 
@@ -1806,10 +1748,8 @@
 	break;
     }
 }
-
 
 /* Prevent warnings from -Wmissing-prototypes.  */
-
 #ifdef YYPARSE_PARAM
 #if defined __STDC__ || defined __cplusplus
 int yyparse (void *YYPARSE_PARAM);
@@ -1828,10 +1768,9 @@
 
 
 
-
-/*----------.
-| yyparse.  |
-`----------*/
+/*-------------------------.
+| yyparse or yypush_parse.  |
+`-------------------------*/
 
 #ifdef YYPARSE_PARAM
 #if (defined __STDC__ || defined __C99__FUNC__ \
@@ -1855,22 +1794,46 @@
 #endif
 #endif
 {
-  /* The look-ahead symbol.  */
+/* The lookahead symbol.  */
 int yychar;
 
-/* The semantic value of the look-ahead symbol.  */
+/* The semantic value of the lookahead symbol.  */
 YYSTYPE yylval;
 
-/* Number of syntax errors so far.  */
-int yynerrs;
+    /* Number of syntax errors so far.  */
+    int yynerrs;
 
-  int yystate;
+    int yystate;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus;
+
+    /* The stacks and their tools:
+       `yyss': related to states.
+       `yyvs': related to semantic values.
+
+       Refer to the stacks thru separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* The state stack.  */
+    yytype_int16 yyssa[YYINITDEPTH];
+    yytype_int16 *yyss;
+    yytype_int16 *yyssp;
+
+    /* The semantic value stack.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs;
+    YYSTYPE *yyvsp;
+
+    YYSIZE_T yystacksize;
+
   int yyn;
   int yyresult;
-  /* Number of tokens to shift before error messages enabled.  */
-  int yyerrstatus;
-  /* Look-ahead token as an internal (translated) token number.  */
-  int yytoken = 0;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
 #if YYERROR_VERBOSE
   /* Buffer for error messages, and its allocated size.  */
   char yymsgbuf[128];
@@ -1878,51 +1841,28 @@
   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 #endif
 
-  /* Three stacks and their tools:
-     `yyss': related to states,
-     `yyvs': related to semantic values,
-     `yyls': related to locations.
-
-     Refer to the stacks thru separate pointers, to allow yyoverflow
-     to reallocate them elsewhere.  */
-
-  /* The state stack.  */
-  yytype_int16 yyssa[YYINITDEPTH];
-  yytype_int16 *yyss = yyssa;
-  yytype_int16 *yyssp;
-
-  /* The semantic value stack.  */
-  YYSTYPE yyvsa[YYINITDEPTH];
-  YYSTYPE *yyvs = yyvsa;
-  YYSTYPE *yyvsp;
-
-
-
 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 
-  YYSIZE_T yystacksize = YYINITDEPTH;
-
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-
-
   /* The number of symbols on the RHS of the reduced rule.
      Keep to zero when no symbol should be popped.  */
   int yylen = 0;
 
+  yytoken = 0;
+  yyss = yyssa;
+  yyvs = yyvsa;
+  yystacksize = YYINITDEPTH;
+
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
-  yychar = YYEMPTY;		/* Cause a token to be read.  */
+  yychar = YYEMPTY; /* Cause a token to be read.  */
 
   /* Initialize stack pointers.
      Waste one element of value and location stack
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */
-
   yyssp = yyss;
   yyvsp = yyvs;
 
@@ -1952,7 +1892,6 @@
 	YYSTYPE *yyvs1 = yyvs;
 	yytype_int16 *yyss1 = yyss;
 
-
 	/* Each stack pointer address is followed by the size of the
 	   data in use in that stack, in bytes.  This used to be a
 	   conditional around just the two extra args, but that might
@@ -1960,7 +1899,6 @@
 	yyoverflow (YY_("memory exhausted"),
 		    &yyss1, yysize * sizeof (*yyssp),
 		    &yyvs1, yysize * sizeof (*yyvsp),
-
 		    &yystacksize);
 
 	yyss = yyss1;
@@ -1983,9 +1921,8 @@
 	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 	if (! yyptr)
 	  goto yyexhaustedlab;
-	YYSTACK_RELOCATE (yyss);
-	YYSTACK_RELOCATE (yyvs);
-
+	YYSTACK_RELOCATE (yyss_alloc, yyss);
+	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
 #  undef YYSTACK_RELOCATE
 	if (yyss1 != yyssa)
 	  YYSTACK_FREE (yyss1);
@@ -1996,7 +1933,6 @@
       yyssp = yyss + yysize - 1;
       yyvsp = yyvs + yysize - 1;
 
-
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 		  (unsigned long int) yystacksize));
 
@@ -2006,6 +1942,9 @@
 
   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
   goto yybackup;
 
 /*-----------.
@@ -2014,16 +1953,16 @@
 yybackup:
 
   /* Do appropriate processing given the current state.  Read a
-     look-ahead token if we need one and don't already have one.  */
+     lookahead token if we need one and don't already have one.  */
 
-  /* First try to decide what to do without reference to look-ahead token.  */
+  /* First try to decide what to do without reference to lookahead token.  */
   yyn = yypact[yystate];
   if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a look-ahead token if don't already have one.  */
+  /* Not known => get a lookahead token if don't already have one.  */
 
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
   if (yychar == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
@@ -2055,20 +1994,16 @@
       goto yyreduce;
     }
 
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
   /* Count tokens shifted since error; after three, turn off error
      status.  */
   if (yyerrstatus)
     yyerrstatus--;
 
-  /* Shift the look-ahead token.  */
+  /* Shift the lookahead token.  */
   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
-  /* Discard the shifted token unless it is eof.  */
-  if (yychar != YYEOF)
-    yychar = YYEMPTY;
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
 
   yystate = yyn;
   *++yyvsp = yylval;
@@ -2140,14 +2075,14 @@
             (yyval.interm.intermTypedNode) = context->intermediate.addSymbol(variable->getUniqueId(),
                                                      variable->getName(),
                                                      variable->getType(), (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 3:
 
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 4:
@@ -2164,7 +2099,7 @@
         ConstantUnion *unionArray = new ConstantUnion[1];
         unionArray->setIConst((yyvsp[(1) - (1)].lex).i);
         (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 5:
@@ -2173,7 +2108,7 @@
         ConstantUnion *unionArray = new ConstantUnion[1];
         unionArray->setFConst((yyvsp[(1) - (1)].lex).f);
         (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpUndefined, EvqConst), (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 6:
@@ -2182,21 +2117,21 @@
         ConstantUnion *unionArray = new ConstantUnion[1];
         unionArray->setBConst((yyvsp[(1) - (1)].lex).b);
         (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 7:
 
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(2) - (3)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 8:
 
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 9:
@@ -2273,14 +2208,14 @@
             (yyval.interm.intermTypedNode)->setType(TType((yyvsp[(1) - (4)].interm.intermTypedNode)->getBasicType(), (yyvsp[(1) - (4)].interm.intermTypedNode)->getPrecision(), EvqTemporary));
         else
             (yyval.interm.intermTypedNode)->setType((yyvsp[(1) - (4)].interm.intermTypedNode)->getType());
-    ;}
+    }
     break;
 
   case 10:
 
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 11:
@@ -2393,7 +2328,7 @@
             (yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
         }
         // don't delete $3.string, it's from the pool
-    ;}
+    }
     break;
 
   case 12:
@@ -2407,7 +2342,7 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(1) - (2)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 13:
@@ -2421,7 +2356,7 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(1) - (2)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 14:
@@ -2430,7 +2365,7 @@
         if (context->integerErrorCheck((yyvsp[(1) - (1)].interm.intermTypedNode), "[]"))
             context->recover();
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 15:
@@ -2530,14 +2465,14 @@
             }
         }
         delete fnCall;
-    ;}
+    }
     break;
 
   case 16:
 
     {
         (yyval.interm) = (yyvsp[(1) - (1)].interm);
-    ;}
+    }
     break;
 
   case 17:
@@ -2546,7 +2481,7 @@
         context->error((yyvsp[(3) - (3)].interm).line, "methods are not supported", "", "");
         context->recover();
         (yyval.interm) = (yyvsp[(3) - (3)].interm);
-    ;}
+    }
     break;
 
   case 18:
@@ -2554,7 +2489,7 @@
     {
         (yyval.interm) = (yyvsp[(1) - (2)].interm);
         (yyval.interm).line = (yyvsp[(2) - (2)].lex).line;
-    ;}
+    }
     break;
 
   case 19:
@@ -2562,7 +2497,7 @@
     {
         (yyval.interm) = (yyvsp[(1) - (2)].interm);
         (yyval.interm).line = (yyvsp[(2) - (2)].lex).line;
-    ;}
+    }
     break;
 
   case 20:
@@ -2570,7 +2505,7 @@
     {
         (yyval.interm).function = (yyvsp[(1) - (2)].interm.function);
         (yyval.interm).intermNode = 0;
-    ;}
+    }
     break;
 
   case 21:
@@ -2578,7 +2513,7 @@
     {
         (yyval.interm).function = (yyvsp[(1) - (1)].interm.function);
         (yyval.interm).intermNode = 0;
-    ;}
+    }
     break;
 
   case 22:
@@ -2588,7 +2523,7 @@
         (yyvsp[(1) - (2)].interm.function)->addParameter(param);
         (yyval.interm).function = (yyvsp[(1) - (2)].interm.function);
         (yyval.interm).intermNode = (yyvsp[(2) - (2)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 23:
@@ -2598,14 +2533,14 @@
         (yyvsp[(1) - (3)].interm).function->addParameter(param);
         (yyval.interm).function = (yyvsp[(1) - (3)].interm).function;
         (yyval.interm).intermNode = context->intermediate.growAggregate((yyvsp[(1) - (3)].interm).intermNode, (yyvsp[(3) - (3)].interm.intermTypedNode), (yyvsp[(2) - (3)].lex).line);
-    ;}
+    }
     break;
 
   case 24:
 
     {
         (yyval.interm.function) = (yyvsp[(1) - (2)].interm.function);
-    ;}
+    }
     break;
 
   case 25:
@@ -2671,7 +2606,7 @@
         TType type((yyvsp[(1) - (1)].interm.type));
         TFunction *function = new TFunction(&tempString, type, op);
         (yyval.interm.function) = function;
-    ;}
+    }
     break;
 
   case 26:
@@ -2682,7 +2617,7 @@
         TType type(EbtVoid, EbpUndefined);
         TFunction *function = new TFunction((yyvsp[(1) - (1)].lex).string, type);
         (yyval.interm.function) = function;
-    ;}
+    }
     break;
 
   case 27:
@@ -2693,14 +2628,14 @@
         TType type(EbtVoid, EbpUndefined);
         TFunction *function = new TFunction((yyvsp[(1) - (1)].lex).string, type);
         (yyval.interm.function) = function;
-    ;}
+    }
     break;
 
   case 28:
 
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 29:
@@ -2714,7 +2649,7 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(2) - (2)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 30:
@@ -2728,7 +2663,7 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(2) - (2)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 31:
@@ -2749,27 +2684,27 @@
             }
         } else
             (yyval.interm.intermTypedNode) = (yyvsp[(2) - (2)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 32:
 
-    { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpNull; ;}
+    { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpNull; }
     break;
 
   case 33:
 
-    { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpNegative; ;}
+    { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpNegative; }
     break;
 
   case 34:
 
-    { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpLogicalNot; ;}
+    { (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpLogicalNot; }
     break;
 
   case 35:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 36:
@@ -2782,7 +2717,7 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 37:
@@ -2795,12 +2730,12 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 38:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 39:
@@ -2812,7 +2747,7 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 40:
@@ -2824,17 +2759,17 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 41:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 42:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 43:
@@ -2848,7 +2783,7 @@
             unionArray->setBConst(false);
             (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 44:
@@ -2862,7 +2797,7 @@
             unionArray->setBConst(false);
             (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 45:
@@ -2876,7 +2811,7 @@
             unionArray->setBConst(false);
             (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 46:
@@ -2890,12 +2825,12 @@
             unionArray->setBConst(false);
             (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 47:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 48:
@@ -2909,7 +2844,7 @@
             unionArray->setBConst(false);
             (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 49:
@@ -2923,27 +2858,27 @@
             unionArray->setBConst(false);
             (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 50:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 51:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 52:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 53:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 54:
@@ -2957,12 +2892,12 @@
             unionArray->setBConst(false);
             (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 55:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 56:
@@ -2976,12 +2911,12 @@
             unionArray->setBConst(false);
             (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 57:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 58:
@@ -2995,12 +2930,12 @@
             unionArray->setBConst(false);
             (yyval.interm.intermTypedNode) = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), (yyvsp[(2) - (3)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 59:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 60:
@@ -3018,12 +2953,12 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(5) - (5)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 61:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 62:
@@ -3037,39 +2972,39 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(1) - (3)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 63:
 
-    {                                    (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpAssign; ;}
+    {                                    (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpAssign; }
     break;
 
   case 64:
 
-    { FRAG_VERT_ONLY("*=", (yyvsp[(1) - (1)].lex).line);     (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpMulAssign; ;}
+    { FRAG_VERT_ONLY("*=", (yyvsp[(1) - (1)].lex).line);     (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpMulAssign; }
     break;
 
   case 65:
 
-    { FRAG_VERT_ONLY("/=", (yyvsp[(1) - (1)].lex).line);     (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpDivAssign; ;}
+    { FRAG_VERT_ONLY("/=", (yyvsp[(1) - (1)].lex).line);     (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpDivAssign; }
     break;
 
   case 66:
 
-    {                                    (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpAddAssign; ;}
+    {                                    (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpAddAssign; }
     break;
 
   case 67:
 
-    {                                    (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpSubAssign; ;}
+    {                                    (yyval.interm).line = (yyvsp[(1) - (1)].lex).line; (yyval.interm).op = EOpSubAssign; }
     break;
 
   case 68:
 
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 69:
@@ -3081,7 +3016,7 @@
             context->recover();
             (yyval.interm.intermTypedNode) = (yyvsp[(3) - (3)].interm.intermTypedNode);
         }
-    ;}
+    }
     break;
 
   case 70:
@@ -3090,7 +3025,7 @@
         if (context->constErrorCheck((yyvsp[(1) - (1)].interm.intermTypedNode)))
             context->recover();
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
-    ;}
+    }
     break;
 
   case 71:
@@ -3119,7 +3054,9 @@
         
         prototype->setOp(EOpPrototype);
         (yyval.interm.intermNode) = prototype;
-    ;}
+
+		context->symbolTable.pop();
+    }
     break;
 
   case 72:
@@ -3128,7 +3065,7 @@
         if ((yyvsp[(1) - (2)].interm).intermAggregate)
             (yyvsp[(1) - (2)].interm).intermAggregate->setOp(EOpDeclaration);
         (yyval.interm.intermNode) = (yyvsp[(1) - (2)].interm).intermAggregate;
-    ;}
+    }
     break;
 
   case 73:
@@ -3136,7 +3073,7 @@
     {
         context->symbolTable.setDefaultPrecision( (yyvsp[(3) - (4)].interm.type).type, (yyvsp[(2) - (4)].interm.precision) );
         (yyval.interm.intermNode) = 0;
-    ;}
+    }
     break;
 
   case 74:
@@ -3172,22 +3109,24 @@
         (yyval.interm).function = (yyvsp[(1) - (2)].interm.function);
         (yyval.interm).line = (yyvsp[(2) - (2)].lex).line;
 
-        context->symbolTable.insert(*(yyval.interm).function);
-    ;}
+        // We're at the inner scope level of the function's arguments and body statement.
+        // Add the function prototype to the surrounding scope instead.
+        context->symbolTable.getOuterLevel()->insert(*(yyval.interm).function);
+    }
     break;
 
   case 75:
 
     {
         (yyval.interm.function) = (yyvsp[(1) - (1)].interm.function);
-    ;}
+    }
     break;
 
   case 76:
 
     {
         (yyval.interm.function) = (yyvsp[(1) - (1)].interm.function);
-    ;}
+    }
     break;
 
   case 77:
@@ -3199,7 +3138,7 @@
             (yyvsp[(1) - (2)].interm.function)->addParameter((yyvsp[(2) - (2)].interm).param);
         else
             delete (yyvsp[(2) - (2)].interm).param.type;
-    ;}
+    }
     break;
 
   case 78:
@@ -3221,7 +3160,7 @@
             (yyval.interm.function) = (yyvsp[(1) - (3)].interm.function);
             (yyvsp[(1) - (3)].interm.function)->addParameter((yyvsp[(3) - (3)].interm).param);
         }
-    ;}
+    }
     break;
 
   case 79:
@@ -3240,7 +3179,9 @@
         TType type((yyvsp[(1) - (3)].interm.type));
         function = new TFunction((yyvsp[(2) - (3)].lex).string, type);
         (yyval.interm.function) = function;
-    ;}
+
+		context->symbolTable.push();
+    }
     break;
 
   case 80:
@@ -3255,7 +3196,7 @@
         TParameter param = {(yyvsp[(2) - (2)].lex).string, new TType((yyvsp[(1) - (2)].interm.type))};
         (yyval.interm).line = (yyvsp[(2) - (2)].lex).line;
         (yyval.interm).param = param;
-    ;}
+    }
     break;
 
   case 81:
@@ -3277,7 +3218,7 @@
         TParameter param = { (yyvsp[(2) - (5)].lex).string, type };
         (yyval.interm).line = (yyvsp[(2) - (5)].lex).line;
         (yyval.interm).param = param;
-    ;}
+    }
     break;
 
   case 82:
@@ -3286,7 +3227,7 @@
         (yyval.interm) = (yyvsp[(3) - (3)].interm);
         if (context->paramErrorCheck((yyvsp[(3) - (3)].interm).line, (yyvsp[(1) - (3)].interm.type).qualifier, (yyvsp[(2) - (3)].interm.qualifier), (yyval.interm).param.type))
             context->recover();
-    ;}
+    }
     break;
 
   case 83:
@@ -3297,7 +3238,7 @@
             context->recover();
         if (context->paramErrorCheck((yyvsp[(2) - (2)].interm).line, EvqTemporary, (yyvsp[(1) - (2)].interm.qualifier), (yyval.interm).param.type))
             context->recover();
-    ;}
+    }
     break;
 
   case 84:
@@ -3306,7 +3247,7 @@
         (yyval.interm) = (yyvsp[(3) - (3)].interm);
         if (context->paramErrorCheck((yyvsp[(3) - (3)].interm).line, (yyvsp[(1) - (3)].interm.type).qualifier, (yyvsp[(2) - (3)].interm.qualifier), (yyval.interm).param.type))
             context->recover();
-    ;}
+    }
     break;
 
   case 85:
@@ -3317,35 +3258,35 @@
             context->recover();
         if (context->paramErrorCheck((yyvsp[(2) - (2)].interm).line, EvqTemporary, (yyvsp[(1) - (2)].interm.qualifier), (yyval.interm).param.type))
             context->recover();
-    ;}
+    }
     break;
 
   case 86:
 
     {
         (yyval.interm.qualifier) = EvqIn;
-    ;}
+    }
     break;
 
   case 87:
 
     {
         (yyval.interm.qualifier) = EvqIn;
-    ;}
+    }
     break;
 
   case 88:
 
     {
         (yyval.interm.qualifier) = EvqOut;
-    ;}
+    }
     break;
 
   case 89:
 
     {
         (yyval.interm.qualifier) = EvqInOut;
-    ;}
+    }
     break;
 
   case 90:
@@ -3353,7 +3294,7 @@
     {
         TParameter param = { 0, new TType((yyvsp[(1) - (1)].interm.type)) };
         (yyval.interm).param = param;
-    ;}
+    }
     break;
 
   case 91:
@@ -3367,12 +3308,18 @@
                 context->recover();
             }
         }
-    ;}
+    }
     break;
 
   case 92:
 
     {
+        if ((yyvsp[(1) - (3)].interm).type.type == EbtInvariant && !(yyvsp[(3) - (3)].lex).symbol)
+        {
+            context->error((yyvsp[(3) - (3)].lex).line, "undeclared identifier declared as invariant", (yyvsp[(3) - (3)].lex).string->c_str(), "");
+            context->recover();
+        }
+
         TIntermSymbol* symbol = context->intermediate.addSymbol(0, *(yyvsp[(3) - (3)].lex).string, TType((yyvsp[(1) - (3)].interm).type), (yyvsp[(3) - (3)].lex).line);
         (yyval.interm).intermAggregate = context->intermediate.growAggregate((yyvsp[(1) - (3)].interm).intermNode, symbol, (yyvsp[(3) - (3)].lex).line);
         
@@ -3387,7 +3334,7 @@
             context->recover();
         if (symbol && variable)
             symbol->setId(variable->getUniqueId());
-    ;}
+    }
     break;
 
   case 93:
@@ -3409,7 +3356,7 @@
             if (context->arrayErrorCheck((yyvsp[(4) - (5)].lex).line, *(yyvsp[(3) - (5)].lex).string, (yyvsp[(1) - (5)].interm).type, variable))
                 context->recover();
         }
-    ;}
+    }
     break;
 
   case 94:
@@ -3437,7 +3384,7 @@
             type.setArraySize(size);
             (yyval.interm).intermAggregate = context->intermediate.growAggregate((yyvsp[(1) - (6)].interm).intermNode, context->intermediate.addSymbol(variable ? variable->getUniqueId() : 0, *(yyvsp[(3) - (6)].lex).string, type, (yyvsp[(3) - (6)].lex).line), (yyvsp[(3) - (6)].lex).line);
         }
-    ;}
+    }
     break;
 
   case 95:
@@ -3461,7 +3408,7 @@
             context->recover();
             (yyval.interm).intermAggregate = 0;
         }
-    ;}
+    }
     break;
 
   case 96:
@@ -3469,7 +3416,7 @@
     {
         (yyval.interm).type = (yyvsp[(1) - (1)].interm.type);
         (yyval.interm).intermAggregate = context->intermediate.makeAggregate(context->intermediate.addSymbol(0, "", TType((yyvsp[(1) - (1)].interm.type)), (yyvsp[(1) - (1)].interm.type).line), (yyvsp[(1) - (1)].interm.type).line);
-    ;}
+    }
     break;
 
   case 97:
@@ -3491,7 +3438,7 @@
             context->recover();
         if (variable && symbol)
             symbol->setId(variable->getUniqueId());
-    ;}
+    }
     break;
 
   case 98:
@@ -3503,7 +3450,7 @@
         TIntermSymbol* symbol = context->intermediate.addSymbol(0, *(yyvsp[(2) - (4)].lex).string, TType((yyvsp[(1) - (4)].interm.type)), (yyvsp[(2) - (4)].lex).line);
         (yyval.interm).intermAggregate = context->intermediate.makeAggregate(symbol, (yyvsp[(2) - (4)].lex).line);
         (yyval.interm).type = (yyvsp[(1) - (4)].interm.type);
-    ;}
+    }
     break;
 
   case 99:
@@ -3539,7 +3486,7 @@
             if (variable && symbol)
                 symbol->setId(variable->getUniqueId());
         }
-    ;}
+    }
     break;
 
   case 100:
@@ -3563,16 +3510,29 @@
             context->recover();
             (yyval.interm).intermAggregate = 0;
         }
-    ;}
+    }
     break;
 
   case 101:
 
     {
         VERTEX_ONLY("invariant declaration", (yyvsp[(1) - (2)].lex).line);
-        (yyval.interm).qualifier = EvqInvariantVaryingOut;
-        (yyval.interm).intermAggregate = 0;
-    ;}
+        if (context->globalErrorCheck((yyvsp[(1) - (2)].lex).line, context->symbolTable.atGlobalLevel(), "invariant varying"))
+            context->recover();
+        (yyval.interm).type.setBasic(EbtInvariant, EvqInvariantVaryingOut, (yyvsp[(2) - (2)].lex).line);
+        if (!(yyvsp[(2) - (2)].lex).symbol)
+        {
+            context->error((yyvsp[(2) - (2)].lex).line, "undeclared identifier declared as invariant", (yyvsp[(2) - (2)].lex).string->c_str(), "");
+            context->recover();
+            
+            (yyval.interm).intermAggregate = 0;
+        }
+        else
+        {
+            TIntermSymbol *symbol = context->intermediate.addSymbol(0, *(yyvsp[(2) - (2)].lex).string, TType((yyval.interm).type), (yyvsp[(2) - (2)].lex).line);
+            (yyval.interm).intermAggregate = context->intermediate.makeAggregate(symbol, (yyvsp[(2) - (2)].lex).line);
+        }
+    }
     break;
 
   case 102:
@@ -3585,7 +3545,7 @@
             context->recover();
             (yyvsp[(1) - (1)].interm.type).setArray(false);
         }
-    ;}
+    }
     break;
 
   case 103:
@@ -3609,14 +3569,14 @@
         }
         (yyval.interm.type) = (yyvsp[(2) - (2)].interm.type);
         (yyval.interm.type).qualifier = (yyvsp[(1) - (2)].interm.type).qualifier;
-    ;}
+    }
     break;
 
   case 104:
 
     {
         (yyval.interm.type).setBasic(EbtVoid, EvqConst, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 105:
@@ -3626,7 +3586,7 @@
         if (context->globalErrorCheck((yyvsp[(1) - (1)].lex).line, context->symbolTable.atGlobalLevel(), "attribute"))
             context->recover();
         (yyval.interm.type).setBasic(EbtVoid, EvqAttribute, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 106:
@@ -3638,7 +3598,7 @@
             (yyval.interm.type).setBasic(EbtVoid, EvqVaryingOut, (yyvsp[(1) - (1)].lex).line);
         else
             (yyval.interm.type).setBasic(EbtVoid, EvqVaryingIn, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 107:
@@ -3650,7 +3610,7 @@
             (yyval.interm.type).setBasic(EbtVoid, EvqInvariantVaryingOut, (yyvsp[(1) - (2)].lex).line);
         else
             (yyval.interm.type).setBasic(EbtVoid, EvqInvariantVaryingIn, (yyvsp[(1) - (2)].lex).line);
-    ;}
+    }
     break;
 
   case 108:
@@ -3659,14 +3619,14 @@
         if (context->globalErrorCheck((yyvsp[(1) - (1)].lex).line, context->symbolTable.atGlobalLevel(), "uniform"))
             context->recover();
         (yyval.interm.type).setBasic(EbtVoid, EvqUniform, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 109:
 
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
-    ;}
+    }
     break;
 
   case 110:
@@ -3674,35 +3634,35 @@
     {
         (yyval.interm.type) = (yyvsp[(2) - (2)].interm.type);
         (yyval.interm.type).precision = (yyvsp[(1) - (2)].interm.precision);
-    ;}
+    }
     break;
 
   case 111:
 
     {
         (yyval.interm.precision) = EbpHigh;
-    ;}
+    }
     break;
 
   case 112:
 
     {
         (yyval.interm.precision) = EbpMedium;
-    ;}
+    }
     break;
 
   case 113:
 
     {
         (yyval.interm.precision) = EbpLow;
-    ;}
+    }
     break;
 
   case 114:
 
     {
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
-    ;}
+    }
     break;
 
   case 115:
@@ -3718,7 +3678,7 @@
                 context->recover();
             (yyval.interm.type).setArray(true, size);
         }
-    ;}
+    }
     break;
 
   case 116:
@@ -3726,7 +3686,7 @@
     {
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtVoid, qual, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 117:
@@ -3734,7 +3694,7 @@
     {
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 118:
@@ -3742,7 +3702,7 @@
     {
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtInt, qual, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 119:
@@ -3750,7 +3710,7 @@
     {
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtBool, qual, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 120:
@@ -3759,7 +3719,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(2);
-    ;}
+    }
     break;
 
   case 121:
@@ -3768,7 +3728,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(3);
-    ;}
+    }
     break;
 
   case 122:
@@ -3777,7 +3737,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(4);
-    ;}
+    }
     break;
 
   case 123:
@@ -3786,7 +3746,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtBool, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(2);
-    ;}
+    }
     break;
 
   case 124:
@@ -3795,7 +3755,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtBool, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(3);
-    ;}
+    }
     break;
 
   case 125:
@@ -3804,7 +3764,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtBool, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(4);
-    ;}
+    }
     break;
 
   case 126:
@@ -3813,7 +3773,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtInt, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(2);
-    ;}
+    }
     break;
 
   case 127:
@@ -3822,7 +3782,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtInt, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(3);
-    ;}
+    }
     break;
 
   case 128:
@@ -3831,7 +3791,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtInt, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(4);
-    ;}
+    }
     break;
 
   case 129:
@@ -3841,7 +3801,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(2, true);
-    ;}
+    }
     break;
 
   case 130:
@@ -3851,7 +3811,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(3, true);
-    ;}
+    }
     break;
 
   case 131:
@@ -3861,7 +3821,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtFloat, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).setAggregate(4, true);
-    ;}
+    }
     break;
 
   case 132:
@@ -3870,7 +3830,7 @@
         FRAG_VERT_ONLY("sampler2D", (yyvsp[(1) - (1)].lex).line);
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtSampler2D, qual, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 133:
@@ -3879,7 +3839,7 @@
         FRAG_VERT_ONLY("samplerCube", (yyvsp[(1) - (1)].lex).line);
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtSamplerCube, qual, (yyvsp[(1) - (1)].lex).line);
-    ;}
+    }
     break;
 
   case 134:
@@ -3888,7 +3848,7 @@
         FRAG_VERT_ONLY("struct", (yyvsp[(1) - (1)].interm.type).line);
         (yyval.interm.type) = (yyvsp[(1) - (1)].interm.type);
         (yyval.interm.type).qualifier = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
-    ;}
+    }
     break;
 
   case 135:
@@ -3902,7 +3862,7 @@
         TQualifier qual = context->symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
         (yyval.interm.type).setBasic(EbtStruct, qual, (yyvsp[(1) - (1)].lex).line);
         (yyval.interm.type).userDef = &structure;
-    ;}
+    }
     break;
 
   case 136:
@@ -3919,7 +3879,7 @@
         }
         (yyval.interm.type).setBasic(EbtStruct, EvqTemporary, (yyvsp[(1) - (5)].lex).line);
         (yyval.interm.type).userDef = structure;
-    ;}
+    }
     break;
 
   case 137:
@@ -3928,14 +3888,14 @@
         TType* structure = new TType((yyvsp[(3) - (4)].interm.typeList), TString(""));
         (yyval.interm.type).setBasic(EbtStruct, EvqTemporary, (yyvsp[(1) - (4)].lex).line);
         (yyval.interm.type).userDef = structure;
-    ;}
+    }
     break;
 
   case 138:
 
     {
         (yyval.interm.typeList) = (yyvsp[(1) - (1)].interm.typeList);
-    ;}
+    }
     break;
 
   case 139:
@@ -3951,7 +3911,7 @@
             }
             (yyval.interm.typeList)->push_back((*(yyvsp[(2) - (2)].interm.typeList))[i]);
         }
-    ;}
+    }
     break;
 
   case 140:
@@ -3983,7 +3943,7 @@
                 type->setTypeName((yyvsp[(1) - (3)].interm.type).userDef->getTypeName());
             }
         }
-    ;}
+    }
     break;
 
   case 141:
@@ -3991,14 +3951,14 @@
     {
         (yyval.interm.typeList) = NewPoolTTypeList();
         (yyval.interm.typeList)->push_back((yyvsp[(1) - (1)].interm.typeLine));
-    ;}
+    }
     break;
 
   case 142:
 
     {
         (yyval.interm.typeList)->push_back((yyvsp[(3) - (3)].interm.typeLine));
-    ;}
+    }
     break;
 
   case 143:
@@ -4010,7 +3970,7 @@
         (yyval.interm.typeLine).type = new TType(EbtVoid, EbpUndefined);
         (yyval.interm.typeLine).line = (yyvsp[(1) - (1)].lex).line;
         (yyval.interm.typeLine).type->setFieldName(*(yyvsp[(1) - (1)].lex).string);
-    ;}
+    }
     break;
 
   case 144:
@@ -4027,67 +3987,67 @@
         if (context->arraySizeErrorCheck((yyvsp[(2) - (4)].lex).line, (yyvsp[(3) - (4)].interm.intermTypedNode), size))
             context->recover();
         (yyval.interm.typeLine).type->setArraySize(size);
-    ;}
+    }
     break;
 
   case 145:
 
-    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); ;}
+    { (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode); }
     break;
 
   case 146:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
   case 147:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermAggregate); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermAggregate); }
     break;
 
   case 148:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
   case 149:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
   case 150:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
   case 151:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
   case 152:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
   case 153:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
   case 154:
 
-    { (yyval.interm.intermAggregate) = 0; ;}
+    { (yyval.interm.intermAggregate) = 0; }
     break;
 
   case 155:
 
-    { context->symbolTable.push(); ;}
+    { context->symbolTable.push(); }
     break;
 
   case 156:
 
-    { context->symbolTable.pop(); ;}
+    { context->symbolTable.pop(); }
     break;
 
   case 157:
@@ -4098,96 +4058,116 @@
             (yyvsp[(3) - (5)].interm.intermAggregate)->setEndLine((yyvsp[(5) - (5)].lex).line);
         }
         (yyval.interm.intermAggregate) = (yyvsp[(3) - (5)].interm.intermAggregate);
-    ;}
+    }
     break;
 
   case 158:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
   case 159:
 
-    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); ;}
+    { (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode); }
     break;
 
   case 160:
 
-    {
-        (yyval.interm.intermNode) = 0;
-    ;}
+    { context->symbolTable.push(); }
     break;
 
   case 161:
 
+    { context->symbolTable.pop(); (yyval.interm.intermNode) = (yyvsp[(2) - (2)].interm.intermNode); }
+    break;
+
+  case 162:
+
+    { context->symbolTable.push(); }
+    break;
+
+  case 163:
+
+    { context->symbolTable.pop(); (yyval.interm.intermNode) = (yyvsp[(2) - (2)].interm.intermNode); }
+    break;
+
+  case 164:
+
+    {
+        (yyval.interm.intermNode) = 0;
+    }
+    break;
+
+  case 165:
+
     {
         if ((yyvsp[(2) - (3)].interm.intermAggregate)) {
             (yyvsp[(2) - (3)].interm.intermAggregate)->setOp(EOpSequence);
             (yyvsp[(2) - (3)].interm.intermAggregate)->setEndLine((yyvsp[(3) - (3)].lex).line);
         }
         (yyval.interm.intermNode) = (yyvsp[(2) - (3)].interm.intermAggregate);
-    ;}
-    break;
-
-  case 162:
-
-    {
-        (yyval.interm.intermAggregate) = context->intermediate.makeAggregate((yyvsp[(1) - (1)].interm.intermNode), 0);
-    ;}
-    break;
-
-  case 163:
-
-    {
-        (yyval.interm.intermAggregate) = context->intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermAggregate), (yyvsp[(2) - (2)].interm.intermNode), 0);
-    ;}
-    break;
-
-  case 164:
-
-    { (yyval.interm.intermNode) = 0; ;}
-    break;
-
-  case 165:
-
-    { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[(1) - (2)].interm.intermTypedNode)); ;}
+    }
     break;
 
   case 166:
 
     {
-        if (context->boolErrorCheck((yyvsp[(1) - (5)].lex).line, (yyvsp[(3) - (5)].interm.intermTypedNode)))
-            context->recover();
-        (yyval.interm.intermNode) = context->intermediate.addSelection((yyvsp[(3) - (5)].interm.intermTypedNode), (yyvsp[(5) - (5)].interm.nodePair), (yyvsp[(1) - (5)].lex).line);
-    ;}
+        (yyval.interm.intermAggregate) = context->intermediate.makeAggregate((yyvsp[(1) - (1)].interm.intermNode), 0);
+    }
     break;
 
   case 167:
 
     {
-        (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermNode);
-        (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermNode);
-    ;}
+        (yyval.interm.intermAggregate) = context->intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermAggregate), (yyvsp[(2) - (2)].interm.intermNode), 0);
+    }
     break;
 
   case 168:
 
-    {
-        (yyval.interm.nodePair).node1 = (yyvsp[(1) - (1)].interm.intermNode);
-        (yyval.interm.nodePair).node2 = 0;
-    ;}
+    { (yyval.interm.intermNode) = 0; }
     break;
 
   case 169:
 
+    { (yyval.interm.intermNode) = static_cast<TIntermNode*>((yyvsp[(1) - (2)].interm.intermTypedNode)); }
+    break;
+
+  case 170:
+
+    {
+        if (context->boolErrorCheck((yyvsp[(1) - (5)].lex).line, (yyvsp[(3) - (5)].interm.intermTypedNode)))
+            context->recover();
+        (yyval.interm.intermNode) = context->intermediate.addSelection((yyvsp[(3) - (5)].interm.intermTypedNode), (yyvsp[(5) - (5)].interm.nodePair), (yyvsp[(1) - (5)].lex).line);
+    }
+    break;
+
+  case 171:
+
+    {
+        (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermNode);
+        (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermNode);
+    }
+    break;
+
+  case 172:
+
+    {
+        (yyval.interm.nodePair).node1 = (yyvsp[(1) - (1)].interm.intermNode);
+        (yyval.interm.nodePair).node2 = 0;
+    }
+    break;
+
+  case 173:
+
     {
         (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
         if (context->boolErrorCheck((yyvsp[(1) - (1)].interm.intermTypedNode)->getLine(), (yyvsp[(1) - (1)].interm.intermTypedNode)))
             context->recover();
-    ;}
+    }
     break;
 
-  case 170:
+  case 174:
 
     {
         TIntermNode* intermNode;
@@ -4202,29 +4182,29 @@
             context->recover();
             (yyval.interm.intermTypedNode) = 0;
         }
-    ;}
+    }
     break;
 
-  case 171:
+  case 175:
 
-    { context->symbolTable.push(); ++context->loopNestingLevel; ;}
+    { context->symbolTable.push(); ++context->loopNestingLevel; }
     break;
 
-  case 172:
+  case 176:
 
     {
         context->symbolTable.pop();
         (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopWhile, 0, (yyvsp[(4) - (6)].interm.intermTypedNode), 0, (yyvsp[(6) - (6)].interm.intermNode), (yyvsp[(1) - (6)].lex).line);
         --context->loopNestingLevel;
-    ;}
+    }
     break;
 
-  case 173:
+  case 177:
 
-    { ++context->loopNestingLevel; ;}
+    { ++context->loopNestingLevel; }
     break;
 
-  case 174:
+  case 178:
 
     {
         if (context->boolErrorCheck((yyvsp[(8) - (8)].lex).line, (yyvsp[(6) - (8)].interm.intermTypedNode)))
@@ -4232,79 +4212,79 @@
 
         (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopDoWhile, 0, (yyvsp[(6) - (8)].interm.intermTypedNode), 0, (yyvsp[(3) - (8)].interm.intermNode), (yyvsp[(4) - (8)].lex).line);
         --context->loopNestingLevel;
-    ;}
-    break;
-
-  case 175:
-
-    { context->symbolTable.push(); ++context->loopNestingLevel; ;}
-    break;
-
-  case 176:
-
-    {
-        context->symbolTable.pop();
-        (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopFor, (yyvsp[(4) - (7)].interm.intermNode), reinterpret_cast<TIntermTyped*>((yyvsp[(5) - (7)].interm.nodePair).node1), reinterpret_cast<TIntermTyped*>((yyvsp[(5) - (7)].interm.nodePair).node2), (yyvsp[(7) - (7)].interm.intermNode), (yyvsp[(1) - (7)].lex).line);
-        --context->loopNestingLevel;
-    ;}
-    break;
-
-  case 177:
-
-    {
-        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
-    ;}
-    break;
-
-  case 178:
-
-    {
-        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
-    ;}
+    }
     break;
 
   case 179:
 
-    {
-        (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
-    ;}
+    { context->symbolTable.push(); ++context->loopNestingLevel; }
     break;
 
   case 180:
 
     {
-        (yyval.interm.intermTypedNode) = 0;
-    ;}
+        context->symbolTable.pop();
+        (yyval.interm.intermNode) = context->intermediate.addLoop(ELoopFor, (yyvsp[(4) - (7)].interm.intermNode), reinterpret_cast<TIntermTyped*>((yyvsp[(5) - (7)].interm.nodePair).node1), reinterpret_cast<TIntermTyped*>((yyvsp[(5) - (7)].interm.nodePair).node2), (yyvsp[(7) - (7)].interm.intermNode), (yyvsp[(1) - (7)].lex).line);
+        --context->loopNestingLevel;
+    }
     break;
 
   case 181:
 
     {
-        (yyval.interm.nodePair).node1 = (yyvsp[(1) - (2)].interm.intermTypedNode);
-        (yyval.interm.nodePair).node2 = 0;
-    ;}
+        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+    }
     break;
 
   case 182:
 
     {
-        (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermTypedNode);
-        (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermTypedNode);
-    ;}
+        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+    }
     break;
 
   case 183:
 
     {
+        (yyval.interm.intermTypedNode) = (yyvsp[(1) - (1)].interm.intermTypedNode);
+    }
+    break;
+
+  case 184:
+
+    {
+        (yyval.interm.intermTypedNode) = 0;
+    }
+    break;
+
+  case 185:
+
+    {
+        (yyval.interm.nodePair).node1 = (yyvsp[(1) - (2)].interm.intermTypedNode);
+        (yyval.interm.nodePair).node2 = 0;
+    }
+    break;
+
+  case 186:
+
+    {
+        (yyval.interm.nodePair).node1 = (yyvsp[(1) - (3)].interm.intermTypedNode);
+        (yyval.interm.nodePair).node2 = (yyvsp[(3) - (3)].interm.intermTypedNode);
+    }
+    break;
+
+  case 187:
+
+    {
         if (context->loopNestingLevel <= 0) {
             context->error((yyvsp[(1) - (2)].lex).line, "continue statement only allowed in loops", "", "");
             context->recover();
         }
         (yyval.interm.intermNode) = context->intermediate.addBranch(EOpContinue, (yyvsp[(1) - (2)].lex).line);
-    ;}
+    }
     break;
 
-  case 184:
+  case 188:
 
     {
         if (context->loopNestingLevel <= 0) {
@@ -4312,10 +4292,10 @@
             context->recover();
         }
         (yyval.interm.intermNode) = context->intermediate.addBranch(EOpBreak, (yyvsp[(1) - (2)].lex).line);
-    ;}
+    }
     break;
 
-  case 185:
+  case 189:
 
     {
         (yyval.interm.intermNode) = context->intermediate.addBranch(EOpReturn, (yyvsp[(1) - (2)].lex).line);
@@ -4323,10 +4303,10 @@
             context->error((yyvsp[(1) - (2)].lex).line, "non-void function must return a value", "return", "");
             context->recover();
         }
-    ;}
+    }
     break;
 
-  case 186:
+  case 190:
 
     {
         (yyval.interm.intermNode) = context->intermediate.addBranch(EOpReturn, (yyvsp[(2) - (3)].interm.intermTypedNode), (yyvsp[(1) - (3)].lex).line);
@@ -4338,50 +4318,50 @@
             context->error((yyvsp[(1) - (3)].lex).line, "function return is not matching type:", "return", "");
             context->recover();
         }
-    ;}
-    break;
-
-  case 187:
-
-    {
-        FRAG_ONLY("discard", (yyvsp[(1) - (2)].lex).line);
-        (yyval.interm.intermNode) = context->intermediate.addBranch(EOpKill, (yyvsp[(1) - (2)].lex).line);
-    ;}
-    break;
-
-  case 188:
-
-    {
-        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
-        context->treeRoot = (yyval.interm.intermNode);
-    ;}
-    break;
-
-  case 189:
-
-    {
-        (yyval.interm.intermNode) = context->intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermNode), (yyvsp[(2) - (2)].interm.intermNode), 0);
-        context->treeRoot = (yyval.interm.intermNode);
-    ;}
-    break;
-
-  case 190:
-
-    {
-        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
-    ;}
+    }
     break;
 
   case 191:
 
     {
-        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
-    ;}
+        FRAG_ONLY("discard", (yyvsp[(1) - (2)].lex).line);
+        (yyval.interm.intermNode) = context->intermediate.addBranch(EOpKill, (yyvsp[(1) - (2)].lex).line);
+    }
     break;
 
   case 192:
 
     {
+        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+        context->treeRoot = (yyval.interm.intermNode);
+    }
+    break;
+
+  case 193:
+
+    {
+        (yyval.interm.intermNode) = context->intermediate.growAggregate((yyvsp[(1) - (2)].interm.intermNode), (yyvsp[(2) - (2)].interm.intermNode), 0);
+        context->treeRoot = (yyval.interm.intermNode);
+    }
+    break;
+
+  case 194:
+
+    {
+        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+    }
+    break;
+
+  case 195:
+
+    {
+        (yyval.interm.intermNode) = (yyvsp[(1) - (1)].interm.intermNode);
+    }
+    break;
+
+  case 196:
+
+    {
         TFunction* function = (yyvsp[(1) - (1)].interm).function;
         TFunction* prevDec = static_cast<TFunction*>(context->symbolTable.find(function->getMangledName()));
         //
@@ -4413,11 +4393,6 @@
         }
 
         //
-        // New symbol table scope for body of function plus its arguments
-        //
-        context->symbolTable.push();
-
-        //
         // Remember the return type for later checking for RETURN statements.
         //
         context->currentFunctionType = &(prevDec->getReturnType());
@@ -4461,10 +4436,10 @@
         context->intermediate.setAggregateOperator(paramNodes, EOpParameters, (yyvsp[(1) - (1)].interm).line);
         (yyvsp[(1) - (1)].interm).intermAggregate = paramNodes;
         context->loopNestingLevel = 0;
-    ;}
+    }
     break;
 
-  case 193:
+  case 197:
 
     {
         //?? Check that all paths return a value if return type != void ?
@@ -4473,7 +4448,7 @@
             context->error((yyvsp[(1) - (3)].interm).line, "function does not return a value:", "", (yyvsp[(1) - (3)].interm).function->getName().c_str());
             context->recover();
         }
-        context->symbolTable.pop();
+        
         (yyval.interm.intermNode) = context->intermediate.growAggregate((yyvsp[(1) - (3)].interm).intermAggregate, (yyvsp[(3) - (3)].interm.intermNode), 0);
         context->intermediate.setAggregateOperator((yyval.interm.intermNode), EOpFunction, (yyvsp[(1) - (3)].interm).line);
         (yyval.interm.intermNode)->getAsAggregate()->setName((yyvsp[(1) - (3)].interm).function->getMangledName().c_str());
@@ -4487,11 +4462,12 @@
 
         if ((yyvsp[(3) - (3)].interm.intermNode) && (yyvsp[(3) - (3)].interm.intermNode)->getAsAggregate())
             (yyval.interm.intermNode)->getAsAggregate()->setEndLine((yyvsp[(3) - (3)].interm.intermNode)->getAsAggregate()->getEndLine());
-    ;}
+
+		context->symbolTable.pop();
+    }
     break;
 
 
-/* Line 1267 of yacc.c.  */
 
       default: break;
     }
@@ -4503,7 +4479,6 @@
 
   *++yyvsp = yyval;
 
-
   /* Now `shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
      number reduced by.  */
@@ -4568,7 +4543,7 @@
 
   if (yyerrstatus == 3)
     {
-      /* If just tried and failed to reuse look-ahead token after an
+      /* If just tried and failed to reuse lookahead token after an
 	 error, discard it.  */
 
       if (yychar <= YYEOF)
@@ -4585,7 +4560,7 @@
 	}
     }
 
-  /* Else will try to reuse look-ahead token after shifting the error
+  /* Else will try to reuse lookahead token after shifting the error
      token.  */
   goto yyerrlab1;
 
@@ -4642,9 +4617,6 @@
       YY_STACK_PRINT (yyss, yyssp);
     }
 
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
   *++yyvsp = yylval;
 
 
@@ -4669,7 +4641,7 @@
   yyresult = 1;
   goto yyreturn;
 
-#ifndef yyoverflow
+#if !defined(yyoverflow) || YYERROR_VERBOSE
 /*-------------------------------------------------.
 | yyexhaustedlab -- memory exhaustion comes here.  |
 `-------------------------------------------------*/
@@ -4680,7 +4652,7 @@
 #endif
 
 yyreturn:
-  if (yychar != YYEOF && yychar != YYEMPTY)
+  if (yychar != YYEMPTY)
      yydestruct ("Cleanup: discarding lookahead",
 		 yytoken, &yylval, context);
   /* Do not reclaim the symbols of the rule which action triggered
diff --git a/src/OpenGL ES 2.0/compiler/glslang_tab.h b/src/OpenGL ES 2.0/compiler/glslang_tab.h
index fa8480d..5227361 100644
--- a/src/OpenGL ES 2.0/compiler/glslang_tab.h
+++ b/src/OpenGL ES 2.0/compiler/glslang_tab.h
@@ -1,24 +1,22 @@
-/* A Bison parser, made by GNU Bison 2.3.  */
+/* A Bison parser, made by GNU Bison 2.4.2.  */
 
 /* Skeleton interface for Bison's Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
+   
+      Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software
+   Foundation, Inc.
+   
+   This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+   
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-
+   
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* As a special exception, you may create a larger work that contains
    part or all of the Bison parser skeleton and distribute that work
@@ -29,10 +27,11 @@
    special exception, which will cause the skeleton and the resulting
    Bison output files to be licensed under the GNU General Public
    License without this special exception.
-
+   
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
+
 /* Tokens.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
@@ -132,106 +131,14 @@
      QUESTION = 348
    };
 #endif
-/* Tokens.  */
-#define INVARIANT 258
-#define HIGH_PRECISION 259
-#define MEDIUM_PRECISION 260
-#define LOW_PRECISION 261
-#define PRECISION 262
-#define ATTRIBUTE 263
-#define CONST_QUAL 264
-#define BOOL_TYPE 265
-#define FLOAT_TYPE 266
-#define INT_TYPE 267
-#define BREAK 268
-#define CONTINUE 269
-#define DO 270
-#define ELSE 271
-#define FOR 272
-#define IF 273
-#define DISCARD 274
-#define RETURN 275
-#define BVEC2 276
-#define BVEC3 277
-#define BVEC4 278
-#define IVEC2 279
-#define IVEC3 280
-#define IVEC4 281
-#define VEC2 282
-#define VEC3 283
-#define VEC4 284
-#define MATRIX2 285
-#define MATRIX3 286
-#define MATRIX4 287
-#define IN_QUAL 288
-#define OUT_QUAL 289
-#define INOUT_QUAL 290
-#define UNIFORM 291
-#define VARYING 292
-#define STRUCT 293
-#define VOID_TYPE 294
-#define WHILE 295
-#define SAMPLER2D 296
-#define SAMPLERCUBE 297
-#define IDENTIFIER 298
-#define TYPE_NAME 299
-#define FLOATCONSTANT 300
-#define INTCONSTANT 301
-#define BOOLCONSTANT 302
-#define FIELD_SELECTION 303
-#define LEFT_OP 304
-#define RIGHT_OP 305
-#define INC_OP 306
-#define DEC_OP 307
-#define LE_OP 308
-#define GE_OP 309
-#define EQ_OP 310
-#define NE_OP 311
-#define AND_OP 312
-#define OR_OP 313
-#define XOR_OP 314
-#define MUL_ASSIGN 315
-#define DIV_ASSIGN 316
-#define ADD_ASSIGN 317
-#define MOD_ASSIGN 318
-#define LEFT_ASSIGN 319
-#define RIGHT_ASSIGN 320
-#define AND_ASSIGN 321
-#define XOR_ASSIGN 322
-#define OR_ASSIGN 323
-#define SUB_ASSIGN 324
-#define LEFT_PAREN 325
-#define RIGHT_PAREN 326
-#define LEFT_BRACKET 327
-#define RIGHT_BRACKET 328
-#define LEFT_BRACE 329
-#define RIGHT_BRACE 330
-#define DOT 331
-#define COMMA 332
-#define COLON 333
-#define EQUAL 334
-#define SEMICOLON 335
-#define BANG 336
-#define DASH 337
-#define TILDE 338
-#define PLUS 339
-#define STAR 340
-#define SLASH 341
-#define PERCENT 342
-#define LEFT_ANGLE 343
-#define RIGHT_ANGLE 344
-#define VERTICAL_BAR 345
-#define CARET 346
-#define AMPERSAND 347
-#define QUESTION 348
-
 
 
 
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union YYSTYPE
-
 {
+
+
     struct {
         TSourceLoc line;
         union {
@@ -261,14 +168,15 @@
             TTypeList* typeList;
         };
     } interm;
-}
-/* Line 1529 of yacc.c.  */
 
-	YYSTYPE;
+
+
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 
 
+
diff --git a/src/OpenGL ES 2.0/compiler/intermediate.h b/src/OpenGL ES 2.0/compiler/intermediate.h
index a8af5ab..70ea8db 100644
--- a/src/OpenGL ES 2.0/compiler/intermediate.h
+++ b/src/OpenGL ES 2.0/compiler/intermediate.h
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -195,6 +195,7 @@
 class TIntermTyped;
 class TIntermSymbol;
 class TIntermLoop;
+class TIntermBranch;
 class TInfoSink;
 
 //
@@ -218,6 +219,7 @@
     virtual TIntermSelection* getAsSelectionNode() { return 0; }
     virtual TIntermSymbol* getAsSymbolNode() { return 0; }
     virtual TIntermLoop* getAsLoopNode() { return 0; }
+	virtual TIntermBranch* getAsBranchNode() { return 0; }
     virtual ~TIntermNode() { }
 
 protected:
@@ -253,10 +255,16 @@
     bool isArray()  const { return type.isArray(); }
     bool isVector() const { return type.isVector(); }
     bool isScalar() const { return type.isScalar(); }
+	bool isRegister() const { return type.isRegister(); }   // Fits in a 4-element register
+	bool isStruct() const { return type.isStruct(); }
     const char* getBasicString() const { return type.getBasicString(); }
     const char* getQualifierString() const { return type.getQualifierString(); }
     TString getCompleteString() const { return type.getCompleteString(); }
 
+	int totalRegisterCount() const { return type.totalRegisterCount(); }
+	int elementRegisterCount() const { return type.elementRegisterCount(); }
+	int getArraySize() const { return type.getArraySize(); }
+
 protected:
     TType type;
 };
@@ -313,6 +321,7 @@
             flowOp(op),
             expression(e) { }
 
+	virtual TIntermBranch* getAsBranchNode() { return this; }
     virtual void traverse(TIntermTraverser*);
 
     TOperator getFlowOp() { return flowOp; }
@@ -332,23 +341,19 @@
     // per process globalpoolallocator, then it causes increased memory usage per compile
     // it is essential to use "symbol = sym" to assign to symbol
     TIntermSymbol(int i, const TString& sym, const TType& t) : 
-            TIntermTyped(t), id(i)  { symbol = sym; originalSymbol = sym; } 
+            TIntermTyped(t), id(i)  { symbol = sym; } 
 
     int getId() const { return id; }
     const TString& getSymbol() const { return symbol; }
 
     void setId(int newId) { id = newId; }
-    void setSymbol(const TString& sym) { symbol = sym; }
-
-    const TString& getOriginalSymbol() const { return originalSymbol; }
-
+    
     virtual void traverse(TIntermTraverser*);
     virtual TIntermSymbol* getAsSymbolNode() { return this; }
 
 protected:
     int id;
     TString symbol;
-    TString originalSymbol;
 };
 
 class TIntermConstantUnion : public TIntermTyped {
@@ -477,12 +482,15 @@
     TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB) :
             TIntermTyped(TType(EbtVoid, EbpUndefined)), condition(cond), trueBlock(trueB), falseBlock(falseB) {}
     TIntermSelection(TIntermTyped* cond, TIntermNode* trueB, TIntermNode* falseB, const TType& type) :
-            TIntermTyped(type), condition(cond), trueBlock(trueB), falseBlock(falseB) {}
+            TIntermTyped(type), condition(cond), trueBlock(trueB), falseBlock(falseB)
+	{
+		this->type.setQualifier(EvqTemporary);
+	}
 
     virtual void traverse(TIntermTraverser*);
 
     bool usesTernaryOperator() const { return getBasicType() != EbtVoid; }
-    TIntermNode* getCondition() const { return condition; }
+    TIntermTyped* getCondition() const { return condition; }
     TIntermNode* getTrueBlock() const { return trueBlock; }
     TIntermNode* getFalseBlock() const { return falseBlock; }
     TIntermSelection* getAsSelectionNode() { return this; }
diff --git a/src/OpenGL ES 2.0/compiler/osinclude.h b/src/OpenGL ES 2.0/compiler/osinclude.h
index 6ce4df9..e22da63 100644
--- a/src/OpenGL ES 2.0/compiler/osinclude.h
+++ b/src/OpenGL ES 2.0/compiler/osinclude.h
@@ -35,7 +35,7 @@
 #endif  // ANGLE_USE_NSPR
 
 
-#include "compiler/debug.h"
+#include "common/debug.h"
 
 //
 // Thread Local Storage Operations
diff --git a/src/OpenGL ES 2.0/compiler/preprocessor/atom.c b/src/OpenGL ES 2.0/compiler/preprocessor/atom.c
index a17c319..b252f6c 100644
--- a/src/OpenGL ES 2.0/compiler/preprocessor/atom.c
+++ b/src/OpenGL ES 2.0/compiler/preprocessor/atom.c
@@ -49,8 +49,8 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <assert.h>
 
-#include "compiler/debug.h"
 #include "compiler/preprocessor/slglobals.h"
 
 #undef malloc
diff --git a/src/OpenGL ES 2.0/compiler/preprocessor/tokens.c b/src/OpenGL ES 2.0/compiler/preprocessor/tokens.c
index aa83d2f..8455a88 100644
--- a/src/OpenGL ES 2.0/compiler/preprocessor/tokens.c
+++ b/src/OpenGL ES 2.0/compiler/preprocessor/tokens.c
@@ -49,11 +49,16 @@
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
+#include <assert.h>
 
-#include "compiler/debug.h"
 #include "compiler/preprocessor/slglobals.h"
 #include "compiler/util.h"
 
+#if defined(_MSC_VER)
+#pragma warning(disable: 4054)
+#pragma warning(disable: 4152)
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////// Preprocessor and Token Recorder and Playback: ////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -260,6 +265,8 @@
     char string_val[MAX_STRING_LEN + 1];
     int ltoken, len;
     char ch;
+    int base, accum;
+    char ch_val;
 
     ltoken = lReadByte(pTok);
     if (ltoken >= 0) {
@@ -310,18 +317,41 @@
             break;
         case CPP_INTCONSTANT:
             len = 0;
+	    accum = 0;
             ch = lReadByte(pTok);
-            while ((ch >= '0' && ch <= '9'))
-            {
-                if (len < MAX_SYMBOL_NAME_LEN) {
+            if (ch == '0') {
+                symbol_name[len++] = ch;
+                ch = lReadByte(pTok);
+                if (ch == 'x' || ch == 'X') {
                     symbol_name[len++] = ch;
+                    base = 16;
                     ch = lReadByte(pTok);
+                } else {
+                    base = 8;
                 }
+            } else {
+                base = 10;
+            }
+
+            while (len < MAX_SYMBOL_NAME_LEN)
+            {
+                ch_val = -1;
+                if (isdigit(ch))
+                    ch_val = ch - '0';
+                else if (isxdigit(ch))
+                    ch_val = tolower(ch) - 'a' + 10;
+
+                if (ch_val < 0 || ch_val >= base)
+                    break;
+
+                symbol_name[len++] = ch;
+                accum = accum * base + ch_val;
+                ch = lReadByte(pTok);
             }
             symbol_name[len] = '\0';
             assert(ch == '\0');
-            strcpy(yylvalpp->symbol_name,symbol_name);
-            yylvalpp->sc_int=atoi(yylvalpp->symbol_name);
+            strcpy(yylvalpp->symbol_name, symbol_name);
+            yylvalpp->sc_int = accum;
             break;
         case '(':
             yylvalpp->sc_int = lReadByte(pTok);
diff --git a/src/OpenGL ES 2.0/compiler/translator_common.vcproj b/src/OpenGL ES 2.0/compiler/translator_common.vcproj
deleted file mode 100644
index b269ae9..0000000
--- a/src/OpenGL ES 2.0/compiler/translator_common.vcproj
+++ /dev/null
@@ -1,584 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="translator_common"
-	ProjectGUID="{5B3A6DB8-1E7E-40D7-92B9-DA8AAE619FAD}"
-	RootNamespace="compiler"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="131072"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)\common"
-			ConfigurationType="4"
-			CharacterSet="0"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../include"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX"
-				MinimalRebuild="true"
-				ExceptionHandling="1"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="false"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)\common"
-			ConfigurationType="4"
-			CharacterSet="0"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				InlineFunctionExpansion="2"
-				AdditionalIncludeDirectories="$(ProjectDir);$(ProjectDir)../;$(ProjectDir)../include"
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0"
-				ExceptionHandling="1"
-				RuntimeLibrary="0"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="false"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath=".\CodeGenGLSL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\CodeGenHLSL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Compiler.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\debug.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\DetectRecursion.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\ForLoopUnroll.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\glslang.l"
-				>
-				<FileConfiguration
-					Name="Debug|Win32"
-					>
-					<Tool
-						Name="VCCustomBuildTool"
-						Description=""
-						CommandLine=""
-						AdditionalDependencies=""
-						Outputs=""
-					/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32"
-					>
-					<Tool
-						Name="VCCustomBuildTool"
-						Description=""
-						CommandLine=""
-						AdditionalDependencies=""
-						Outputs=""
-					/>
-				</FileConfiguration>
-			</File>
-			<File
-				RelativePath=".\glslang.y"
-				>
-				<FileConfiguration
-					Name="Debug|Win32"
-					>
-					<Tool
-						Name="VCCustomBuildTool"
-						Description=""
-						CommandLine=""
-						Outputs=""
-					/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32"
-					>
-					<Tool
-						Name="VCCustomBuildTool"
-						Description=""
-						CommandLine=""
-						Outputs=""
-					/>
-				</FileConfiguration>
-			</File>
-			<File
-				RelativePath=".\InfoSink.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Initialize.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\InitializeDll.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Intermediate.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\intermOut.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\IntermTraverse.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\MapLongVariableNames.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\ossource_win.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\OutputGLSL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\OutputHLSL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\parseConst.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\ParseHelper.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\PoolAlloc.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\QualifierAlive.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\RemoveTree.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\SearchSymbol.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\ShaderLang.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\SymbolTable.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\TranslatorGLSL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\TranslatorHLSL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\UnfoldSelect.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\util.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\ValidateLimitations.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\VariableInfo.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\VersionGLSL.cpp"
-				>
-			</File>
-			<Filter
-				Name="preprocessor"
-				>
-				<File
-					RelativePath=".\preprocessor\atom.c"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\cpp.c"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\cppstruct.c"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\memory.c"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\scanner.c"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\symbols.c"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\tokens.c"
-					>
-				</File>
-			</Filter>
-			<Filter
-				Name="generated"
-				>
-				<File
-					RelativePath=".\glslang_lex.cpp"
-					>
-				</File>
-				<File
-					RelativePath=".\glslang_tab.cpp"
-					>
-				</File>
-			</Filter>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-			<File
-				RelativePath=".\BaseTypes.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Common.h"
-				>
-			</File>
-			<File
-				RelativePath=".\ConstantUnion.h"
-				>
-			</File>
-			<File
-				RelativePath=".\debug.h"
-				>
-			</File>
-			<File
-				RelativePath=".\DetectRecursion.h"
-				>
-			</File>
-			<File
-				RelativePath=".\ExtensionBehavior.h"
-				>
-			</File>
-			<File
-				RelativePath=".\ForLoopUnroll.h"
-				>
-			</File>
-			<File
-				RelativePath=".\glslang.h"
-				>
-			</File>
-			<File
-				RelativePath=".\InfoSink.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Initialize.h"
-				>
-			</File>
-			<File
-				RelativePath=".\InitializeDll.h"
-				>
-			</File>
-			<File
-				RelativePath=".\InitializeGlobals.h"
-				>
-			</File>
-			<File
-				RelativePath=".\InitializeParseContext.h"
-				>
-			</File>
-			<File
-				RelativePath=".\intermediate.h"
-				>
-			</File>
-			<File
-				RelativePath=".\localintermediate.h"
-				>
-			</File>
-			<File
-				RelativePath=".\MapLongVariableNames.h"
-				>
-			</File>
-			<File
-				RelativePath=".\MMap.h"
-				>
-			</File>
-			<File
-				RelativePath=".\osinclude.h"
-				>
-			</File>
-			<File
-				RelativePath=".\OutputGLSL.h"
-				>
-			</File>
-			<File
-				RelativePath=".\OutputHLSL.h"
-				>
-			</File>
-			<File
-				RelativePath=".\ParseHelper.h"
-				>
-			</File>
-			<File
-				RelativePath=".\PoolAlloc.h"
-				>
-			</File>
-			<File
-				RelativePath=".\QualifierAlive.h"
-				>
-			</File>
-			<File
-				RelativePath=".\RemoveTree.h"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\GLSLANG\ResourceLimits.h"
-				>
-			</File>
-			<File
-				RelativePath=".\SearchSymbol.h"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\GLSLANG\ShaderLang.h"
-				>
-			</File>
-			<File
-				RelativePath=".\ShHandle.h"
-				>
-			</File>
-			<File
-				RelativePath=".\SymbolTable.h"
-				>
-			</File>
-			<File
-				RelativePath=".\TranslatorGLSL.h"
-				>
-			</File>
-			<File
-				RelativePath=".\TranslatorHLSL.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Types.h"
-				>
-			</File>
-			<File
-				RelativePath=".\UnfoldSelect.h"
-				>
-			</File>
-			<File
-				RelativePath=".\util.h"
-				>
-			</File>
-			<File
-				RelativePath=".\ValidateLimitations.h"
-				>
-			</File>
-			<File
-				RelativePath=".\VariableInfo.h"
-				>
-			</File>
-			<File
-				RelativePath=".\VersionGLSL.h"
-				>
-			</File>
-			<Filter
-				Name="preprocessor"
-				>
-				<File
-					RelativePath=".\preprocessor\atom.h"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\compile.h"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\cpp.h"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\memory.h"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\parser.h"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\preprocess.h"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\scanner.h"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\slglobals.h"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\symbols.h"
-					>
-				</File>
-				<File
-					RelativePath=".\preprocessor\tokens.h"
-					>
-				</File>
-			</Filter>
-			<Filter
-				Name="generated"
-				>
-				<File
-					RelativePath=".\glslang_tab.h"
-					>
-				</File>
-			</Filter>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/src/OpenGL ES 2.0/compiler/translator_common.vcxproj.user b/src/OpenGL ES 2.0/compiler/translator_common.vcxproj.user
deleted file mode 100644
index 695b5c7..0000000
--- a/src/OpenGL ES 2.0/compiler/translator_common.vcxproj.user
+++ /dev/null
@@ -1,3 +0,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/compiler/translator_hlsl.vcproj b/src/OpenGL ES 2.0/compiler/translator_hlsl.vcproj
deleted file mode 100644
index 405a812..0000000
--- a/src/OpenGL ES 2.0/compiler/translator_hlsl.vcproj
+++ /dev/null
@@ -1,202 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="translator_hlsl"
-	ProjectGUID="{5620F0E4-6C43-49BC-A178-B804E1A0C3A7}"
-	RootNamespace="CrossCompilerHLSL"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)\hlsl"
-			ConfigurationType="4"
-			CharacterSet="0"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="$(ProjectDir)../;$(ProjectDir)../include"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_WARNINGS;NOMINMAX"
-				MinimalRebuild="true"
-				ExceptionHandling="1"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)\hlsl"
-			ConfigurationType="4"
-			CharacterSet="0"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				InlineFunctionExpansion="2"
-				EnableIntrinsicFunctions="true"
-				AdditionalIncludeDirectories="$(ProjectDir)../;$(ProjectDir)../include"
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_WARNINGS;NOMINMAX;_SECURE_SCL=0"
-				ExceptionHandling="1"
-				RuntimeLibrary="0"
-				EnableFunctionLevelLinking="true"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath=".\CodeGenHLSL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\OutputHLSL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\SearchSymbol.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\TranslatorHLSL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\UnfoldSelect.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-			<File
-				RelativePath=".\OutputHLSL.h"
-				>
-			</File>
-			<File
-				RelativePath=".\SearchSymbol.h"
-				>
-			</File>
-			<File
-				RelativePath=".\TranslatorHLSL.h"
-				>
-			</File>
-			<File
-				RelativePath=".\UnfoldSelect.h"
-				>
-			</File>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/src/OpenGL ES 2.0/compiler/translator_hlsl.vcxproj.user b/src/OpenGL ES 2.0/compiler/translator_hlsl.vcxproj.user
deleted file mode 100644
index 695b5c7..0000000
--- a/src/OpenGL ES 2.0/compiler/translator_hlsl.vcxproj.user
+++ /dev/null
@@ -1,3 +0,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/include/EGL/eglext.h b/src/OpenGL ES 2.0/include/EGL/eglext.h
index b650a50..b670840 100644
--- a/src/OpenGL ES 2.0/include/EGL/eglext.h
+++ b/src/OpenGL ES 2.0/include/EGL/eglext.h
@@ -6,7 +6,7 @@
 #endif
 
 /*
-** Copyright (c) 2007-2009 The Khronos Group Inc.
+** Copyright (c) 2007-2012 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
@@ -34,8 +34,8 @@
 
 /* Header file version number */
 /* Current version at http://www.khronos.org/registry/egl/ */
-/* $Revision: 10795 $ on $Date: 2010-03-19 17:04:17 -0700 (Fri, 19 Mar 2010) $ */
-#define EGL_EGLEXT_VERSION 5
+/* $Revision: 16473 $ on $Date: 2012-01-04 02:20:48 -0800 (Wed, 04 Jan 2012) $ */
+#define EGL_EGLEXT_VERSION 11
 
 #ifndef EGL_KHR_config_attribs
 #define EGL_KHR_config_attribs 1
@@ -120,6 +120,7 @@
 #define EGL_GL_RENDERBUFFER_KHR			0x30B9	/* eglCreateImageKHR target */
 #endif
 
+#if KHRONOS_SUPPORT_INT64   /* EGLTimeKHR requires 64-bit uint support */
 #ifndef EGL_KHR_reusable_sync
 #define EGL_KHR_reusable_sync 1
 
@@ -149,6 +150,7 @@
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
 #endif
+#endif
 
 #ifndef EGL_KHR_image_base
 #define EGL_KHR_image_base 1
@@ -169,19 +171,25 @@
 #define EGL_CONTEXT_PRIORITY_LOW_IMG		0x3103
 #endif
 
+#ifndef EGL_KHR_lock_surface2
+#define EGL_KHR_lock_surface2 1
+#define EGL_BITMAP_PIXEL_SIZE_KHR		0x3110
+#endif
+
 #ifndef EGL_NV_coverage_sample
 #define EGL_NV_coverage_sample 1
-#define EGL_COVERAGE_BUFFERS_NV 0x30E0
-#define EGL_COVERAGE_SAMPLES_NV 0x30E1
+#define EGL_COVERAGE_BUFFERS_NV			0x30E0
+#define EGL_COVERAGE_SAMPLES_NV			0x30E1
 #endif
 
 #ifndef EGL_NV_depth_nonlinear
 #define EGL_NV_depth_nonlinear 1
-#define EGL_DEPTH_ENCODING_NV 0x30E2
+#define EGL_DEPTH_ENCODING_NV			0x30E2
 #define EGL_DEPTH_ENCODING_NONE_NV 0
-#define EGL_DEPTH_ENCODING_NONLINEAR_NV 0x30E3
+#define EGL_DEPTH_ENCODING_NONLINEAR_NV		0x30E3
 #endif
 
+#if KHRONOS_SUPPORT_INT64   /* EGLTimeNV requires 64-bit uint support */
 #ifndef EGL_NV_sync
 #define EGL_NV_sync 1
 #define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV	0x30E6
@@ -198,7 +206,7 @@
 #define EGL_SYNC_FENCE_NV			0x30EF
 #define EGL_NO_SYNC_NV				((EGLSyncNV)0)
 typedef void* EGLSyncNV;
-typedef unsigned long long EGLTimeNV;
+typedef khronos_utime_nanoseconds_t EGLTimeNV;
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLSyncNV eglCreateFenceSyncNV (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
 EGLBoolean eglDestroySyncNV (EGLSyncNV sync);
@@ -214,6 +222,76 @@
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCNVPROC) (EGLSyncNV sync, EGLenum mode);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBNVPROC) (EGLSyncNV sync, EGLint attribute, EGLint *value);
 #endif
+#endif
+
+#if KHRONOS_SUPPORT_INT64   /* Dependent on EGL_KHR_reusable_sync which requires 64-bit uint support */
+#ifndef EGL_KHR_fence_sync
+#define EGL_KHR_fence_sync 1
+/* Reuses most tokens and entry points from EGL_KHR_reusable_sync */
+#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR	0x30F0
+#define EGL_SYNC_CONDITION_KHR			0x30F8
+#define EGL_SYNC_FENCE_KHR			0x30F9
+#endif
+#endif
+
+#ifndef EGL_HI_clientpixmap
+#define EGL_HI_clientpixmap 1
+
+/* Surface Attribute */
+#define EGL_CLIENT_PIXMAP_POINTER_HI		0x8F74
+/*
+ * Structure representing a client pixmap
+ * (pixmap's data is in client-space memory).
+ */
+struct EGLClientPixmapHI
+{
+	void*		pData;
+	EGLint		iWidth;
+	EGLint		iHeight;
+	EGLint		iStride;
+};
+
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurfaceHI(EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPIXMAPSURFACEHIPROC) (EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
+#endif	/* EGL_HI_clientpixmap */
+
+#ifndef EGL_HI_colorformats
+#define EGL_HI_colorformats 1
+/* Config Attribute */
+#define EGL_COLOR_FORMAT_HI			0x8F70
+/* Color Formats */
+#define EGL_COLOR_RGB_HI			0x8F71
+#define EGL_COLOR_RGBA_HI			0x8F72
+#define EGL_COLOR_ARGB_HI			0x8F73
+#endif /* EGL_HI_colorformats */
+
+#ifndef EGL_MESA_drm_image
+#define EGL_MESA_drm_image 1
+#define EGL_DRM_BUFFER_FORMAT_MESA		0x31D0	    /* CreateDRMImageMESA attribute */
+#define EGL_DRM_BUFFER_USE_MESA			0x31D1	    /* CreateDRMImageMESA attribute */
+#define EGL_DRM_BUFFER_FORMAT_ARGB32_MESA	0x31D2	    /* EGL_IMAGE_FORMAT_MESA attribute value */
+#define EGL_DRM_BUFFER_MESA			0x31D3	    /* eglCreateImageKHR target */
+#define EGL_DRM_BUFFER_STRIDE_MESA		0x31D4
+#define EGL_DRM_BUFFER_USE_SCANOUT_MESA		0x00000001  /* EGL_DRM_BUFFER_USE_MESA bits */
+#define EGL_DRM_BUFFER_USE_SHARE_MESA		0x00000002  /* EGL_DRM_BUFFER_USE_MESA bits */
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLImageKHR EGLAPIENTRY eglCreateDRMImageMESA (EGLDisplay dpy, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglExportDRMImageMESA (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEDRMIMAGEMESAPROC) (EGLDisplay dpy, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLEXPORTDRMIMAGEMESAPROC) (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
+#endif
+
+#ifndef EGL_NV_post_sub_buffer
+#define EGL_NV_post_sub_buffer 1
+#define EGL_POST_SUB_BUFFER_SUPPORTED_NV	0x30BE
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglPostSubBufferNV (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLPOSTSUBBUFFERNVPROC) (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
+#endif
 
 #ifndef EGL_ANGLE_query_surface_pointer
 #define EGL_ANGLE_query_surface_pointer 1
@@ -223,9 +301,44 @@
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
 #endif
 
+#ifndef EGL_ANGLE_software_display
+#define EGL_ANGLE_software_display 1
+#define EGL_SOFTWARE_DISPLAY_ANGLE ((EGLNativeDisplayType)-1)
+#endif
+
 #ifndef EGL_ANGLE_surface_d3d_texture_2d_share_handle
-#define EGL_ANGLE_surface_d3d_texture_2d_share_handle
-#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE 0x3200
+#define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
+#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE	0x3200
+#endif
+
+#ifndef EGL_NV_coverage_sample_resolve
+#define EGL_NV_coverage_sample_resolve 1
+#define EGL_COVERAGE_SAMPLE_RESOLVE_NV		0x3131
+#define EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV	0x3132
+#define EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV	0x3133
+#endif
+
+#if KHRONOS_SUPPORT_INT64   /* EGLTimeKHR requires 64-bit uint support */
+#ifndef EGL_NV_system_time
+#define EGL_NV_system_time 1
+
+typedef khronos_utime_nanoseconds_t EGLuint64NV;
+
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeFrequencyNV(void);
+EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV(void);
+#endif /* EGL_EGLEXT_PROTOTYPES */
+typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC) (void);
+typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMENVPROC) (void);
+#endif
+#endif
+
+#ifndef EGL_EXT_create_context_robustness
+#define EGL_EXT_create_context_robustness 1
+#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT	0x30BF
+#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT 0x3138
+#define EGL_NO_RESET_NOTIFICATION_EXT		0x31BE
+#define EGL_LOSE_CONTEXT_ON_RESET_EXT		0x31BF
 #endif
 
 #ifdef __cplusplus
diff --git a/src/OpenGL ES 2.0/include/EGL/eglplatform.h b/src/OpenGL ES 2.0/include/EGL/eglplatform.h
index 22e855f..34283f2 100644
--- a/src/OpenGL ES 2.0/include/EGL/eglplatform.h
+++ b/src/OpenGL ES 2.0/include/EGL/eglplatform.h
@@ -25,7 +25,7 @@
 */
 
 /* Platform-specific types and definitions for egl.h
- * $Revision: 9724 $ on $Date: 2009-12-02 02:05:33 -0800 (Wed, 02 Dec 2009) $
+ * $Revision: 12306 $ on $Date: 2010-08-25 09:51:28 -0700 (Wed, 25 Aug 2010) $
  *
  * Adopters may modify khrplatform.h and this file to suit their platform.
  * You are encouraged to submit all modifications to the Khronos group so that
@@ -60,6 +60,11 @@
  * Windows Device Context. They must be defined in platform-specific
  * code below. The EGL-prefixed versions of Native*Type are the same
  * types, renamed in EGL 1.3 so all types in the API start with "EGL".
+ *
+ * Khronos STRONGLY RECOMMENDS that you use the default definitions
+ * provided below, since these changes affect both binary and source
+ * portability of applications using EGL running on different EGL
+ * implementations.
  */
 
 #if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
@@ -78,7 +83,13 @@
 typedef void *EGLNativeWindowType;
 typedef void *EGLNativePixmapType;
 
-#elif defined(__unix__)
+#elif defined(WL_EGL_PLATFORM)
+
+typedef struct wl_display     *EGLNativeDisplayType;
+typedef struct wl_egl_pixmap  *EGLNativePixmapType;
+typedef struct wl_egl_window  *EGLNativeWindowType;
+
+#elif defined(__unix__) && !defined(ANDROID)
 
 /* X11 (tentative)  */
 #include <X11/Xlib.h>
@@ -88,6 +99,14 @@
 typedef Pixmap   EGLNativePixmapType;
 typedef Window   EGLNativeWindowType;
 
+#elif defined(ANDROID)
+
+struct egl_native_pixmap_t;
+
+typedef struct ANativeWindow*           EGLNativeWindowType;
+typedef struct egl_native_pixmap_t*     EGLNativePixmapType;
+typedef void*                           EGLNativeDisplayType;
+
 #else
 #error "Platform not recognized"
 #endif
diff --git a/src/OpenGL ES 2.0/include/GLES2/gl2ext.h b/src/OpenGL ES 2.0/include/GLES2/gl2ext.h
index 01844de..a124014 100644
--- a/src/OpenGL ES 2.0/include/GLES2/gl2ext.h
+++ b/src/OpenGL ES 2.0/include/GLES2/gl2ext.h
@@ -1,7 +1,7 @@
 #ifndef __gl2ext_h_
 #define __gl2ext_h_
 
-/* $Revision: 10798 $ on $Date:: 2010-03-19 17:34:30 -0700 #$ */
+/* $Revision: 16482 $ on $Date:: 2012-01-04 13:44:55 -0500 #$ */
 
 #ifdef __cplusplus
 extern "C" {
@@ -57,6 +57,15 @@
 typedef void* GLeglImageOES;
 #endif
 
+/* GL_OES_EGL_image_external */
+#ifndef GL_OES_EGL_image_external
+/* GLeglImageOES defined in GL_OES_EGL_image already. */
+#define GL_TEXTURE_EXTERNAL_OES                                 0x8D65
+#define GL_SAMPLER_EXTERNAL_OES                                 0x8D66
+#define GL_TEXTURE_BINDING_EXTERNAL_OES                         0x8D67
+#define GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES                     0x8D68
+#endif
+
 /* GL_OES_element_index_uint */
 #ifndef GL_OES_element_index_uint
 #define GL_UNSIGNED_INT                                         0x1405
@@ -180,6 +189,100 @@
 #endif
 
 /*------------------------------------------------------------------------*
+ * ANGLE extension tokens
+ *------------------------------------------------------------------------*/
+
+/* GL_ANGLE_framebuffer_blit */
+#ifndef GL_ANGLE_framebuffer_blit
+#define GL_READ_FRAMEBUFFER_ANGLE                               0x8CA8
+#define GL_DRAW_FRAMEBUFFER_ANGLE                               0x8CA9
+#define GL_DRAW_FRAMEBUFFER_BINDING_ANGLE                       0x8CA6
+#define GL_READ_FRAMEBUFFER_BINDING_ANGLE                       0x8CAA
+#endif
+
+/* GL_ANGLE_framebuffer_multisample */
+#ifndef GL_ANGLE_framebuffer_multisample
+#define GL_RENDERBUFFER_SAMPLES_ANGLE                           0x8CAB
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE             0x8D56
+#define GL_MAX_SAMPLES_ANGLE                                    0x8D57
+#endif
+
+/* GL_ANGLE_pack_reverse_row_order */
+#ifndef GL_ANGLE_pack_reverse_row_order
+#define GL_PACK_REVERSE_ROW_ORDER_ANGLE                         0x93A4
+#endif
+
+/* GL_ANGLE_texture_compression_dxt3 */
+#ifndef GL_ANGLE_texture_compression_dxt3
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE                      0x83F2
+#endif
+
+/* GL_ANGLE_texture_compression_dxt5 */
+#ifndef GL_ANGLE_texture_compression_dxt5
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE                      0x83F3
+#endif
+
+/* GL_ANGLE_translated_shader_source */
+#ifndef GL_ANGLE_translated_shader_source
+#define GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE                0x93A0
+#endif
+
+/* GL_ANGLE_texture_usage */
+#ifndef GL_ANGLE_texture_usage
+#define GL_TEXTURE_USAGE_ANGLE                                  0x93A2
+#define GL_FRAMEBUFFER_ATTACHMENT_ANGLE                         0x93A3
+#endif
+
+/* GL_ANGLE_instanced_arrays */
+#ifndef GL_ANGLE_instanced_arrays
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE                    0x88FE
+#endif
+
+/*------------------------------------------------------------------------*
+ * APPLE extension tokens
+ *------------------------------------------------------------------------*/
+
+/* GL_APPLE_rgb_422 */
+#ifndef GL_APPLE_rgb_422
+#define GL_RGB_422_APPLE                                        0x8A1F
+#define GL_UNSIGNED_SHORT_8_8_APPLE                             0x85BA
+#define GL_UNSIGNED_SHORT_8_8_REV_APPLE                         0x85BB
+#endif
+
+/* GL_APPLE_framebuffer_multisample */
+#ifndef GL_APPLE_framebuffer_multisample
+#define GL_RENDERBUFFER_SAMPLES_APPLE                           0x8CAB
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE             0x8D56
+#define GL_MAX_SAMPLES_APPLE                                    0x8D57
+#define GL_READ_FRAMEBUFFER_APPLE                               0x8CA8
+#define GL_DRAW_FRAMEBUFFER_APPLE                               0x8CA9
+#define GL_DRAW_FRAMEBUFFER_BINDING_APPLE                       0x8CA6
+#define GL_READ_FRAMEBUFFER_BINDING_APPLE                       0x8CAA
+#endif
+
+/* GL_APPLE_texture_format_BGRA8888 */
+#ifndef GL_APPLE_texture_format_BGRA8888
+#define GL_BGRA_EXT                                             0x80E1
+#endif
+
+/* GL_APPLE_texture_max_level */
+#ifndef GL_APPLE_texture_max_level
+#define GL_TEXTURE_MAX_LEVEL_APPLE                              0x813D
+#endif
+
+/*------------------------------------------------------------------------*
+ * ARM extension tokens
+ *------------------------------------------------------------------------*/
+
+/* GL_ARM_mali_shader_binary */
+#ifndef GL_ARM_mali_shader_binary
+#define GL_MALI_SHADER_BINARY_ARM                               0x8F60
+#endif
+
+/* GL_ARM_rgba8 */
+/* No new tokens introduced by this extension. */
+
+/*------------------------------------------------------------------------*
  * EXT extension tokens
  *------------------------------------------------------------------------*/
 
@@ -189,6 +292,29 @@
 #define GL_MAX_EXT                                              0x8008
 #endif
 
+/* GL_EXT_color_buffer_half_float */
+#ifndef GL_EXT_color_buffer_half_float
+#define GL_RGBA16F_EXT                                          0x881A
+#define GL_RGB16F_EXT                                           0x881B
+#define GL_RG16F_EXT                                            0x822F
+#define GL_R16F_EXT                                             0x822D
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT            0x8211
+#define GL_UNSIGNED_NORMALIZED_EXT                              0x8C17
+#endif
+
+/* GL_EXT_debug_label */
+#ifndef GL_EXT_debug_label
+#define GL_PROGRAM_PIPELINE_OBJECT_EXT                          0x8A4F
+#define GL_PROGRAM_OBJECT_EXT                                   0x8B40
+#define GL_SHADER_OBJECT_EXT                                    0x8B48
+#define GL_BUFFER_OBJECT_EXT                                    0x9151
+#define GL_QUERY_OBJECT_EXT                                     0x9153
+#define GL_VERTEX_ARRAY_OBJECT_EXT                              0x9154
+#endif
+
+/* GL_EXT_debug_marker */
+/* No new tokens introduced by this extension. */
+
 /* GL_EXT_discard_framebuffer */
 #ifndef GL_EXT_discard_framebuffer
 #define GL_COLOR_EXT                                            0x1800
@@ -196,9 +322,26 @@
 #define GL_STENCIL_EXT                                          0x1802
 #endif
 
+/* GL_EXT_multisampled_render_to_texture */
+#ifndef GL_EXT_multisampled_render_to_texture
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT           0x8D6C
+#define GL_RENDERBUFFER_SAMPLES_EXT                             0x9133
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT               0x9134
+#define GL_MAX_SAMPLES_EXT                                      0x9135
+#endif
+
 /* GL_EXT_multi_draw_arrays */
 /* No new tokens introduced by this extension. */
 
+/* GL_EXT_occlusion_query_boolean */
+#ifndef GL_EXT_occlusion_query_boolean
+#define GL_ANY_SAMPLES_PASSED_EXT                               0x8C2F
+#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT                  0x8D6A
+#define GL_CURRENT_QUERY_EXT                                    0x8865
+#define GL_QUERY_RESULT_EXT                                     0x8866
+#define GL_QUERY_RESULT_AVAILABLE_EXT                           0x8867
+#endif
+
 /* GL_EXT_read_format_bgra */
 #ifndef GL_EXT_read_format_bgra
 #define GL_BGRA_EXT                                             0x80E1
@@ -206,6 +349,52 @@
 #define GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT                       0x8366
 #endif
 
+/* GL_EXT_robustness */
+#ifndef GL_EXT_robustness
+/* reuse GL_NO_ERROR */
+#define GL_GUILTY_CONTEXT_RESET_EXT                             0x8253
+#define GL_INNOCENT_CONTEXT_RESET_EXT                           0x8254
+#define GL_UNKNOWN_CONTEXT_RESET_EXT                            0x8255
+#define GL_CONTEXT_ROBUST_ACCESS_EXT                            0x90F3
+#define GL_RESET_NOTIFICATION_STRATEGY_EXT                      0x8256
+#define GL_LOSE_CONTEXT_ON_RESET_EXT                            0x8252
+#define GL_NO_RESET_NOTIFICATION_EXT                            0x8261
+#endif
+
+/* GL_EXT_separate_shader_objects */
+#ifndef GL_EXT_separate_shader_objects
+#define GL_VERTEX_SHADER_BIT_EXT                                0x00000001
+#define GL_FRAGMENT_SHADER_BIT_EXT                              0x00000002
+#define GL_ALL_SHADER_BITS_EXT                                  0xFFFFFFFF
+#define GL_PROGRAM_SEPARABLE_EXT                                0x8258
+#define GL_ACTIVE_PROGRAM_EXT                                   0x8259
+#define GL_PROGRAM_PIPELINE_BINDING_EXT                         0x825A
+#endif
+
+/* GL_EXT_shader_texture_lod */
+/* No new tokens introduced by this extension. */
+
+/* GL_EXT_shadow_samplers */
+#ifndef GL_EXT_shadow_samplers
+#define GL_TEXTURE_COMPARE_MODE_EXT                             0x884C
+#define GL_TEXTURE_COMPARE_FUNC_EXT                             0x884D
+#define GL_COMPARE_REF_TO_TEXTURE_EXT                           0x884E
+#endif
+
+/* GL_EXT_sRGB */
+#ifndef GL_EXT_sRGB
+#define GL_SRGB_EXT                                             0x8C40
+#define GL_SRGB_ALPHA_EXT                                       0x8C42
+#define GL_SRGB8_ALPHA8_EXT                                     0x8C43
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT            0x8210
+#endif
+
+/* GL_EXT_texture_compression_dxt1 */
+#ifndef GL_EXT_texture_compression_dxt1
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT                         0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT                        0x83F1
+#endif
+
 /* GL_EXT_texture_filter_anisotropic */
 #ifndef GL_EXT_texture_filter_anisotropic
 #define GL_TEXTURE_MAX_ANISOTROPY_EXT                           0x84FE
@@ -217,15 +406,54 @@
 #define GL_BGRA_EXT                                             0x80E1
 #endif
 
+/* GL_EXT_texture_rg */
+#ifndef GL_EXT_texture_rg
+#define GL_RED_EXT                                              0x1903
+#define GL_RG_EXT                                               0x8227
+#define GL_R8_EXT                                               0x8229
+#define GL_RG8_EXT                                              0x822B
+#endif
+
+/* GL_EXT_texture_storage */
+#ifndef GL_EXT_texture_storage
+#define GL_TEXTURE_IMMUTABLE_FORMAT_EXT                         0x912F
+#define GL_ALPHA8_EXT                                           0x803C  
+#define GL_LUMINANCE8_EXT                                       0x8040
+#define GL_LUMINANCE8_ALPHA8_EXT                                0x8045
+#define GL_RGBA32F_EXT                                          0x8814  
+#define GL_RGB32F_EXT                                           0x8815
+#define GL_ALPHA32F_EXT                                         0x8816
+#define GL_LUMINANCE32F_EXT                                     0x8818
+#define GL_LUMINANCE_ALPHA32F_EXT                               0x8819
+/* reuse GL_RGBA16F_EXT */
+#define GL_RGB16F_EXT                                           0x881B
+#define GL_ALPHA16F_EXT                                         0x881C
+#define GL_LUMINANCE16F_EXT                                     0x881E
+#define GL_LUMINANCE_ALPHA16F_EXT                               0x881F
+#define GL_RGB10_A2_EXT                                         0x8059  
+#define GL_RGB10_EXT                                            0x8052
+#define GL_BGRA8_EXT                                            0x93A1
+#endif
+
 /* GL_EXT_texture_type_2_10_10_10_REV */
 #ifndef GL_EXT_texture_type_2_10_10_10_REV
 #define GL_UNSIGNED_INT_2_10_10_10_REV_EXT                      0x8368
 #endif
 
-/* GL_EXT_texture_compression_dxt1 */
-#ifndef GL_EXT_texture_compression_dxt1
-#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT                         0x83F0
-#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT                        0x83F1
+/* GL_EXT_unpack_subimage */
+#ifndef GL_EXT_unpack_subimage
+#define GL_UNPACK_ROW_LENGTH                                    0x0CF2
+#define GL_UNPACK_SKIP_ROWS                                     0x0CF3
+#define GL_UNPACK_SKIP_PIXELS                                   0x0CF4
+#endif
+
+/*------------------------------------------------------------------------*
+ * DMP extension tokens
+ *------------------------------------------------------------------------*/
+
+/* GL_DMP_shader_binary */
+#ifndef GL_DMP_shader_binary
+#define GL_SHADER_BINARY_DMP                                    0x9250
 #endif
 
 /*------------------------------------------------------------------------*
@@ -256,17 +484,18 @@
 #define GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG                     0x8C03
 #endif
 
+/* GL_IMG_multisampled_render_to_texture */
+#ifndef GL_IMG_multisampled_render_to_texture
+#define GL_RENDERBUFFER_SAMPLES_IMG                             0x9133
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG               0x9134
+#define GL_MAX_SAMPLES_IMG                                      0x9135
+#define GL_TEXTURE_SAMPLES_IMG                                  0x9136
+#endif
+
 /*------------------------------------------------------------------------*
  * NV extension tokens
  *------------------------------------------------------------------------*/
 
-/* GL_NV_fence */
-#ifndef GL_NV_fence
-#define GL_ALL_COMPLETED_NV                                     0x84F2
-#define GL_FENCE_STATUS_NV                                      0x84F3
-#define GL_FENCE_CONDITION_NV                                   0x84F4
-#endif
-
 /* GL_NV_coverage_sample */
 #ifndef GL_NV_coverage_sample
 #define GL_COVERAGE_COMPONENT_NV                                0x8ED0
@@ -285,10 +514,90 @@
 #define GL_DEPTH_COMPONENT16_NONLINEAR_NV                       0x8E2C
 #endif
 
+/* GL_NV_draw_buffers */
+#ifndef GL_NV_draw_buffers
+#define GL_MAX_DRAW_BUFFERS_NV                                  0x8824
+#define GL_DRAW_BUFFER0_NV                                      0x8825
+#define GL_DRAW_BUFFER1_NV                                      0x8826
+#define GL_DRAW_BUFFER2_NV                                      0x8827
+#define GL_DRAW_BUFFER3_NV                                      0x8828
+#define GL_DRAW_BUFFER4_NV                                      0x8829
+#define GL_DRAW_BUFFER5_NV                                      0x882A
+#define GL_DRAW_BUFFER6_NV                                      0x882B
+#define GL_DRAW_BUFFER7_NV                                      0x882C
+#define GL_DRAW_BUFFER8_NV                                      0x882D
+#define GL_DRAW_BUFFER9_NV                                      0x882E
+#define GL_DRAW_BUFFER10_NV                                     0x882F
+#define GL_DRAW_BUFFER11_NV                                     0x8830
+#define GL_DRAW_BUFFER12_NV                                     0x8831
+#define GL_DRAW_BUFFER13_NV                                     0x8832
+#define GL_DRAW_BUFFER14_NV                                     0x8833
+#define GL_DRAW_BUFFER15_NV                                     0x8834
+#define GL_COLOR_ATTACHMENT0_NV                                 0x8CE0
+#define GL_COLOR_ATTACHMENT1_NV                                 0x8CE1
+#define GL_COLOR_ATTACHMENT2_NV                                 0x8CE2
+#define GL_COLOR_ATTACHMENT3_NV                                 0x8CE3
+#define GL_COLOR_ATTACHMENT4_NV                                 0x8CE4
+#define GL_COLOR_ATTACHMENT5_NV                                 0x8CE5
+#define GL_COLOR_ATTACHMENT6_NV                                 0x8CE6
+#define GL_COLOR_ATTACHMENT7_NV                                 0x8CE7
+#define GL_COLOR_ATTACHMENT8_NV                                 0x8CE8
+#define GL_COLOR_ATTACHMENT9_NV                                 0x8CE9
+#define GL_COLOR_ATTACHMENT10_NV                                0x8CEA
+#define GL_COLOR_ATTACHMENT11_NV                                0x8CEB
+#define GL_COLOR_ATTACHMENT12_NV                                0x8CEC
+#define GL_COLOR_ATTACHMENT13_NV                                0x8CED
+#define GL_COLOR_ATTACHMENT14_NV                                0x8CEE
+#define GL_COLOR_ATTACHMENT15_NV                                0x8CEF
+#endif
+
+/* GL_NV_fbo_color_attachments */
+#ifndef GL_NV_fbo_color_attachments
+#define GL_MAX_COLOR_ATTACHMENTS_NV                             0x8CDF
+/* GL_COLOR_ATTACHMENT{0-15}_NV defined in GL_NV_draw_buffers already. */
+#endif
+
+/* GL_NV_fence */
+#ifndef GL_NV_fence
+#define GL_ALL_COMPLETED_NV                                     0x84F2
+#define GL_FENCE_STATUS_NV                                      0x84F3
+#define GL_FENCE_CONDITION_NV                                   0x84F4
+#endif
+
+/* GL_NV_read_buffer */
+#ifndef GL_NV_read_buffer
+#define GL_READ_BUFFER_NV                                       0x0C02
+#endif
+
+/* GL_NV_read_buffer_front */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_read_depth */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_read_depth_stencil */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_read_stencil */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_texture_compression_s3tc_update */
+/* No new tokens introduced by this extension. */
+
+/* GL_NV_texture_npot_2D_mipmap */
+/* No new tokens introduced by this extension. */
+
 /*------------------------------------------------------------------------*
  * QCOM extension tokens
  *------------------------------------------------------------------------*/
 
+/* GL_QCOM_alpha_test */
+#ifndef GL_QCOM_alpha_test
+#define GL_ALPHA_TEST_QCOM                                      0x0BC0
+#define GL_ALPHA_TEST_FUNC_QCOM                                 0x0BC1
+#define GL_ALPHA_TEST_REF_QCOM                                  0x0BC2
+#endif
+
 /* GL_QCOM_driver_control */
 /* No new tokens introduced by this extension. */
 
@@ -357,22 +666,12 @@
 #endif
 
 /*------------------------------------------------------------------------*
- * ANGLE extension tokens
+ * VIV extension tokens
  *------------------------------------------------------------------------*/
 
-/* GL_ANGLE_framebuffer_blit */
-#ifndef GL_ANGLE_framebuffer_blit
-#define GL_READ_FRAMEBUFFER_ANGLE         0x8CA8
-#define GL_DRAW_FRAMEBUFFER_ANGLE         0x8CA9
-#define GL_DRAW_FRAMEBUFFER_BINDING_ANGLE 0x8CA6 // alias GL_FRAMEBUFFER_BINDING
-#define GL_READ_FRAMEBUFFER_BINDING_ANGLE 0x8CAA
-#endif
-
-/* GL_ANGLE_framebuffer_multisample */
-#ifndef GL_ANGLE_framebuffer_multisample
-#define GL_RENDERBUFFER_SAMPLES_ANGLE                   0x8CAB
-#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE     0x8D56
-#define GL_MAX_SAMPLES_ANGLE                            0x8D57
+/* GL_VIV_shader_binary */
+#ifndef GL_VIV_shader_binary
+#define GL_SHADER_BINARY_VIV                                    0x8FC4
 #endif
 
 /*------------------------------------------------------------------------*
@@ -419,6 +718,12 @@
 typedef void (GL_APIENTRYP PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC) (GLenum target, GLeglImageOES image);
 #endif
 
+/* GL_OES_EGL_image_external */
+#ifndef GL_OES_EGL_image_external
+#define GL_OES_EGL_image_external 1
+/* glEGLImageTargetTexture2DOES defined in GL_OES_EGL_image already. */
+#endif
+
 /* GL_OES_element_index_uint */
 #ifndef GL_OES_element_index_uint
 #define GL_OES_element_index_uint 1
@@ -601,6 +906,114 @@
 #endif
 
 /*------------------------------------------------------------------------*
+ * ANGLE extension functions
+ *------------------------------------------------------------------------*/
+
+/* GL_ANGLE_framebuffer_blit */
+#ifndef GL_ANGLE_framebuffer_blit
+#define GL_ANGLE_framebuffer_blit 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glBlitFramebufferANGLE (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+#endif
+typedef void (GL_APIENTRYP PFNGLBLITFRAMEBUFFERANGLEPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+#endif
+
+/* GL_ANGLE_framebuffer_multisample */
+#ifndef GL_ANGLE_framebuffer_multisample
+#define GL_ANGLE_framebuffer_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleANGLE (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+#endif
+typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+#endif
+
+/* GL_ANGLE_pack_reverse_row_order */
+#ifndef GL_ANGLE_pack_reverse_row_order
+#define GL_ANGLE_pack_reverse_row_order 1
+#endif
+
+/* GL_ANGLE_texture_compression_dxt3 */
+#ifndef GL_ANGLE_texture_compression_dxt3
+#define GL_ANGLE_texture_compression_dxt3 1
+#endif
+
+/* GL_ANGLE_texture_compression_dxt5 */
+#ifndef GL_ANGLE_texture_compression_dxt5
+#define GL_ANGLE_texture_compression_dxt5 1
+#endif
+
+/* GL_ANGLE_translated_shader_source */
+#ifndef GL_ANGLE_translated_shader_source
+#define GL_ANGLE_translated_shader_source 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glGetTranslatedShaderSourceANGLE (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
+#endif
+typedef void (GL_APIENTRYP PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC) (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
+#endif
+
+/* GL_ANGLE_texture_usage */
+#ifndef GL_ANGLE_texture_usage
+#define GL_ANGLE_texture_usage 1
+#endif
+
+/* GL_ANGLE_instanced_arrays */
+#ifndef GL_ANGLE_instanced_arrays
+#define GL_ANGLE_instanced_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glVertexAttribDivisorANGLE(GLuint index, GLuint divisor);
+GL_APICALL void GL_APIENTRY glDrawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+GL_APICALL void GL_APIENTRY glDrawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+#endif
+typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISORANGLEPROC) (GLuint index, GLuint divisor);
+typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDANGLEPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDANGLEPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount);
+#endif
+
+/*------------------------------------------------------------------------*
+ * APPLE extension functions
+ *------------------------------------------------------------------------*/
+
+/* GL_APPLE_rgb_422 */
+#ifndef GL_APPLE_rgb_422
+#define GL_APPLE_rgb_422 1
+#endif
+
+/* GL_APPLE_framebuffer_multisample */
+#ifndef GL_APPLE_framebuffer_multisample
+#define GL_APPLE_framebuffer_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleAPPLE (GLenum, GLsizei, GLenum, GLsizei, GLsizei);
+GL_APICALL void GL_APIENTRY glResolveMultisampleFramebufferAPPLE (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLEPROC) (void);
+#endif
+
+/* GL_APPLE_texture_format_BGRA8888 */
+#ifndef GL_APPLE_texture_format_BGRA8888
+#define GL_APPLE_texture_format_BGRA8888 1
+#endif
+
+/* GL_APPLE_texture_max_level */
+#ifndef GL_APPLE_texture_max_level
+#define GL_APPLE_texture_max_level 1
+#endif
+
+/*------------------------------------------------------------------------*
+ * ARM extension functions
+ *------------------------------------------------------------------------*/
+
+/* GL_ARM_mali_shader_binary */
+#ifndef GL_ARM_mali_shader_binary
+#define GL_ARM_mali_shader_binary 1
+#endif
+
+/* GL_ARM_rgba8 */
+#ifndef GL_ARM_rgba8
+#define GL_ARM_rgba8 1
+#endif
+
+/*------------------------------------------------------------------------*
  * EXT extension functions
  *------------------------------------------------------------------------*/
 
@@ -609,6 +1022,35 @@
 #define GL_EXT_blend_minmax 1
 #endif
 
+/* GL_EXT_color_buffer_half_float */
+#ifndef GL_EXT_color_buffer_half_float
+#define GL_EXT_color_buffer_half_float 1
+#endif
+
+/* GL_EXT_debug_label */
+#ifndef GL_EXT_debug_label
+#define GL_EXT_debug_label 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glLabelObjectEXT (GLenum type, GLuint object, GLsizei length, const GLchar *label);
+GL_APICALL void GL_APIENTRY glGetObjectLabelEXT (GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label);
+#endif
+typedef void (GL_APIENTRYP PFNGLLABELOBJECTEXTPROC) (GLenum type, GLuint object, GLsizei length, const GLchar *label);
+typedef void (GL_APIENTRYP PFNGLGETOBJECTLABELEXTPROC) (GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label);
+#endif
+
+/* GL_EXT_debug_marker */
+#ifndef GL_EXT_debug_marker
+#define GL_EXT_debug_marker 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glInsertEventMarkerEXT (GLsizei length, const GLchar *marker);
+GL_APICALL void GL_APIENTRY glPushGroupMarkerEXT (GLsizei length, const GLchar *marker);
+GL_APICALL void GL_APIENTRY glPopGroupMarkerEXT (void);
+#endif
+typedef void (GL_APIENTRYP PFNGLINSERTEVENTMARKEREXTPROC) (GLsizei length, const GLchar *marker);
+typedef void (GL_APIENTRYP PFNGLPUSHGROUPMARKEREXTPROC) (GLsizei length, const GLchar *marker);
+typedef void (GL_APIENTRYP PFNGLPOPGROUPMARKEREXTPROC) (void);
+#endif
+
 /* GL_EXT_discard_framebuffer */
 #ifndef GL_EXT_discard_framebuffer
 #define GL_EXT_discard_framebuffer 1
@@ -618,6 +1060,17 @@
 typedef void (GL_APIENTRYP PFNGLDISCARDFRAMEBUFFEREXTPROC) (GLenum target, GLsizei numAttachments, const GLenum *attachments);
 #endif
 
+/* GL_EXT_multisampled_render_to_texture */
+#ifndef GL_EXT_multisampled_render_to_texture
+#define GL_EXT_multisampled_render_to_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleEXT (GLenum, GLsizei, GLenum, GLsizei, GLsizei);
+GL_APICALL void GL_APIENTRY glFramebufferTexture2DMultisampleEXT (GLenum, GLenum, GLenum, GLuint, GLint, GLsizei);
+#endif
+typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
+#endif
+
 #ifndef GL_EXT_multi_draw_arrays
 #define GL_EXT_multi_draw_arrays 1
 #ifdef GL_GLEXT_PROTOTYPES
@@ -628,11 +1081,134 @@
 typedef void (GL_APIENTRYP PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
 #endif
 
+/* GL_EXT_occlusion_query_boolean */
+#ifndef GL_EXT_occlusion_query_boolean
+#define GL_EXT_occlusion_query_boolean 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glGenQueriesEXT (GLsizei n, GLuint *ids);
+GL_APICALL void GL_APIENTRY glDeleteQueriesEXT (GLsizei n, const GLuint *ids);
+GL_APICALL GLboolean GL_APIENTRY glIsQueryEXT (GLuint id);
+GL_APICALL void GL_APIENTRY glBeginQueryEXT (GLenum target, GLuint id);
+GL_APICALL void GL_APIENTRY glEndQueryEXT (GLenum target);
+GL_APICALL void GL_APIENTRY glGetQueryivEXT (GLenum target, GLenum pname, GLint *params);
+GL_APICALL void GL_APIENTRY glGetQueryObjectuivEXT (GLuint id, GLenum pname, GLuint *params);
+#endif
+typedef void (GL_APIENTRYP PFNGLGENQUERIESEXTPROC) (GLsizei n, GLuint *ids);
+typedef void (GL_APIENTRYP PFNGLDELETEQUERIESEXTPROC) (GLsizei n, const GLuint *ids);
+typedef GLboolean (GL_APIENTRYP PFNGLISQUERYEXTPROC) (GLuint id);
+typedef void (GL_APIENTRYP PFNGLBEGINQUERYEXTPROC) (GLenum target, GLuint id);
+typedef void (GL_APIENTRYP PFNGLENDQUERYEXTPROC) (GLenum target);
+typedef void (GL_APIENTRYP PFNGLGETQUERYIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (GL_APIENTRYP PFNGLGETQUERYOBJECTUIVEXTPROC) (GLuint id, GLenum pname, GLuint *params);
+#endif
+
 /* GL_EXT_read_format_bgra */
 #ifndef GL_EXT_read_format_bgra
 #define GL_EXT_read_format_bgra 1
 #endif
 
+/* GL_EXT_robustness */
+#ifndef GL_EXT_robustness
+#define GL_EXT_robustness 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL GLenum GL_APIENTRY glGetGraphicsResetStatusEXT (void);
+GL_APICALL void GL_APIENTRY glReadnPixelsEXT (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
+GL_APICALL void GL_APIENTRY glGetnUniformfvEXT (GLuint program, GLint location, GLsizei bufSize, float *params);
+GL_APICALL void GL_APIENTRY glGetnUniformivEXT (GLuint program, GLint location, GLsizei bufSize, GLint *params);
+#endif
+typedef GLenum (GL_APIENTRYP PFNGLGETGRAPHICSRESETSTATUSEXTPROC) (void);
+typedef void (GL_APIENTRYP PFNGLREADNPIXELSEXTPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
+typedef void (GL_APIENTRYP PFNGLGETNUNIFORMFVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, float *params);
+typedef void (GL_APIENTRYP PFNGLGETNUNIFORMIVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, GLint *params);
+#endif
+
+/* GL_EXT_separate_shader_objects */
+#ifndef GL_EXT_separate_shader_objects
+#define GL_EXT_separate_shader_objects 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glUseProgramStagesEXT (GLuint pipeline, GLbitfield stages, GLuint program);
+GL_APICALL void GL_APIENTRY glActiveShaderProgramEXT (GLuint pipeline, GLuint program);
+GL_APICALL GLuint GL_APIENTRY glCreateShaderProgramvEXT (GLenum type, GLsizei count, const GLchar **strings);
+GL_APICALL void GL_APIENTRY glBindProgramPipelineEXT (GLuint pipeline);
+GL_APICALL void GL_APIENTRY glDeleteProgramPipelinesEXT (GLsizei n, const GLuint *pipelines);
+GL_APICALL void GL_APIENTRY glGenProgramPipelinesEXT (GLsizei n, GLuint *pipelines);
+GL_APICALL GLboolean GL_APIENTRY glIsProgramPipelineEXT (GLuint pipeline);
+GL_APICALL void GL_APIENTRY glProgramParameteriEXT (GLuint program, GLenum pname, GLint value);
+GL_APICALL void GL_APIENTRY glGetProgramPipelineivEXT (GLuint pipeline, GLenum pname, GLint *params);
+GL_APICALL void GL_APIENTRY glProgramUniform1iEXT (GLuint program, GLint location, GLint x);
+GL_APICALL void GL_APIENTRY glProgramUniform2iEXT (GLuint program, GLint location, GLint x, GLint y);
+GL_APICALL void GL_APIENTRY glProgramUniform3iEXT (GLuint program, GLint location, GLint x, GLint y, GLint z);
+GL_APICALL void GL_APIENTRY glProgramUniform4iEXT (GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w);
+GL_APICALL void GL_APIENTRY glProgramUniform1fEXT (GLuint program, GLint location, GLfloat x);
+GL_APICALL void GL_APIENTRY glProgramUniform2fEXT (GLuint program, GLint location, GLfloat x, GLfloat y);
+GL_APICALL void GL_APIENTRY glProgramUniform3fEXT (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z);
+GL_APICALL void GL_APIENTRY glProgramUniform4fEXT (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GL_APICALL void GL_APIENTRY glProgramUniform1ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GL_APICALL void GL_APIENTRY glProgramUniform2ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GL_APICALL void GL_APIENTRY glProgramUniform3ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GL_APICALL void GL_APIENTRY glProgramUniform4ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
+GL_APICALL void GL_APIENTRY glProgramUniform1fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniform2fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniform3fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniform4fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniformMatrix2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniformMatrix3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glProgramUniformMatrix4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GL_APICALL void GL_APIENTRY glValidateProgramPipelineEXT (GLuint pipeline);
+GL_APICALL void GL_APIENTRY glGetProgramPipelineInfoLogEXT (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+#endif
+typedef void (GL_APIENTRYP PFNGLUSEPROGRAMSTAGESEXTPROC) (GLuint pipeline, GLbitfield stages, GLuint program);
+typedef void (GL_APIENTRYP PFNGLACTIVESHADERPROGRAMEXTPROC) (GLuint pipeline, GLuint program);
+typedef GLuint (GL_APIENTRYP PFNGLCREATESHADERPROGRAMVEXTPROC) (GLenum type, GLsizei count, const GLchar **strings);
+typedef void (GL_APIENTRYP PFNGLBINDPROGRAMPIPELINEEXTPROC) (GLuint pipeline);
+typedef void (GL_APIENTRYP PFNGLDELETEPROGRAMPIPELINESEXTPROC) (GLsizei n, const GLuint *pipelines);
+typedef void (GL_APIENTRYP PFNGLGENPROGRAMPIPELINESEXTPROC) (GLsizei n, GLuint *pipelines);
+typedef GLboolean (GL_APIENTRYP PFNGLISPROGRAMPIPELINEEXTPROC) (GLuint pipeline);
+typedef void (GL_APIENTRYP PFNGLPROGRAMPARAMETERIEXTPROC) (GLuint program, GLenum pname, GLint value);
+typedef void (GL_APIENTRYP PFNGLGETPROGRAMPIPELINEIVEXTPROC) (GLuint pipeline, GLenum pname, GLint *params);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM1IEXTPROC) (GLuint program, GLint location, GLint x);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM2IEXTPROC) (GLuint program, GLint location, GLint x, GLint y);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM3IEXTPROC) (GLuint program, GLint location, GLint x, GLint y, GLint z);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM4IEXTPROC) (GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM1FEXTPROC) (GLuint program, GLint location, GLfloat x);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM2FEXTPROC) (GLuint program, GLint location, GLfloat x, GLfloat y);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM3FEXTPROC) (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM4FEXTPROC) (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM1IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM2IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM3IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM4IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM1FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM2FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM3FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORM4FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (GL_APIENTRYP PFNGLVALIDATEPROGRAMPIPELINEEXTPROC) (GLuint pipeline);
+typedef void (GL_APIENTRYP PFNGLGETPROGRAMPIPELINEINFOLOGEXTPROC) (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+#endif
+
+/* GL_EXT_shader_texture_lod */
+#ifndef GL_EXT_shader_texture_lod
+#define GL_EXT_shader_texture_lod 1
+#endif
+
+/* GL_EXT_shadow_samplers */
+#ifndef GL_EXT_shadow_samplers
+#define GL_EXT_shadow_samplers 1
+#endif
+
+/* GL_EXT_sRGB */
+#ifndef GL_EXT_sRGB
+#define GL_EXT_sRGB 1
+#endif
+
+/* GL_EXT_texture_compression_dxt1 */
+#ifndef GL_EXT_texture_compression_dxt1
+#define GL_EXT_texture_compression_dxt1 1
+#endif
+
 /* GL_EXT_texture_filter_anisotropic */
 #ifndef GL_EXT_texture_filter_anisotropic
 #define GL_EXT_texture_filter_anisotropic 1
@@ -643,14 +1219,47 @@
 #define GL_EXT_texture_format_BGRA8888 1
 #endif
 
+/* GL_EXT_texture_rg */
+#ifndef GL_EXT_texture_rg
+#define GL_EXT_texture_rg 1
+#endif
+
+/* GL_EXT_texture_storage */
+#ifndef GL_EXT_texture_storage
+#define GL_EXT_texture_storage 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glTexStorage1DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+GL_APICALL void GL_APIENTRY glTexStorage2DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+GL_APICALL void GL_APIENTRY glTexStorage3DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+GL_APICALL void GL_APIENTRY glTextureStorage1DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+GL_APICALL void GL_APIENTRY glTextureStorage2DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+GL_APICALL void GL_APIENTRY glTextureStorage3DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+#endif
+typedef void (GL_APIENTRYP PFNGLTEXSTORAGE1DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+typedef void (GL_APIENTRYP PFNGLTEXSTORAGE2DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLTEXSTORAGE3DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+typedef void (GL_APIENTRYP PFNGLTEXTURESTORAGE1DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+typedef void (GL_APIENTRYP PFNGLTEXTURESTORAGE2DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLTEXTURESTORAGE3DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+#endif
+
 /* GL_EXT_texture_type_2_10_10_10_REV */
 #ifndef GL_EXT_texture_type_2_10_10_10_REV
 #define GL_EXT_texture_type_2_10_10_10_REV 1
 #endif
 
-/* GL_EXT_texture_compression_dxt1 */
-#ifndef GL_EXT_texture_compression_dxt1
-#define GL_EXT_texture_compression_dxt1 1
+/* GL_EXT_unpack_subimage */
+#ifndef GL_EXT_unpack_subimage
+#define GL_EXT_unpack_subimage 1
+#endif
+
+/*------------------------------------------------------------------------*
+ * DMP extension functions
+ *------------------------------------------------------------------------*/
+
+/* GL_DMP_shader_binary */
+#ifndef GL_DMP_shader_binary
+#define GL_DMP_shader_binary 1
 #endif
 
 /*------------------------------------------------------------------------*
@@ -677,10 +1286,51 @@
 #define GL_IMG_texture_compression_pvrtc 1
 #endif
 
+/* GL_IMG_multisampled_render_to_texture */
+#ifndef GL_IMG_multisampled_render_to_texture
+#define GL_IMG_multisampled_render_to_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleIMG (GLenum, GLsizei, GLenum, GLsizei, GLsizei);
+GL_APICALL void GL_APIENTRY glFramebufferTexture2DMultisampleIMG (GLenum, GLenum, GLenum, GLuint, GLint, GLsizei);
+#endif
+typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GL_APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
+#endif
+
 /*------------------------------------------------------------------------*
  * NV extension functions
  *------------------------------------------------------------------------*/
 
+/* GL_NV_coverage_sample */
+#ifndef GL_NV_coverage_sample
+#define GL_NV_coverage_sample 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glCoverageMaskNV (GLboolean mask);
+GL_APICALL void GL_APIENTRY glCoverageOperationNV (GLenum operation);
+#endif
+typedef void (GL_APIENTRYP PFNGLCOVERAGEMASKNVPROC) (GLboolean mask);
+typedef void (GL_APIENTRYP PFNGLCOVERAGEOPERATIONNVPROC) (GLenum operation);
+#endif
+
+/* GL_NV_depth_nonlinear */
+#ifndef GL_NV_depth_nonlinear
+#define GL_NV_depth_nonlinear 1
+#endif
+
+/* GL_NV_draw_buffers */
+#ifndef GL_NV_draw_buffers
+#define GL_NV_draw_buffers 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glDrawBuffersNV (GLsizei n, const GLenum *bufs);
+#endif
+typedef void (GL_APIENTRYP PFNGLDRAWBUFFERSNVPROC) (GLsizei n, const GLenum *bufs);
+#endif
+
+/* GL_NV_fbo_color_attachments */
+#ifndef GL_NV_fbo_color_attachments
+#define GL_NV_fbo_color_attachments 1
+#endif
+
 /* GL_NV_fence */
 #ifndef GL_NV_fence
 #define GL_NV_fence 1
@@ -702,26 +1352,58 @@
 typedef void (GL_APIENTRYP PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition);
 #endif
 
-/* GL_NV_coverage_sample */
-#ifndef GL_NV_coverage_sample
-#define GL_NV_coverage_sample 1
+/* GL_NV_read_buffer */
+#ifndef GL_NV_read_buffer
+#define GL_NV_read_buffer 1
 #ifdef GL_GLEXT_PROTOTYPES
-GL_APICALL void GL_APIENTRY glCoverageMaskNV (GLboolean mask);
-GL_APICALL void GL_APIENTRY glCoverageOperationNV (GLenum operation);
+GL_APICALL void GL_APIENTRY glReadBufferNV (GLenum mode);
 #endif
-typedef void (GL_APIENTRYP PFNGLCOVERAGEMASKNVPROC) (GLboolean mask);
-typedef void (GL_APIENTRYP PFNGLCOVERAGEOPERATIONNVPROC) (GLenum operation);
+typedef void (GL_APIENTRYP PFNGLREADBUFFERNVPROC) (GLenum mode);
 #endif
 
-/* GL_NV_depth_nonlinear */
-#ifndef GL_NV_depth_nonlinear
-#define GL_NV_depth_nonlinear 1
+/* GL_NV_read_buffer_front */
+#ifndef GL_NV_read_buffer_front
+#define GL_NV_read_buffer_front 1
+#endif
+
+/* GL_NV_read_depth */
+#ifndef GL_NV_read_depth
+#define GL_NV_read_depth 1
+#endif
+
+/* GL_NV_read_depth_stencil */
+#ifndef GL_NV_read_depth_stencil
+#define GL_NV_read_depth_stencil 1
+#endif
+
+/* GL_NV_read_stencil */
+#ifndef GL_NV_read_stencil
+#define GL_NV_read_stencil 1
+#endif
+
+/* GL_NV_texture_compression_s3tc_update */
+#ifndef GL_NV_texture_compression_s3tc_update
+#define GL_NV_texture_compression_s3tc_update 1
+#endif
+
+/* GL_NV_texture_npot_2D_mipmap */
+#ifndef GL_NV_texture_npot_2D_mipmap
+#define GL_NV_texture_npot_2D_mipmap 1
 #endif
 
 /*------------------------------------------------------------------------*
  * QCOM extension functions
  *------------------------------------------------------------------------*/
 
+/* GL_QCOM_alpha_test */
+#ifndef GL_QCOM_alpha_test
+#define GL_QCOM_alpha_test 1
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glAlphaFuncQCOM (GLenum func, GLclampf ref);
+#endif
+typedef void (GL_APIENTRYP PFNGLALPHAFUNCQCOMPROC) (GLenum func, GLclampf ref);
+#endif
+
 /* GL_QCOM_driver_control */
 #ifndef GL_QCOM_driver_control
 #define GL_QCOM_driver_control 1
@@ -797,31 +1479,12 @@
 #endif
 
 /*------------------------------------------------------------------------*
- * ANGLE extension functions
+ * VIV extension tokens
  *------------------------------------------------------------------------*/
 
-/* GL_ANGLE_framebuffer_blit */
-#ifndef GL_ANGLE_framebuffer_blit
-#define GL_ANGLE_framebuffer_blit 1
-#ifdef GL_GLEXT_PROTOTYPES
-GL_APICALL void GL_APIENTRY glBlitFramebufferANGLE (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                                                    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                                                    GLbitfield mask, GLenum filter);
-#endif
-typedef void (GL_APIENTRYP PFNGLBLITFRAMEBUFFERANGLEPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                                                           GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                                                           GLbitfield mask, GLenum filter);
-#endif
-
-/* GL_ANGLE_framebuffer_multisample */
-#ifndef GL_ANGLE_framebuffer_multisample
-#define GL_ANGLE_framebuffer_multisample 1
-#ifdef GL_GLEXT_PROTOTYPES
-GL_APICALL void GL_APIENTRY glRenderbufferStorageMultisampleANGLE (GLenum target, GLsizei samples, GLenum internalformat, 
-                                                                   GLsizei width, GLsizei height);
-#endif
-typedef void (GL_APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC) (GLenum target, GLsizei samples, GLenum internalformat,
-                                                                          GLsizei width, GLsizei height);
+/* GL_VIV_shader_binary */
+#ifndef GL_VIV_shader_binary
+#define GL_VIV_shader_binary 1
 #endif
 
 #ifdef __cplusplus
diff --git a/src/OpenGL ES 2.0/include/GLSLANG/ShaderLang.h b/src/OpenGL ES 2.0/include/GLSLANG/ShaderLang.h
index 6795a87..0d78834 100644
--- a/src/OpenGL ES 2.0/include/GLSLANG/ShaderLang.h
+++ b/src/OpenGL ES 2.0/include/GLSLANG/ShaderLang.h
@@ -62,8 +62,7 @@
   SH_ACTIVE_UNIFORMS             =  0x8B86,
   SH_ACTIVE_UNIFORM_MAX_LENGTH   =  0x8B87,
   SH_ACTIVE_ATTRIBUTES           =  0x8B89,
-  SH_ACTIVE_ATTRIBUTE_MAX_LENGTH =  0x8B8A,
-  SH_MAPPED_NAME_MAX_LENGTH      =  0x8B8B
+  SH_ACTIVE_ATTRIBUTE_MAX_LENGTH =  0x8B8A
 } ShShaderInfo;
 
 // Compile options.
@@ -74,8 +73,7 @@
   SH_OBJECT_CODE             = 0x0004,
   SH_ATTRIBUTES_UNIFORMS     = 0x0008,
   SH_LINE_DIRECTIVES         = 0x0010,
-  SH_SOURCE_PATH             = 0x0020,
-  SH_MAP_LONG_VARIABLE_NAMES = 0x0040
+  SH_SOURCE_PATH             = 0x0020
 } ShCompileOptions;
 
 //
diff --git a/src/OpenGL ES 2.0/libEGL/Config.cpp b/src/OpenGL ES 2.0/libEGL/Config.cpp
index 4851edb..f675bb1 100644
--- a/src/OpenGL ES 2.0/libEGL/Config.cpp
+++ b/src/OpenGL ES 2.0/libEGL/Config.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Config.cpp: Implements the egl::Config class, describing the format, type
diff --git a/src/OpenGL ES 2.0/libEGL/Config.h b/src/OpenGL ES 2.0/libEGL/Config.h
index 1dc260d..ae0bbcc 100644
--- a/src/OpenGL ES 2.0/libEGL/Config.h
+++ b/src/OpenGL ES 2.0/libEGL/Config.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Config.h: Defines the egl::Config class, describing the format, type
diff --git a/src/OpenGL ES 2.0/libEGL/Display.cpp b/src/OpenGL ES 2.0/libEGL/Display.cpp
index c4273c4..07bf868 100644
--- a/src/OpenGL ES 2.0/libEGL/Display.cpp
+++ b/src/OpenGL ES 2.0/libEGL/Display.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Display.cpp: Implements the egl::Display class, representing the abstract
@@ -63,12 +68,28 @@
 	displays.erase(displayId);
 }
 
+static bool detectSSE()
+{
+	#if defined(_WIN32) && _M_IX86 >= 500
+		int registers[4];
+		__cpuid(registers, 1);
+		return (registers[3] & 0x02000000) != 0;
+	#else
+		#error Unimplemented platform
+	#endif
+}
+
 bool Display::initialize()
 {
     if(isInitialized())
     {
         return true;
     }
+
+	if(!detectSSE())
+	{
+		 return false;
+	}
 		
     mMinSwapInterval = 0;
     mMaxSwapInterval = 4;
@@ -482,7 +503,7 @@
     std::string::size_type end = mExtensionString.find_last_not_of(' ');
     if(end != std::string::npos)
     {
-        mExtensionString.resize(end+1);
+        mExtensionString.resize(end + 1);
     }
 }
 
diff --git a/src/OpenGL ES 2.0/libEGL/Display.h b/src/OpenGL ES 2.0/libEGL/Display.h
index 4449a28..1ce295e 100644
--- a/src/OpenGL ES 2.0/libEGL/Display.h
+++ b/src/OpenGL ES 2.0/libEGL/Display.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Display.h: Defines the egl::Display class, representing the abstract
@@ -22,11 +27,6 @@
 #include <windows.h>
 #include <set>
 
-namespace sw
-{
-	class Context;
-}
-
 namespace egl
 {
 	class Display
@@ -39,8 +39,8 @@
 		bool initialize();
 		void terminate();
 
-		virtual void startScene() {};   // FIXME: Remove when Chrome no longer calls getDevice() directly
-		virtual void endScene() {};     // FIXME: Remove when Chrome no longer calls getDevice() directly
+		virtual void startScene() {ASSERT(!"Stop calling internal ANGLE methods!");};   // FIXME: Remove when Chrome no longer calls getDevice() directly
+		virtual void endScene() {ASSERT(!"Stop calling internal ANGLE methods!");};     // FIXME: Remove when Chrome no longer calls getDevice() directly
 
 		bool getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig);
 		bool getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value);
@@ -61,7 +61,7 @@
 		EGLint getMinSwapInterval();
 		EGLint getMaxSwapInterval();
 
-		virtual gl::Device *getDeviceChrome() {return 0;};   // FIXME: Remove when Chrome no longer calls getDevice() directly
+		virtual gl::Device *getDeviceChrome() {ASSERT(!"Stop calling internal ANGLE methods!"); return 0;};   // FIXME: Remove when Chrome no longer calls getDevice() directly
 		virtual gl::Device *getDevice();
 
 		const char *getExtensionString() const;
diff --git a/src/OpenGL ES 2.0/libEGL/Surface.cpp b/src/OpenGL ES 2.0/libEGL/Surface.cpp
index 456bf01..d31ed14 100644
--- a/src/OpenGL ES 2.0/libEGL/Surface.cpp
+++ b/src/OpenGL ES 2.0/libEGL/Surface.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Surface.cpp: Implements the egl::Surface class, representing a drawing surface
@@ -23,22 +28,6 @@
 namespace egl
 {
 
-namespace
-{
-const int versionWindowsVista = MAKEWORD(0x00, 0x06);
-const int versionWindows7 = MAKEWORD(0x01, 0x06);
-
-// Return the version of the operating system in a format suitable for ordering
-// comparison.
-int getComparableOSVersion()
-{
-    DWORD version = GetVersion();
-    int majorVersion = LOBYTE(LOWORD(version));
-    int minorVersion = HIBYTE(LOWORD(version));
-    return MAKEWORD(minorVersion, majorVersion);
-}
-}
-
 Surface::Surface(Display *display, const Config *config, HWND window) 
     : mDisplay(display), mConfig(config), mWindow(window)
 {
@@ -96,7 +85,7 @@
     // Modify present parameters for this window, if we are composited,
     // to minimize the amount of queuing done by DWM between our calls to
     // present and the actual screen.
-    if (mWindow && (getComparableOSVersion() >= versionWindowsVista))
+    if(mWindow && (LOWORD(GetVersion()) >= 0x60))
 	{
         BOOL isComposited;
         HRESULT result = DwmIsCompositionEnabled(&isComposited);
@@ -175,7 +164,7 @@
 
     if(mWindow)
     {
-		frameBuffer = createFrameBuffer(0, backBufferWidth, backBufferHeight, false);
+		frameBuffer = createFrameBuffer(0, backBufferWidth, backBufferHeight, false, false);
 
 		if(!frameBuffer)
 		{
diff --git a/src/OpenGL ES 2.0/libEGL/Surface.h b/src/OpenGL ES 2.0/libEGL/Surface.h
index 7cff1bc..934b059 100644
--- a/src/OpenGL ES 2.0/libEGL/Surface.h
+++ b/src/OpenGL ES 2.0/libEGL/Surface.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Surface.h: Defines the egl::Surface class, representing a drawing surface
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.cpp b/src/OpenGL ES 2.0/libEGL/libEGL.cpp
index d91e5e7..3d29a8c 100644
--- a/src/OpenGL ES 2.0/libEGL/libEGL.cpp
+++ b/src/OpenGL ES 2.0/libEGL/libEGL.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // libEGL.cpp: Implements the exported EGL functions.
@@ -186,7 +191,7 @@
           case EGL_VENDOR:
             return success("TransGaming Inc.");
           case EGL_VERSION:
-            return success("1.4 (ANGLE "VERSION_STRING")");
+            return success("1.4 (SwiftShader "VERSION_STRING")");
         }
 
         return error(EGL_BAD_PARAMETER, (const char*)NULL);
@@ -436,7 +441,7 @@
             return error(EGL_BAD_SURFACE, EGL_FALSE);
         }
 
-        switch (attribute)
+        switch(attribute)
         {
           case EGL_VG_ALPHA_FORMAT:
             UNIMPLEMENTED();   // FIXME
@@ -846,7 +851,7 @@
         }
 
         if((draw != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(draw))) ||
-            (read != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(read))))
+           (read != EGL_NO_SURFACE && !validateSurface(display, static_cast<egl::Surface*>(read))))
         {
             return EGL_FALSE;
         }
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.rc b/src/OpenGL ES 2.0/libEGL/libEGL.rc
index a8487df..d426063 100644
--- a/src/OpenGL ES 2.0/libEGL/libEGL.rc
+++ b/src/OpenGL ES 2.0/libEGL/libEGL.rc
@@ -73,7 +73,7 @@
             VALUE "FileDescription", "SwiftShader libEGL Dynamic Link Library"
             VALUE "FileVersion", VERSION_STRING
             VALUE "InternalName", "libEGL"
-            VALUE "LegalCopyright", "Copyright (C) 2011 TransGaming Inc."
+            VALUE "LegalCopyright", "Copyright (C) 2012 TransGaming Inc."
             VALUE "OriginalFilename", "libEGL.dll"
             VALUE "PrivateBuild", VERSION_STRING
             VALUE "ProductName", "SwiftShader libEGL Dynamic Link Library"
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.vcproj b/src/OpenGL ES 2.0/libEGL/libEGL.vcproj
deleted file mode 100644
index 68b041f..0000000
--- a/src/OpenGL ES 2.0/libEGL/libEGL.vcproj
+++ /dev/null
@@ -1,268 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="libEGL"
-	ProjectGUID="{E746FCA9-64C3-433E-85E8-9A5A67AB7ED6}"
-	RootNamespace="libEGL"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="131072"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="2"
-			CharacterSet="0"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="$(ProjectDir)/..;$(ProjectDir)/../..; $(ProjectDir)/../include"
-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBEGL_EXPORTS;_CRT_SECURE_NO_DEPRECATE;NOMINMAX"
-				MinimalRebuild="true"
-				ExceptionHandling="1"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="false"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="d3d9.lib dxguid.lib dwmapi.lib"
-				LinkIncremental="2"
-				ModuleDefinitionFile="libEGL.def"
-				DelayLoadDLLs="dwmapi.dll"
-				GenerateDebugInformation="true"
-				SubSystem="2"
-				RandomizedBaseAddress="1"
-				DataExecutionPrevention="0"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-				CommandLine="@echo on&#x0D;&#x0A;mkdir &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;copy &quot;$(OutDir)\libEGL.dll&quot; &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;copy &quot;$(OutDir)\libEGL.lib&quot; &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;@echo off&#x0D;&#x0A;"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="2"
-			CharacterSet="0"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				InlineFunctionExpansion="2"
-				AdditionalIncludeDirectories="$(ProjectDir)/..;$(ProjectDir)/../..; $(ProjectDir)/../include"
-				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBEGL_EXPORTS;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0"
-				ExceptionHandling="1"
-				RuntimeLibrary="0"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="false"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="d3d9.lib dxguid.lib dwmapi.lib"
-				LinkIncremental="1"
-				ModuleDefinitionFile="libEGL.def"
-				DelayLoadDLLs="dwmapi.dll"
-				GenerateDebugInformation="true"
-				SubSystem="2"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				RandomizedBaseAddress="1"
-				DataExecutionPrevention="0"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-				CommandLine="@echo on&#x0D;&#x0A;mkdir &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;copy &quot;$(OutDir)\libEGL.dll&quot; &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;copy &quot;$(OutDir)\libEGL.lib&quot; &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;@echo off&#x0D;&#x0A;"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath=".\Config.cpp"
-				>
-			</File>
-			<File
-				RelativePath="..\Common\debug.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Display.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\libEGL.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\main.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Surface.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-			<File
-				RelativePath=".\Config.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Display.h"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\EGL\egl.h"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\EGL\eglext.h"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\EGL\eglplatform.h"
-				>
-			</File>
-			<File
-				RelativePath=".\main.h"
-				>
-			</File>
-			<File
-				RelativePath=".\resource.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Surface.h"
-				>
-			</File>
-			<File
-				RelativePath="..\common\version.h"
-				>
-			</File>
-		</Filter>
-		<File
-			RelativePath=".\libEGL.def"
-			>
-		</File>
-		<File
-			RelativePath=".\libEGL.rc"
-			>
-		</File>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj
index 4eca5e1..0b0dc8a 100644
--- a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj
+++ b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj
@@ -75,7 +75,6 @@
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <BrowseInformation>true</BrowseInformation>
-      <ExceptionHandling>Sync</ExceptionHandling>
     </ClCompile>
     <Link>
       <AdditionalDependencies>dwmapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
@@ -106,7 +105,6 @@
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <ExceptionHandling>Sync</ExceptionHandling>
     </ClCompile>
     <Link>
       <AdditionalDependencies>dwmapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
@@ -139,6 +137,7 @@
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <OmitFramePointers>false</OmitFramePointers>
     </ClCompile>
     <Link>
       <AdditionalDependencies>dwmapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
@@ -169,15 +168,14 @@
     <ClCompile Include="Surface.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="..\include\EGL\egl.h" />
+    <ClInclude Include="..\include\EGL\eglext.h" />
+    <ClInclude Include="..\include\EGL\eglplatform.h" />
     <ClInclude Include="Config.h" />
     <ClInclude Include="Display.h" />
-    <ClInclude Include="..\..\include\EGL\egl.h" />
-    <ClInclude Include="..\..\include\EGL\eglext.h" />
-    <ClInclude Include="..\..\include\EGL\eglplatform.h" />
     <ClInclude Include="main.h" />
     <ClInclude Include="resource.h" />
     <ClInclude Include="Surface.h" />
-    <ClInclude Include="..\common\version.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="libEGL.def" />
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.filters b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.filters
index 860e169..0ee6b4b 100644
--- a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.filters
+++ b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.filters
@@ -37,15 +37,6 @@
     <ClInclude Include="Display.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\EGL\egl.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\EGL\eglext.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\EGL\eglplatform.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="main.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -55,7 +46,13 @@
     <ClInclude Include="Surface.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\common\version.h">
+    <ClInclude Include="..\include\EGL\egl.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\EGL\eglext.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\EGL\eglplatform.h">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
diff --git a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.user b/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.user
deleted file mode 100644
index 695b5c7..0000000
--- a/src/OpenGL ES 2.0/libEGL/libEGL.vcxproj.user
+++ /dev/null
@@ -1,3 +0,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/libEGL/main.cpp b/src/OpenGL ES 2.0/libEGL/main.cpp
index 7c6f44b..6661a1a 100644
--- a/src/OpenGL ES 2.0/libEGL/main.cpp
+++ b/src/OpenGL ES 2.0/libEGL/main.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // main.cpp: DLL entry point and management of thread-local data.
diff --git a/src/OpenGL ES 2.0/libEGL/main.h b/src/OpenGL ES 2.0/libEGL/main.h
index d09d9e6..7ba67a9 100644
--- a/src/OpenGL ES 2.0/libEGL/main.h
+++ b/src/OpenGL ES 2.0/libEGL/main.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // main.h: Management of thread-local data.
diff --git a/src/OpenGL ES 2.0/libGLESv2/Buffer.cpp b/src/OpenGL ES 2.0/libGLESv2/Buffer.cpp
index 0edb0e7..8869800 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Buffer.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Buffer.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Buffer.cpp: Implements the Buffer class, representing storage of vertex and/or
diff --git a/src/OpenGL ES 2.0/libGLESv2/Buffer.h b/src/OpenGL ES 2.0/libGLESv2/Buffer.h
index bdc5244..2b3d2fc 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Buffer.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Buffer.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Buffer.h: Defines the Buffer class, representing storage of vertex and/or
@@ -40,8 +45,6 @@
 	sw::Resource *getResource();
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(Buffer);
-
     sw::Resource *mContents;
     size_t mSize;
     GLenum mUsage;
diff --git a/src/OpenGL ES 2.0/libGLESv2/Context.cpp b/src/OpenGL ES 2.0/libGLESv2/Context.cpp
index 0ab375d..e674e20 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Context.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Context.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Context.cpp: Implements the gl::Context class, managing all GL state and performing
@@ -17,6 +22,7 @@
 #include "Fence.h"
 #include "FrameBuffer.h"
 #include "Program.h"
+#include "Query.h"
 #include "RenderBuffer.h"
 #include "Shader.h"
 #include "Texture.h"
@@ -173,6 +179,11 @@
         deleteFence(mFenceMap.begin()->first);
     }
 
+	while(!mQueryMap.empty())
+    {
+        deleteQuery(mQueryMap.begin()->first);
+    }
+
     while(!mMultiSampleSupport.empty())
     {
         delete [] mMultiSampleSupport.begin()->second;
@@ -192,6 +203,11 @@
         mState.vertexAttribute[i].mBoundBuffer.set(NULL);
     }
 
+	for(int i = 0; i < QUERY_TYPE_COUNT; i++)
+    {
+        mState.activeQuery[i].set(NULL);
+    }
+
     mState.arrayBuffer.set(NULL);
     mState.elementArrayBuffer.set(NULL);
     mState.renderbuffer.set(NULL);
@@ -211,8 +227,8 @@
 
     if(!mHasBeenCurrent)
     {
-        mVertexDataManager = new VertexDataManager(this, device);
-        mIndexDataManager = new IndexDataManager(this, device);
+        mVertexDataManager = new VertexDataManager(this);
+        mIndexDataManager = new IndexDataManager();
 
         const sw::Format renderBufferFormats[] =
         {
@@ -264,19 +280,12 @@
 void Context::markAllStateDirty()
 {
     mAppliedProgramSerial = 0;
-    mAppliedRenderTargetSerial = 0;
-    mAppliedDepthbufferSerial = 0;
-    mAppliedStencilbufferSerial = 0;
-    mDepthStencilInitialized = false;
 
-    mClearStateDirty = true;
-    mCullStateDirty = true;
     mDepthStateDirty = true;
     mMaskStateDirty = true;
     mBlendStateDirty = true;
     mStencilStateDirty = true;
     mPolygonOffsetStateDirty = true;
-    mScissorStateDirty = true;
     mSampleStateDirty = true;
     mDitherStateDirty = true;
     mFrontFaceDirty = true;
@@ -302,11 +311,7 @@
 
 void Context::setCullFace(bool enabled)
 {
-    if(mState.cullFace != enabled)
-    {
-        mState.cullFace = enabled;
-        mCullStateDirty = true;
-    }
+    mState.cullFace = enabled;
 }
 
 bool Context::isCullFaceEnabled() const
@@ -316,11 +321,7 @@
 
 void Context::setCullMode(GLenum mode)
 {
-    if(mState.cullMode != mode)
-    {
-        mState.cullMode = mode;
-        mCullStateDirty = true;
-    }
+   mState.cullMode = mode;
 }
 
 void Context::setFrontFace(GLenum front)
@@ -567,11 +568,7 @@
 
 void Context::setScissorTest(bool enabled)
 {
-    if(mState.scissorTest != enabled)
-    {
-        mState.scissorTest = enabled;
-        mScissorStateDirty = true;
-    }
+    mState.scissorTest = enabled;
 }
 
 bool Context::isScissorTestEnabled() const
@@ -621,21 +618,16 @@
 
 void Context::setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    if(mState.scissorX != x || mState.scissorY != y || 
-        mState.scissorWidth != width || mState.scissorHeight != height)
-    {
-        mState.scissorX = x;
-        mState.scissorY = y;
-        mState.scissorWidth = width;
-        mState.scissorHeight = height;
-        mScissorStateDirty = true;
-    }
+    mState.scissorX = x;
+    mState.scissorY = y;
+    mState.scissorWidth = width;
+    mState.scissorHeight = height;
 }
 
 void Context::setColorMask(bool red, bool green, bool blue, bool alpha)
 {
     if(mState.colorMaskRed != red || mState.colorMaskGreen != green ||
-        mState.colorMaskBlue != blue || mState.colorMaskAlpha != alpha)
+       mState.colorMaskBlue != blue || mState.colorMaskAlpha != alpha)
     {
         mState.colorMaskRed = red;
         mState.colorMaskGreen = green;
@@ -679,6 +671,30 @@
     return mState.arrayBuffer.id();
 }
 
+GLuint Context::getActiveQuery(GLenum target) const
+{
+    Query *queryObject = NULL;
+    
+    switch(target)
+    {
+    case GL_ANY_SAMPLES_PASSED_EXT:
+        queryObject = mState.activeQuery[QUERY_ANY_SAMPLES_PASSED].get();
+        break;
+    case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+        queryObject = mState.activeQuery[QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE].get();
+        break;
+    default:
+        ASSERT(false);
+    }
+
+    if(queryObject)
+    {
+        return queryObject->id();
+    }
+    
+	return 0;
+}
+
 void Context::setEnableVertexAttribArray(unsigned int attribNum, bool enabled)
 {
     mState.vertexAttribute[attribNum].mArrayEnabled = enabled;
@@ -774,6 +790,16 @@
     return handle;
 }
 
+// Returns an unused query name
+GLuint Context::createQuery()
+{
+    GLuint handle = mQueryHandleAllocator.allocate();
+
+    mQueryMap[handle] = NULL;
+
+    return handle;
+}
+
 void Context::deleteBuffer(GLuint buffer)
 {
     if(mResourceManager->getBuffer(buffer))
@@ -840,6 +866,23 @@
     }
 }
 
+void Context::deleteQuery(GLuint query)
+{
+    QueryMap::iterator queryObject = mQueryMap.find(query);
+    
+	if(queryObject != mQueryMap.end())
+    {
+        mQueryHandleAllocator.release(queryObject->first);
+        
+		if(queryObject->second)
+        {
+            queryObject->second->release();
+        }
+        
+		mQueryMap.erase(queryObject);
+    }
+}
+
 Buffer *Context::getBuffer(GLuint handle)
 {
     return mResourceManager->getBuffer(handle);
@@ -952,6 +995,93 @@
     }
 }
 
+void Context::beginQuery(GLenum target, GLuint query)
+{
+    // From EXT_occlusion_query_boolean: If BeginQueryEXT is called with an <id>  
+    // of zero, if the active query object name for <target> is non-zero (for the  
+    // targets ANY_SAMPLES_PASSED_EXT and ANY_SAMPLES_PASSED_CONSERVATIVE_EXT, if  
+    // the active query for either target is non-zero), if <id> is the name of an 
+    // existing query object whose type does not match <target>, or if <id> is the
+    // active query object name for any query type, the error INVALID_OPERATION is
+    // generated.
+
+    // Ensure no other queries are active
+    // NOTE: If other queries than occlusion are supported, we will need to check
+    // separately that:
+    //    a) The query ID passed is not the current active query for any target/type
+    //    b) There are no active queries for the requested target (and in the case
+    //       of GL_ANY_SAMPLES_PASSED_EXT and GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
+    //       no query may be active for either if glBeginQuery targets either.
+    for(int i = 0; i < QUERY_TYPE_COUNT; i++)
+    {
+        if(mState.activeQuery[i].get() != NULL)
+        {
+            return error(GL_INVALID_OPERATION);
+        }
+    }
+
+    QueryType qType;
+    switch(target)
+    {
+    case GL_ANY_SAMPLES_PASSED_EXT: 
+        qType = QUERY_ANY_SAMPLES_PASSED; 
+        break;
+    case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT: 
+        qType = QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE; 
+        break;
+    default: 
+        ASSERT(false);
+    }
+
+    Query *queryObject = getQuery(query, true, target);
+
+    // Check that name was obtained with glGenQueries
+    if(!queryObject)
+    {
+        return error(GL_INVALID_OPERATION);
+    }
+
+    // Check for type mismatch
+    if(queryObject->getType() != target)
+    {
+        return error(GL_INVALID_OPERATION);
+    }
+
+    // Set query as active for specified target
+    mState.activeQuery[qType].set(queryObject);
+
+    // Begin query
+    queryObject->begin();
+}
+
+void Context::endQuery(GLenum target)
+{
+    QueryType qType;
+
+    switch(target)
+    {
+    case GL_ANY_SAMPLES_PASSED_EXT: 
+        qType = QUERY_ANY_SAMPLES_PASSED; 
+        break;
+    case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT: 
+        qType = QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE; 
+        break;
+    default: 
+        ASSERT(false);
+    }
+
+    Query *queryObject = mState.activeQuery[qType].get();
+
+    if(queryObject == NULL)
+    {
+        return error(GL_INVALID_OPERATION);
+    }
+
+    queryObject->end();
+
+    mState.activeQuery[qType].set(NULL);
+}
+
 void Context::setFramebufferZero(Framebuffer *buffer)
 {
     delete mFramebufferMap[0];
@@ -992,6 +1122,26 @@
     }
 }
 
+Query *Context::getQuery(unsigned int handle, bool create, GLenum type)
+{
+    QueryMap::iterator query = mQueryMap.find(handle);
+
+    if(query == mQueryMap.end())
+    {
+        return NULL;
+    }
+    else
+    {
+        if(!query->second && create)
+        {
+            query->second = new Query(handle, type);
+            query->second->addRef();
+        }
+
+        return query->second;
+    }
+}
+
 Buffer *Context::getArrayBuffer()
 {
     return mState.arrayBuffer.get();
@@ -1167,9 +1317,11 @@
         {
             if(S3TC_SUPPORT)
             {
-                // at current, only GL_COMPRESSED_RGB_S3TC_DXT1_EXT and 
-                // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT are supported
-                *params = 2;
+                // GL_COMPRESSED_RGB_S3TC_DXT1_EXT
+                // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
+				// GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE
+				// GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE
+                *params = 4;
             }
             else
             {
@@ -1222,6 +1374,8 @@
             {
                 params[0] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
                 params[1] = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+				params[2] = GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE;
+                params[3] = GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE;
             }
         }
         break;
@@ -1333,7 +1487,12 @@
     // application.
     switch (pname)
     {
-      case GL_COMPRESSED_TEXTURE_FORMATS: /* no compressed texture formats are supported */ 
+      case GL_COMPRESSED_TEXTURE_FORMATS:
+		{
+            *type = GL_INT;
+            *numParams = S3TC_SUPPORT ? 4 : 0;
+        }
+		break;
       case GL_SHADER_BINARY_FORMATS:
         {
             *type = GL_INT;
@@ -1479,7 +1638,7 @@
 }
 
 // Applies the render target surface, depth stencil surface, viewport rectangle and scissor rectangle
-bool Context::applyRenderTarget(bool ignoreViewport)
+bool Context::applyRenderTarget()
 {
     Device *device = getDevice();
 
@@ -1494,16 +1653,14 @@
 
     if(!renderTarget)
     {
-        return false;   // Context must be lost
+        return false;
     }
 
+	device->setRenderTarget(renderTarget);
+	renderTarget->release();
+
     Image *depthStencil = NULL;
 
-    device->setRenderTarget(renderTarget);
-    mScissorStateDirty = true;   // Scissor area must be clamped to render target's size - this is different for different render targets.
-    
-    unsigned int depthbufferSerial = 0;
-    unsigned int stencilbufferSerial = 0;
     if(framebufferObject->getDepthbufferType() != GL_NONE)
     {
         depthStencil = framebufferObject->getDepthbuffer()->getDepthStencil();
@@ -1512,8 +1669,6 @@
             ERR("Depth stencil pointer unexpectedly null.");
             return false;
         }
-        
-        depthbufferSerial = framebufferObject->getDepthbuffer()->getSerial();
     }
     else if(framebufferObject->getStencilbufferType() != GL_NONE)
     {
@@ -1523,93 +1678,44 @@
             ERR("Depth stencil pointer unexpectedly null.");
             return false;
         }
-        
-        stencilbufferSerial = framebufferObject->getStencilbuffer()->getSerial();
     }
 
-    if(depthbufferSerial != mAppliedDepthbufferSerial ||
-       stencilbufferSerial != mAppliedStencilbufferSerial ||
-       !mDepthStencilInitialized)
-    {
-        device->setDepthStencilSurface(depthStencil);
-        mAppliedDepthbufferSerial = depthbufferSerial;
-        mAppliedStencilbufferSerial = stencilbufferSerial;
-        mDepthStencilInitialized = true;
-    }
+    device->setDepthStencilSurface(depthStencil);
 
     Viewport viewport;
-
     float zNear = clamp01(mState.zNear);
     float zFar = clamp01(mState.zFar);
 
-    if(ignoreViewport)
-    {
-        viewport.x = 0;
-        viewport.y = 0;
-        viewport.width = renderTarget->getWidth();
-        viewport.height = renderTarget->getHeight();
-        viewport.minZ = 0.0f;
-        viewport.maxZ = 1.0f;
-    }
-    else
-    {
-        sw::Rect rect = transformPixelRect(mState.viewportX, mState.viewportY, mState.viewportWidth, mState.viewportHeight, renderTarget->getHeight());
-        viewport.x = clamp(rect.left, 0L, static_cast<LONG>(renderTarget->getWidth()));
-        viewport.y = clamp(rect.top, 0L, static_cast<LONG>(renderTarget->getHeight()));
-        viewport.width = clamp(rect.right - rect.left, 0L, static_cast<LONG>(renderTarget->getWidth()) - static_cast<LONG>(viewport.x));
-        viewport.height = clamp(rect.bottom - rect.top, 0L, static_cast<LONG>(renderTarget->getHeight()) - static_cast<LONG>(viewport.y));
-        viewport.minZ = zNear;
-        viewport.maxZ = zFar;
-    }
-
-    if(viewport.width <= 0 || viewport.height <= 0)
-    {
-        return false;   // Nothing to render
-    }
+    viewport.x0 = mState.viewportX;
+    viewport.y0 = mState.viewportY;
+    viewport.width = mState.viewportWidth;
+    viewport.height = mState.viewportHeight;
+    viewport.minZ = zNear;
+    viewport.maxZ = zFar;
 
     device->setViewport(viewport);
 
-    if(mScissorStateDirty)
+    if(mState.scissorTest)
     {
-        if(mState.scissorTest)
-        {
-            sw::Rect rect = transformPixelRect(mState.scissorX, mState.scissorY, mState.scissorWidth, mState.scissorHeight, renderTarget->getHeight());
-            rect.left = clamp(rect.left, 0L, static_cast<LONG>(renderTarget->getWidth()));
-            rect.top = clamp(rect.top, 0L, static_cast<LONG>(renderTarget->getHeight()));
-            rect.right = clamp(rect.right, 0L, static_cast<LONG>(renderTarget->getWidth()));
-            rect.bottom = clamp(rect.bottom, 0L, static_cast<LONG>(renderTarget->getHeight()));
-            device->setScissorRect(rect);
-            device->setScissorEnable(true);
-        }
-        else
-        {
-            device->setScissorEnable(false);
-        }
-
-        mScissorStateDirty = false;
+		sw::Rect scissor = {mState.scissorX, mState.scissorY, mState.scissorX + mState.scissorWidth, mState.scissorY + mState.scissorHeight};
+		scissor.clip(0, 0, renderTarget->getWidth(), renderTarget->getHeight());
+        
+		device->setScissorRect(scissor);
+        device->setScissorEnable(true);
+    }
+    else
+    {
+        device->setScissorEnable(false);
     }
 
-    if(mState.currentProgram)
-    {
-        Program *programObject = getCurrentProgram();
+	Program *program = getCurrentProgram();
 
-        GLint halfPixelSize = programObject->getDxHalfPixelSizeLocation();
-        GLfloat xy[2] = {1.0f / viewport.width, -1.0f / viewport.height};
-        programObject->setUniform2fv(halfPixelSize, 1, xy);
-
-        GLint viewport = programObject->getDxViewportLocation();
-        GLfloat whxy[4] = {mState.viewportWidth / 2.0f, mState.viewportHeight / 2.0f, 
-                           (float)mState.viewportX + mState.viewportWidth / 2.0f, 
-                           (float)mState.viewportY + mState.viewportHeight / 2.0f};
-        programObject->setUniform4fv(viewport, 1, whxy);
-
-        GLint depth = programObject->getDxDepthLocation();
-        GLfloat dz[2] = {(zFar - zNear) / 2.0f, (zNear + zFar) / 2.0f};
-        programObject->setUniform2fv(depth, 1, dz);
-
-        GLint depthRange = programObject->getDxDepthRangeLocation();
-        GLfloat nearFarDiff[3] = {zNear, zFar, zFar - zNear};
-        programObject->setUniform3fv(depthRange, 1, nearFarDiff);
+	if(program)
+	{
+		GLfloat nearFarDiff[3] = {zNear, zFar, zFar - zNear};
+        program->setUniform1fv(program->getUniformLocation("gl_DepthRange.near"), 1, &nearFarDiff[0]);
+		program->setUniform1fv(program->getUniformLocation("gl_DepthRange.far"), 1, &nearFarDiff[1]);
+		program->setUniform1fv(program->getUniformLocation("gl_DepthRange.diff"), 1, &nearFarDiff[2]);
     }
 
     return true;
@@ -1623,28 +1729,13 @@
 
     Framebuffer *framebufferObject = getDrawFramebuffer();
 
-    GLenum adjustedFrontFace = adjustWinding(mState.frontFace);
-
-    GLint frontCCW = programObject->getDxFrontCCWLocation();
-    GLint ccw = (adjustedFrontFace == GL_CCW);
-    programObject->setUniform1iv(frontCCW, 1, &ccw);
-
-    GLint pointsOrLines = programObject->getDxPointsOrLinesLocation();
-    GLint alwaysFront = !isTriangleMode(drawMode);
-    programObject->setUniform1iv(pointsOrLines, 1, &alwaysFront);
-
-    if(mCullStateDirty || mFrontFaceDirty)
+    if(mState.cullFace)
     {
-        if(mState.cullFace)
-        {
-            device->setCullMode(es2sw::ConvertCullMode(mState.cullMode, adjustedFrontFace));
-        }
-        else
-        {
-			device->setCullMode(sw::Context::CULL_NONE);
-        }
-
-        mCullStateDirty = false;
+        device->setCullMode(es2sw::ConvertCullMode(mState.cullMode, mState.frontFace));
+    }
+    else
+    {
+		device->setCullMode(sw::Context::CULL_NONE);
     }
 
     if(mDepthStateDirty)
@@ -1706,7 +1797,7 @@
             DepthStencilbuffer *stencilbuffer = framebufferObject->getStencilbuffer();
             GLuint maxStencil = (1 << stencilbuffer->getStencilSize()) - 1;
 
-			if(adjustedFrontFace == GL_CCW)
+			if(mState.frontFace == GL_CCW)
 			{
 				device->setStencilWriteMask(mState.stencilWritemask);
 				device->setStencilCompare(es2sw::ConvertStencilComparison(mState.stencilFunc));
@@ -1854,8 +1945,8 @@
 	device->resetInputStreams(false);
 
     for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
-	{			
-		if(!attributes[i].active)
+	{
+		if(program->getAttributeStream(i) == -1)
 		{
 			continue;
 		}
@@ -1873,16 +1964,8 @@
 		attribute.count = attributes[i].count;
 		attribute.normalized = attributes[i].normalized;
 
-		for(int stream = 0; stream < 16; stream++)
-		{
-			if(program->getVertexShader()->input[stream].usage == sw::ShaderOperation::USAGE_TEXCOORD &&
-			   program->getVertexShader()->input[stream].index == program->getSemanticIndex(i))
-			{
-				device->setInputStream(stream, attribute);
-
-				break;
-			}
-		}
+		int stream = program->getAttributeStream(i);
+		device->setInputStream(stream, attribute);
 	}
 
 	return GL_NO_ERROR;
@@ -1908,7 +1991,7 @@
     Device *device = getDevice();
     Program *programObject = getCurrentProgram();
     sw::VertexShader *vertexShader = programObject->getVertexShader();
-    sw::PixelShader *pixelShader = programObject->getPixelShader();
+	sw::PixelShader *pixelShader = programObject->getPixelShader();
 
     device->setVertexShader(vertexShader);
     device->setPixelShader(pixelShader);
@@ -1922,16 +2005,12 @@
     programObject->applyUniforms();
 }
 
-// Applies the textures and sampler states
 void Context::applyTextures()
 {
     applyTextures(sw::SAMPLER_PIXEL);
 	applyTextures(sw::SAMPLER_VERTEX);
 }
 
-// For each Direct3D 9 sampler of either the pixel or vertex stage,
-// looks up the corresponding OpenGL texture image unit and texture type,
-// and sets the texture and its addressing/filtering state (or NULL when inactive).
 void Context::applyTextures(sw::SamplerType samplerType)
 {
     Device *device = getDevice();
@@ -1949,7 +2028,7 @@
 
             Texture *texture = getSamplerTexture(textureUnit, textureType);
 
-			if(texture->isComplete())
+			if(texture->isSamplerComplete())
             {
                 GLenum wrapS = texture->getWrapS();
                 GLenum wrapT = texture->getWrapT();
@@ -1995,7 +2074,7 @@
 	}
 	else if(type == sw::SAMPLER_VERTEX)
 	{
-		textureUsed = program->getPixelShader()->usesSampler(index);
+		textureUsed = program->getVertexShader()->usesSampler(index);
 	}
 	else
 	{
@@ -2068,7 +2147,8 @@
 	}
 }
 
-void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
+void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height,
+                         GLenum format, GLenum type, GLsizei *bufSize, void* pixels)
 {
     Framebuffer *framebuffer = getReadFramebuffer();
 
@@ -2082,75 +2162,45 @@
         return error(GL_INVALID_OPERATION);
     }
 
+	GLsizei outputPitch = ComputePitch(width, format, type, mState.packAlignment);
+    
+	// Sized query sanity check
+    if(bufSize)
+    {
+        int requiredSize = outputPitch * height;
+        if(requiredSize > *bufSize)
+        {
+            return error(GL_INVALID_OPERATION);
+        }
+    }
+
     Image *renderTarget = framebuffer->getRenderTarget();
 
     if(!renderTarget)
     {
-        return;   // Context must be lost, return silently
-    }
-
-    Device *device = getDevice();
-	
-    Image *systemSurface = device->createOffscreenPlainSurface(renderTarget->getWidth(), renderTarget->getHeight(), renderTarget->getInternalFormat());
-
-    if(!systemSurface)
-    {
         return error(GL_OUT_OF_MEMORY);
     }
 
-    if(renderTarget->getMultiSampleDepth() > 1)
-    {
-        UNIMPLEMENTED();   // FIXME: Requires resolve using StretchRect into non-multisampled render target
-    }
+	sw::Rect rect = {x, y, x + width, y + height};
+	rect.clip(0, 0, renderTarget->getWidth(), renderTarget->getHeight());
 
-    bool success = device->getRenderTargetData(renderTarget, systemSurface);
-
-    if(!success)
-    {
-		UNREACHABLE();
-        systemSurface->release();
-
-        return;   // No sensible error to generate
-    }
-
-    sw::Rect rect = transformPixelRect(x, y, width, height, renderTarget->getHeight());
-    rect.left = clamp(rect.left, 0L, static_cast<LONG>(renderTarget->getWidth()));
-    rect.top = clamp(rect.top, 0L, static_cast<LONG>(renderTarget->getHeight()));
-    rect.right = clamp(rect.right, 0L, static_cast<LONG>(renderTarget->getWidth()));
-    rect.bottom = clamp(rect.bottom, 0L, static_cast<LONG>(renderTarget->getHeight()));
-
-    void *buffer = systemSurface->lock(rect.left, rect.top, sw::LOCK_READONLY);
-
-    if(!buffer)
-    {
-        UNREACHABLE();
-        systemSurface->release();
-
-        return;   // No sensible error to generate
-    }
-
-    unsigned char *source = ((unsigned char*)buffer) + systemSurface->getPitch() * (rect.bottom - rect.top - 1);
+    unsigned char *source = (unsigned char*)renderTarget->lock(rect.x0, rect.y0, sw::LOCK_READONLY);
     unsigned char *dest = (unsigned char*)pixels;
     unsigned short *dest16 = (unsigned short*)pixels;
-    int inputPitch = -(int)systemSurface->getPitch();
-    GLsizei outputPitch = ComputePitch(width, format, type, mState.packAlignment);
+    int inputPitch = (int)renderTarget->getPitch();
 
-    for(int j = 0; j < rect.bottom - rect.top; j++)
+    for(int j = 0; j < rect.y1 - rect.y0; j++)
     {
         if(renderTarget->getInternalFormat() == sw::FORMAT_A8R8G8B8 &&
-           format == GL_BGRA_EXT &&
-           type == GL_UNSIGNED_BYTE)
+           format == GL_BGRA_EXT && type == GL_UNSIGNED_BYTE)
         {
-            // Fast path for EXT_read_format_bgra, given
-            // an RGBA source buffer.  Note that buffers with no
-            // alpha go through the slow path below.
-            memcpy(dest + j * outputPitch,
-                   source + j * inputPitch,
-                   (rect.right - rect.left) * 4);
+            // Fast path for EXT_read_format_bgra, given an RGBA source buffer
+			// Note that buffers with no alpha go through the slow path below
+            memcpy(dest + j * outputPitch, source + j * inputPitch, (rect.x1 - rect.x0) * 4);
         }
 		else
 		{
-			for(int i = 0; i < rect.right - rect.left; i++)
+			for(int i = 0; i < rect.x1 - rect.x0; i++)
 			{
 				float r;
 				float g;
@@ -2230,10 +2280,10 @@
 					UNREACHABLE();
 				}
 
-				switch (format)
+				switch(format)
 				{
 				case GL_RGBA:
-					switch (type)
+					switch(type)
 					{
 					case GL_UNSIGNED_BYTE:
 						dest[4 * i + j * outputPitch + 0] = (unsigned char)(255 * r + 0.5f);
@@ -2245,7 +2295,7 @@
 					}
 					break;
 				case GL_BGRA_EXT:
-					switch (type)
+					switch(type)
 					{
 					case GL_UNSIGNED_BYTE:
 						dest[4 * i + j * outputPitch + 0] = (unsigned char)(255 * b + 0.5f);
@@ -2285,7 +2335,7 @@
 					}
 					break;
 				case GL_RGB:   // IMPLEMENTATION_COLOR_READ_FORMAT
-					switch (type)
+					switch(type)
 					{
 					case GL_UNSIGNED_SHORT_5_6_5:   // IMPLEMENTATION_COLOR_READ_TYPE
 						dest16[i + j * outputPitch / sizeof(unsigned short)] = 
@@ -2302,9 +2352,8 @@
         }
     }
 
-    systemSurface->unlock();
-
-    systemSurface->release();
+	renderTarget->unlock();
+	renderTarget->release();
 }
 
 void Context::clear(GLbitfield mask)
@@ -2316,14 +2365,13 @@
         return error(GL_INVALID_FRAMEBUFFER_OPERATION);
     }
 
-    egl::Display *display = getDisplay();
-    Device *device = getDevice();
-
-    if(!applyRenderTarget(true))   // Clips the clear to the scissor rectangle but not the viewport
+    if(!applyRenderTarget())
     {
         return;
     }
 
+	Device *device = getDevice();
+
 	unsigned int color = (unorm<8>(mState.colorClearValue.alpha) << 24) |
                          (unorm<8>(mState.colorClearValue.red) << 16) |
                          (unorm<8>(mState.colorClearValue.green) << 8) | 
@@ -2361,7 +2409,6 @@
         return error(GL_INVALID_OPERATION);
     }
 
-    egl::Display *display = getDisplay();
     Device *device = getDevice();
     PrimitiveType primitiveType;
     int primitiveCount;
@@ -2374,7 +2421,7 @@
         return;
     }
 
-    if(!applyRenderTarget(false))
+    if(!applyRenderTarget())
     {
         return;
     }
@@ -2413,7 +2460,6 @@
         return error(GL_INVALID_OPERATION);
     }
 
-    egl::Display *display = getDisplay();
     Device *device = getDevice();
     PrimitiveType primitiveType;
     int primitiveCount;
@@ -2426,7 +2472,7 @@
         return;
     }
 
-    if(!applyRenderTarget(false))
+    if(!applyRenderTarget())
     {
         return;
     }
@@ -2701,32 +2747,40 @@
 
 void Context::initExtensionString()
 {
-    mExtensionString += "GL_OES_packed_depth_stencil ";
-    mExtensionString += "GL_EXT_texture_format_BGRA8888 ";
-    mExtensionString += "GL_EXT_read_format_bgra ";
-    mExtensionString += "GL_ANGLE_framebuffer_blit ";
-    mExtensionString += "GL_OES_rgb8_rgba8 ";
-    mExtensionString += "GL_OES_standard_derivatives ";
-    mExtensionString += "GL_NV_fence ";
+	// Keep list sorted in following order:
+	// OES extensions
+	// EXT extensions
+	// Vendor extensions
 
-    if(S3TC_SUPPORT)
-    {
-        mExtensionString += "GL_EXT_texture_compression_dxt1 ";
-    }
+	mExtensionString += "GL_OES_element_index_uint ";
+	mExtensionString += "GL_OES_packed_depth_stencil ";
+	mExtensionString += "GL_OES_rgb8_rgba8 ";
+	mExtensionString += "GL_OES_standard_derivatives ";
+	mExtensionString += "GL_OES_texture_float ";
+	mExtensionString += "GL_OES_texture_float_linear ";
+	mExtensionString += "GL_OES_texture_half_float ";
+	mExtensionString += "GL_OES_texture_half_float_linear ";
+	mExtensionString += "GL_OES_texture_npot ";
+	mExtensionString += "GL_EXT_occlusion_query_boolean ";
+	mExtensionString += "GL_EXT_read_format_bgra ";
+	
+	if(S3TC_SUPPORT)
+	{
+		mExtensionString += "GL_EXT_texture_compression_dxt1 ";
+		mExtensionString += "GL_ANGLE_texture_compression_dxt3 ";
+		mExtensionString += "GL_ANGLE_texture_compression_dxt5 ";
+	}
 
-    mExtensionString += "GL_OES_texture_float ";
-    mExtensionString += "GL_OES_texture_half_float ";
-    mExtensionString += "GL_OES_texture_float_linear ";
-    mExtensionString += "GL_OES_texture_half_float_linear ";
-    mExtensionString += "GL_ANGLE_framebuffer_multisample ";
-    mExtensionString += "GL_OES_element_index_uint ";
-    mExtensionString += "GL_OES_texture_npot ";
+	mExtensionString += "GL_EXT_texture_format_BGRA8888 ";
+	mExtensionString += "GL_ANGLE_framebuffer_blit ";
+	mExtensionString += "GL_ANGLE_framebuffer_multisample ";
+	mExtensionString += "GL_NV_fence ";
 
-    std::string::size_type end = mExtensionString.find_last_not_of(' ');
-    if(end != std::string::npos)
-    {
-        mExtensionString.resize(end+1);
-    }
+	std::string::size_type end = mExtensionString.find_last_not_of(' ');
+	if(end != std::string::npos)
+	{
+		mExtensionString.resize(end + 1);
+	}
 }
 
 const char *Context::getExtensionString() const
@@ -2744,7 +2798,7 @@
     Framebuffer *drawFramebuffer = getDrawFramebuffer();
 
     if(!readFramebuffer || readFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE ||
-        !drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
+       !drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
     {
         return error(GL_INVALID_FRAMEBUFFER_OPERATION);
     }
@@ -2764,68 +2818,65 @@
 
     if(srcX0 < srcX1)
     {
-        sourceRect.left = srcX0;
-        sourceRect.right = srcX1;
-        destRect.left = dstX0;
-        destRect.right = dstX1;
+        sourceRect.x0 = srcX0;
+        sourceRect.x1 = srcX1;
+        destRect.x0 = dstX0;
+        destRect.x1 = dstX1;
     }
     else
     {
-        sourceRect.left = srcX1;
-        destRect.left = dstX1;
-        sourceRect.right = srcX0;
-        destRect.right = dstX0;
+        sourceRect.x0 = srcX1;
+        destRect.x0 = dstX1;
+        sourceRect.x1 = srcX0;
+        destRect.x1 = dstX0;
     }
 
     if(srcY0 < srcY1)
     {
-        sourceRect.top = readBufferHeight - srcY1;
-        destRect.top = drawBufferHeight - dstY1;
-        sourceRect.bottom = readBufferHeight - srcY0;
-        destRect.bottom = drawBufferHeight - dstY0;
+        sourceRect.y0 = srcY0;
+        destRect.y0 = dstY0;
+        sourceRect.y1 = srcY1;
+        destRect.y1 = dstY1;
     }
     else
     {
-        sourceRect.top = readBufferHeight - srcY0;
-        destRect.top = drawBufferHeight - dstY0;
-        sourceRect.bottom = readBufferHeight - srcY1;
-        destRect.bottom = drawBufferHeight - dstY1;
+        sourceRect.y0 = srcY1;
+        destRect.y0 = dstY1;
+        sourceRect.y1 = srcY0;
+        destRect.y1 = dstY0;
     }
 
     sw::Rect sourceScissoredRect = sourceRect;
     sw::Rect destScissoredRect = destRect;
 
-    if(mState.scissorTest)
+    if(mState.scissorTest)   // Only write to parts of the destination framebuffer which pass the scissor test
     {
-        // Only write to parts of the destination framebuffer which pass the scissor test
-        // Please note: the destRect is now in Y-down coordinates, so the *top* of the
-        // rect will be checked against scissorY, rather than the bottom.
-        if(destRect.left < mState.scissorX)
+        if(destRect.x0 < mState.scissorX)
         {
-            int xDiff = mState.scissorX - destRect.left;
-            destScissoredRect.left = mState.scissorX;
-            sourceScissoredRect.left += xDiff;
+            int xDiff = mState.scissorX - destRect.x0;
+            destScissoredRect.x0 = mState.scissorX;
+            sourceScissoredRect.x0 += xDiff;
         }
 
-        if(destRect.right > mState.scissorX + mState.scissorWidth)
+        if(destRect.x1 > mState.scissorX + mState.scissorWidth)
         {
-            int xDiff = destRect.right - (mState.scissorX + mState.scissorWidth);
-            destScissoredRect.right = mState.scissorX + mState.scissorWidth;
-            sourceScissoredRect.right -= xDiff;
+            int xDiff = destRect.x1 - (mState.scissorX + mState.scissorWidth);
+            destScissoredRect.x1 = mState.scissorX + mState.scissorWidth;
+            sourceScissoredRect.x1 -= xDiff;
         }
 
-        if(destRect.top < mState.scissorY)
+        if(destRect.y0 < mState.scissorY)
         {
-            int yDiff = mState.scissorY - destRect.top;
-            destScissoredRect.top = mState.scissorY;
-            sourceScissoredRect.top += yDiff;
+            int yDiff = mState.scissorY - destRect.y0;
+            destScissoredRect.y0 = mState.scissorY;
+            sourceScissoredRect.y0 += yDiff;
         }
 
-        if(destRect.bottom > mState.scissorY + mState.scissorHeight)
+        if(destRect.y1 > mState.scissorY + mState.scissorHeight)
         {
-            int yDiff = destRect.bottom - (mState.scissorY + mState.scissorHeight);
-            destScissoredRect.bottom = mState.scissorY + mState.scissorHeight;
-            sourceScissoredRect.bottom -= yDiff;
+            int yDiff = destRect.y1 - (mState.scissorY + mState.scissorHeight);
+            destScissoredRect.y1 = mState.scissorY + mState.scissorHeight;
+            sourceScissoredRect.y1 -= yDiff;
         }
     }
 
@@ -2837,68 +2888,68 @@
 
     // The source & destination rectangles also may need to be trimmed if they fall out of the bounds of 
     // the actual draw and read surfaces.
-    if(sourceTrimmedRect.left < 0)
+    if(sourceTrimmedRect.x0 < 0)
     {
-        int xDiff = 0 - sourceTrimmedRect.left;
-        sourceTrimmedRect.left = 0;
-        destTrimmedRect.left += xDiff;
+        int xDiff = 0 - sourceTrimmedRect.x0;
+        sourceTrimmedRect.x0 = 0;
+        destTrimmedRect.x0 += xDiff;
     }
 
-    if(sourceTrimmedRect.right > readBufferWidth)
+    if(sourceTrimmedRect.x1 > readBufferWidth)
     {
-        int xDiff = sourceTrimmedRect.right - readBufferWidth;
-        sourceTrimmedRect.right = readBufferWidth;
-        destTrimmedRect.right -= xDiff;
+        int xDiff = sourceTrimmedRect.x1 - readBufferWidth;
+        sourceTrimmedRect.x1 = readBufferWidth;
+        destTrimmedRect.x1 -= xDiff;
     }
 
-    if(sourceTrimmedRect.top < 0)
+    if(sourceTrimmedRect.y0 < 0)
     {
-        int yDiff = 0 - sourceTrimmedRect.top;
-        sourceTrimmedRect.top = 0;
-        destTrimmedRect.top += yDiff;
+        int yDiff = 0 - sourceTrimmedRect.y0;
+        sourceTrimmedRect.y0 = 0;
+        destTrimmedRect.y0 += yDiff;
     }
 
-    if(sourceTrimmedRect.bottom > readBufferHeight)
+    if(sourceTrimmedRect.y1 > readBufferHeight)
     {
-        int yDiff = sourceTrimmedRect.bottom - readBufferHeight;
-        sourceTrimmedRect.bottom = readBufferHeight;
-        destTrimmedRect.bottom -= yDiff;
+        int yDiff = sourceTrimmedRect.y1 - readBufferHeight;
+        sourceTrimmedRect.y1 = readBufferHeight;
+        destTrimmedRect.y1 -= yDiff;
     }
 
-    if(destTrimmedRect.left < 0)
+    if(destTrimmedRect.x0 < 0)
     {
-        int xDiff = 0 - destTrimmedRect.left;
-        destTrimmedRect.left = 0;
-        sourceTrimmedRect.left += xDiff;
+        int xDiff = 0 - destTrimmedRect.x0;
+        destTrimmedRect.x0 = 0;
+        sourceTrimmedRect.x0 += xDiff;
     }
 
-    if(destTrimmedRect.right > drawBufferWidth)
+    if(destTrimmedRect.x1 > drawBufferWidth)
     {
-        int xDiff = destTrimmedRect.right - drawBufferWidth;
-        destTrimmedRect.right = drawBufferWidth;
-        sourceTrimmedRect.right -= xDiff;
+        int xDiff = destTrimmedRect.x1 - drawBufferWidth;
+        destTrimmedRect.x1 = drawBufferWidth;
+        sourceTrimmedRect.x1 -= xDiff;
     }
 
-    if(destTrimmedRect.top < 0)
+    if(destTrimmedRect.y0 < 0)
     {
-        int yDiff = 0 - destTrimmedRect.top;
-        destTrimmedRect.top = 0;
-        sourceTrimmedRect.top += yDiff;
+        int yDiff = 0 - destTrimmedRect.y0;
+        destTrimmedRect.y0 = 0;
+        sourceTrimmedRect.y0 += yDiff;
     }
 
-    if(destTrimmedRect.bottom > drawBufferHeight)
+    if(destTrimmedRect.y1 > drawBufferHeight)
     {
-        int yDiff = destTrimmedRect.bottom - drawBufferHeight;
-        destTrimmedRect.bottom = drawBufferHeight;
-        sourceTrimmedRect.bottom -= yDiff;
+        int yDiff = destTrimmedRect.y1 - drawBufferHeight;
+        destTrimmedRect.y1 = drawBufferHeight;
+        sourceTrimmedRect.y1 -= yDiff;
     }
 
     bool partialBufferCopy = false;
-    if(sourceTrimmedRect.bottom - sourceTrimmedRect.top < readBufferHeight ||
-        sourceTrimmedRect.right - sourceTrimmedRect.left < readBufferWidth || 
-        destTrimmedRect.bottom - destTrimmedRect.top < drawBufferHeight ||
-        destTrimmedRect.right - destTrimmedRect.left < drawBufferWidth ||
-        sourceTrimmedRect.top != 0 || destTrimmedRect.top != 0 || sourceTrimmedRect.left != 0 || destTrimmedRect.left != 0)
+    if(sourceTrimmedRect.y1 - sourceTrimmedRect.y0 < readBufferHeight ||
+       sourceTrimmedRect.x1 - sourceTrimmedRect.x0 < readBufferWidth || 
+       destTrimmedRect.y1 - destTrimmedRect.y0 < drawBufferHeight ||
+       destTrimmedRect.x1 - destTrimmedRect.x0 < drawBufferWidth ||
+       sourceTrimmedRect.y0 != 0 || destTrimmedRect.y0 != 0 || sourceTrimmedRect.x0 != 0 || destTrimmedRect.x0 != 0)
     {
         partialBufferCopy = true;
     }
@@ -2922,7 +2973,6 @@
         }
 
         blitRenderTarget = true;
-
     }
 
     if(mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT))
@@ -2968,7 +3018,7 @@
         if(partialBufferCopy)
         {
             ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
-            return error(GL_INVALID_OPERATION); // only whole-buffer copies are permitted
+            return error(GL_INVALID_OPERATION);   // Only whole-buffer copies are permitted
         }
 
         if((drawDSBuffer && drawDSBuffer->getSamples() != 0) || 
@@ -2984,8 +3034,13 @@
 
         if(blitRenderTarget)
         {
-            bool success = device->stretchRect(readFramebuffer->getRenderTarget(), &sourceTrimmedRect, 
-                                               drawFramebuffer->getRenderTarget(), &destTrimmedRect, false);
+            Image *readRenderTarget = readFramebuffer->getRenderTarget();
+            Image *drawRenderTarget = drawFramebuffer->getRenderTarget();
+ 
+            bool success = device->stretchRect(readRenderTarget, &sourceRect, drawRenderTarget, &destRect, false);
+
+            readRenderTarget->release();
+            drawRenderTarget->release();
 
             if(!success)
             {
diff --git a/src/OpenGL ES 2.0/libGLESv2/Context.h b/src/OpenGL ES 2.0/libGLESv2/Context.h
index 4b533bd..0086ba7 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Context.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Context.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Context.h: Defines the Context class, managing all GL state and performing
@@ -13,8 +18,8 @@
 #include "ResourceManager.h"
 #include "HandleAllocator.h"
 #include "RefCountObject.h"
-#include "common/angleutils.h"
 #include "Image.hpp"
+#include "common/angleutils.h"
 #include "Renderer/Sampler.hpp"
 
 #define GL_APICALL
@@ -55,26 +60,36 @@
 class VertexDataManager;
 class IndexDataManager;
 class Fence;
+class Query;
 
 enum
 {
     MAX_VERTEX_ATTRIBS = 16,
-    MAX_VERTEX_UNIFORM_VECTORS = 256 - 2,   // 256 is the minimum for SM2, and in practice the maximum for DX9. Reserve space for dx_HalfPixelSize and dx_DepthRange.
+	MAX_UNIFORM_VECTORS = 256,   // Device limit
+    MAX_VERTEX_UNIFORM_VECTORS = 256 - 3,   // Reserve space for gl_DepthRange
     MAX_VARYING_VECTORS = 10,
     MAX_TEXTURE_IMAGE_UNITS = 16,
-    MAX_VERTEX_TEXTURE_IMAGE_UNITS = 4,   // For devices supporting vertex texture fetch
+    MAX_VERTEX_TEXTURE_IMAGE_UNITS = 4,
     MAX_COMBINED_TEXTURE_IMAGE_UNITS = MAX_TEXTURE_IMAGE_UNITS + MAX_VERTEX_TEXTURE_IMAGE_UNITS,
-    MAX_FRAGMENT_UNIFORM_VECTORS = 224 - 3,    // Reserve space for dx_Viewport, dx_Depth, and dx_DepthRange. dx_PointOrLines and dx_FrontCCW use separate bool registers.
+    MAX_FRAGMENT_UNIFORM_VECTORS = 224 - 3,    // Reserve space for gl_DepthRange
     MAX_DRAW_BUFFERS = 1,
 
     IMPLEMENTATION_COLOR_READ_FORMAT = GL_RGB,
     IMPLEMENTATION_COLOR_READ_TYPE = GL_UNSIGNED_SHORT_5_6_5
 };
 
+enum QueryType
+{
+    QUERY_ANY_SAMPLES_PASSED,
+    QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE,
+
+    QUERY_TYPE_COUNT
+};
+
 const float ALIASED_LINE_WIDTH_RANGE_MIN = 1.0f;
 const float ALIASED_LINE_WIDTH_RANGE_MAX = 1.0f;
-const float ALIASED_POINT_SIZE_RANGE_MIN = 1.0f;
-const float ALIASED_POINT_SIZE_RANGE_MAX = 64.0f;
+const float ALIASED_POINT_SIZE_RANGE_MIN = 0.125f;
+const float ALIASED_POINT_SIZE_RANGE_MAX = 8192.0f;
 
 struct Color
 {
@@ -213,6 +228,7 @@
 
     VertexAttribute vertexAttribute[MAX_VERTEX_ATTRIBS];
     BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][MAX_COMBINED_TEXTURE_IMAGE_UNITS];
+	BindingPointer<Query> activeQuery[QUERY_TYPE_COUNT];
 
     GLint unpackAlignment;
     GLint packAlignment;
@@ -292,6 +308,8 @@
     GLuint getDrawFramebufferHandle() const;
     GLuint getRenderbufferHandle() const;
 
+	GLuint getActiveQuery(GLenum target) const;
+
     GLuint getArrayBufferHandle() const;
 
     void setEnableVertexAttribArray(unsigned int attribNum, bool enabled);
@@ -326,10 +344,14 @@
     GLuint createFramebuffer();
     void deleteFramebuffer(GLuint framebuffer);
 
-    // Fences are owned by the Context.
+    // Fences are owned by the Context
     GLuint createFence();
     void deleteFence(GLuint fence);
 
+	// Queries are owned by the Context
+    GLuint createQuery();
+    void deleteQuery(GLuint query);
+
     void bindArrayBuffer(GLuint buffer);
     void bindElementArrayBuffer(GLuint buffer);
     void bindTexture2D(GLuint texture);
@@ -339,6 +361,9 @@
     void bindRenderbuffer(GLuint renderbuffer);
     void useProgram(GLuint program);
 
+	void beginQuery(GLenum target, GLuint query);
+    void endQuery(GLenum target);
+
     void setFramebufferZero(Framebuffer *framebuffer);
 
     void setRenderbufferStorage(RenderbufferStorage *renderbuffer);
@@ -352,6 +377,7 @@
     Texture *getTexture(GLuint handle);
     Framebuffer *getFramebuffer(GLuint handle);
     Renderbuffer *getRenderbuffer(GLuint handle);
+	Query *getQuery(GLuint handle, bool create, GLenum type);
 
     Buffer *getArrayBuffer();
     Buffer *getElementArrayBuffer();
@@ -368,7 +394,7 @@
 
     bool getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams);
 
-    void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
+    void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels);
     void clear(GLbitfield mask);
     void drawArrays(GLenum mode, GLint first, GLsizei count);
     void drawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
@@ -393,7 +419,7 @@
   private:
     DISALLOW_COPY_AND_ASSIGN(Context);
 
-    bool applyRenderTarget(bool ignoreViewport);
+    bool applyRenderTarget();
     void applyState(GLenum drawMode);
     GLenum applyVertexBuffer(GLint base, GLint first, GLsizei count);
     GLenum applyIndexBuffer(const void *indices, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo);
@@ -425,6 +451,10 @@
     FenceMap mFenceMap;
     HandleAllocator mFenceHandleAllocator;
 
+	typedef stdext::hash_map<GLuint, Query*> QueryMap;
+    QueryMap mQueryMap;
+    HandleAllocator mQueryHandleAllocator;
+
     void initExtensionString();
     std::string mExtensionString;
 
@@ -441,23 +471,16 @@
     bool mHasBeenCurrent;
 
     unsigned int mAppliedProgramSerial;
-    unsigned int mAppliedRenderTargetSerial;
-    unsigned int mAppliedDepthbufferSerial;
-    unsigned int mAppliedStencilbufferSerial;
-    bool mDepthStencilInitialized;
 
     std::map<sw::Format, bool*> mMultiSampleSupport;
     
     // state caching flags
-    bool mClearStateDirty;
-    bool mCullStateDirty;
     bool mDepthStateDirty;
     bool mMaskStateDirty;
     bool mPixelPackingStateDirty;
     bool mBlendStateDirty;
     bool mStencilStateDirty;
     bool mPolygonOffsetStateDirty;
-    bool mScissorStateDirty;
     bool mSampleStateDirty;
     bool mFrontFaceDirty;
     bool mDitherStateDirty;
diff --git a/src/OpenGL ES 2.0/libGLESv2/Device.cpp b/src/OpenGL ES 2.0/libGLESv2/Device.cpp
index 68e293f..359588f 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Device.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Device.cpp
@@ -1,6 +1,6 @@
 // SwiftShader Software Renderer
 //
-// Copyright(c) 2005-2011 TransGaming Inc.
+// Copyright(c) 2005-2012 TransGaming Inc.
 //
 // All rights reserved. No part of this software may be copied, distributed, transmitted,
 // transcribed, stored in a retrieval system, translated into any human or computer
@@ -25,13 +25,13 @@
 #include "Common/Timer.hpp"
 #include "../common/debug.h"
 
-bool localShaderConstants = true;
+bool localShaderConstants = false;
 
 namespace gl
 {
 	using namespace sw;
 
-	Device::Device(Context *context) : Renderer(context), context(context)
+	Device::Device(Context *context) : Renderer(context, true, true, true, true, true), context(context)
 	{
 		depthStencil = 0;
 		renderTarget = 0;
@@ -67,9 +67,9 @@
 		setVertexFogMode(Context::FOG_NONE);
 		setClipFlags(0);
 		setPointSize(1.0f);
-		setPointSizeMin(1.0f);
+		setPointSizeMin(0.125f);
 		setPointSpriteEnable(false);
-		setPointSizeMax(64.0f);
+        setPointSizeMax(8192.0f);
 		setColorWriteMask(0, 0x0000000F);
 		setBlendOperation(Context::BLENDOP_ADD);
 		scissorEnable = false;
@@ -163,75 +163,73 @@
 	{
 		TRACE("unsigned long color = 0x%0.8X", color);
 
-		int x = viewport.x;
-		int y = viewport.y;
-		int width = viewport.width;
-		int height = viewport.height;
+		int x0 = 0;
+		int y0 = 0;
+		int width = renderTarget->getExternalWidth();
+		int height = renderTarget->getExternalHeight();
 
-		// Clamp against scissor rectangle
-		if(scissorEnable)
+		if(scissorEnable)   // Clamp against scissor rectangle
 		{
-			if(x < scissorRect.left) x = scissorRect.left;
-			if(y < scissorRect.top) y = scissorRect.top;
-			if(width > scissorRect.right - scissorRect.left) width = scissorRect.right - scissorRect.left;
-			if(height > scissorRect.bottom - scissorRect.top) height = scissorRect.bottom - scissorRect.top;
+			if(x0 < scissorRect.x0) x0 = scissorRect.x0;
+			if(y0 < scissorRect.y0) y0 = scissorRect.y0;
+			if(width > scissorRect.x1 - scissorRect.x0) width = scissorRect.x1 - scissorRect.x0;
+			if(height > scissorRect.y1 - scissorRect.y0) height = scissorRect.y1 - scissorRect.y0;
 		}
 
-		if(renderTarget)
-		{
-			renderTarget->clearColorBuffer(color, rgbaMask, x, y, width, height);
-		}
+		renderTarget->clearColorBuffer(color, rgbaMask, x0, y0, width, height);
 	}
 
 	void Device::clearDepth(float z)
 	{
 		TRACE("float z = %f", z);
 
+		if(!depthStencil)
+		{
+			return;
+		}
+
 		if(z > 1) z = 1;
 		if(z < 0) z = 0;
 
-		int x = viewport.x;
-		int y = viewport.y;
-		int width = viewport.width;
-		int height = viewport.height;
+		int x0 = 0;
+		int y0 = 0;
+		int width = depthStencil->getExternalWidth();
+		int height = depthStencil->getExternalHeight();
 
-		// Clamp against scissor rectangle
-		if(scissorEnable)
+		if(scissorEnable)   // Clamp against scissor rectangle
 		{
-			if(x < scissorRect.left) x = scissorRect.left;
-			if(y < scissorRect.top) y = scissorRect.top;
-			if(width > scissorRect.right - scissorRect.left) width = scissorRect.right - scissorRect.left;
-			if(height > scissorRect.bottom - scissorRect.top) height = scissorRect.bottom - scissorRect.top;
+			if(x0 < scissorRect.x0) x0 = scissorRect.x0;
+			if(y0 < scissorRect.y0) y0 = scissorRect.y0;
+			if(width > scissorRect.x1 - scissorRect.x0) width = scissorRect.x1 - scissorRect.x0;
+			if(height > scissorRect.y1 - scissorRect.y0) height = scissorRect.y1 - scissorRect.y0;
 		}
-
-		if(depthStencil)
-		{
-			depthStencil->clearDepthBuffer(z, x, y, width, height);
-		}
+			
+		depthStencil->clearDepthBuffer(z, x0, y0, width, height);
 	}
 
 	void Device::clearStencil(unsigned int stencil, unsigned int mask)
 	{
 		TRACE("unsigned long stencil = %d", stencil);
 
-		int x = viewport.x;
-		int y = viewport.y;
-		int width = viewport.width;
-		int height = viewport.height;
-
-		// Clamp against scissor rectangle
-		if(scissorEnable)
+		if(!depthStencil)
 		{
-			if(x < scissorRect.left) x = scissorRect.left;
-			if(y < scissorRect.top) y = scissorRect.top;
-			if(width > scissorRect.right - scissorRect.left) width = scissorRect.right - scissorRect.left;
-			if(height > scissorRect.bottom - scissorRect.top) height = scissorRect.bottom - scissorRect.top;
+			return;
 		}
 
-		if(depthStencil)
+		int x0 = 0;
+		int y0 = 0;
+		int width = renderTarget->getExternalWidth();
+		int height = renderTarget->getExternalHeight();
+
+		if(scissorEnable)   // Clamp against scissor rectangle
 		{
-			depthStencil->clearStencilBuffer(stencil, mask, x, y, width, height);
+			if(x0 < scissorRect.x0) x0 = scissorRect.x0;
+			if(y0 < scissorRect.y0) y0 = scissorRect.y0;
+			if(width > scissorRect.x1 - scissorRect.x0) width = scissorRect.x1 - scissorRect.x0;
+			if(height > scissorRect.y1 - scissorRect.y0) height = scissorRect.y1 - scissorRect.y0;
 		}
+
+		depthStencil->clearStencilBuffer(stencil, mask, x0, y0, width, height);
 	}
 
 	Image *Device::createDepthStencilSurface(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)
@@ -420,57 +418,6 @@
 		return depthStencil;
 	}
 
-	bool Device::getRenderTargetData(Image *renderTarget, Image *destSurface)
-	{
-		TRACE("Image *renderTarget = 0x%0.8p, Image *destSurface = 0x%0.8p", renderTarget, destSurface);
-
-		if(!renderTarget || !destSurface)
-		{
-			ERR("Invalid parameters");
-			return false;
-		}
-		
-		if(renderTarget->getWidth()  != destSurface->getWidth() ||
-		   renderTarget->getHeight() != destSurface->getHeight() ||
-		   renderTarget->getInternalFormat() != destSurface->getInternalFormat())
-		{
-			ERR("Invalid parameters");
-			return false;
-		}
-
-		static void (__cdecl *blitFunction)(void *dst, void *src);
-		static Routine *blitRoutine;
-		static BlitState blitState = {0};
-
-		BlitState update;
-		update.width = renderTarget->getInternalWidth();
-		update.height = renderTarget->getInternalHeight();
-		update.depth = 32;
-		update.stride = destSurface->getInternalPitchB();
-		update.HDR = false;
-		update.cursorHeight = 0;
-		update.cursorWidth = 0;
-		
-		if(memcmp(&blitState, &update, sizeof(BlitState)) != 0)
-		{
-			blitState = update;
-			delete blitRoutine;
-
-			blitRoutine = FrameBuffer::copyRoutine(blitState);
-			blitFunction = (void(__cdecl*)(void*, void*))blitRoutine->getEntry();
-		}
-
-		void *dst = destSurface->lockInternal(0, 0, 0, LOCK_WRITEONLY, PUBLIC);
-		void *src = renderTarget->lockInternal(0, 0, 0, LOCK_WRITEONLY, PUBLIC);
-
-		blitFunction(dst, src);
-
-		destSurface->unlockInternal();
-		renderTarget->unlockInternal();
-
-		return true;
-	}
-
 	void Device::setDepthStencilSurface(Image *depthStencil)
 	{
 		TRACE("Image *newDepthStencil = 0x%0.8p", depthStencil);
@@ -542,23 +489,6 @@
 
 		this->renderTarget = renderTarget;
 
-		if(renderTarget)
-		{
-			// Reset viewport to size of current render target
-			viewport.x = 0;
-			viewport.y = 0;
-			viewport.width = renderTarget->getWidth();
-			viewport.height = renderTarget->getHeight();
-			viewport.minZ = 0;
-			viewport.maxZ = 1;
-
-			// Reset scissor rectangle to size of current render target
-			scissorRect.left = 0;
-			scissorRect.top = 0;
-			scissorRect.right = renderTarget->getWidth();
-			scissorRect.bottom = renderTarget->getHeight();
-		}
-
 		Renderer::setRenderTarget(0, renderTarget);
 	}
 
@@ -627,10 +557,10 @@
 		}
 		else
 		{
-			sRect.top = 0;
-			sRect.left = 0;
-			sRect.bottom = sHeight;
-			sRect.right = sWidth;
+			sRect.y0 = 0;
+			sRect.x0 = 0;
+			sRect.y1 = sHeight;
+			sRect.x1 = sWidth;
 		}
 
 		if(destRect)
@@ -639,13 +569,13 @@
 		}
 		else
 		{
-			dRect.top = 0;
-			dRect.left = 0;
-			dRect.bottom = dHeight;
-			dRect.right = dWidth;
+			dRect.y0 = 0;
+			dRect.x0 = 0;
+			dRect.y1 = dHeight;
+			dRect.x1 = dWidth;
 		}
 
-		bool scaling = (sRect.right - sRect.left != dRect.right - dRect.left) || (sRect.bottom - sRect.top != dRect.bottom - dRect.top);
+		bool scaling = (sRect.x1 - sRect.x0 != dRect.x1 - dRect.x0) || (sRect.y1 - sRect.y0 != dRect.y1 - dRect.y0);
 		bool equalFormats = source->getInternalFormat() == dest->getInternalFormat();
 		bool depthStencil = Image::isDepth(source->getInternalFormat()) || Image::isStencil(source->getInternalFormat());
 		bool alpha0xFF = false;
@@ -703,13 +633,13 @@
 		}
 		else if(!scaling && equalFormats)
 		{
-			unsigned char *sourceBytes = (unsigned char*)source->lockInternal(sRect.left, sRect.top, 0, LOCK_READONLY, PUBLIC);
-			unsigned char *destBytes = (unsigned char*)dest->lockInternal(dRect.left, dRect.top, 0, LOCK_READWRITE, PUBLIC);
+			unsigned char *sourceBytes = (unsigned char*)source->lockInternal(sRect.x0, sRect.y0, 0, LOCK_READONLY, PUBLIC);
+			unsigned char *destBytes = (unsigned char*)dest->lockInternal(dRect.x0, dRect.y0, 0, LOCK_READWRITE, PUBLIC);
 			unsigned int sourcePitch = source->getInternalPitchB();
 			unsigned int destPitch = dest->getInternalPitchB();
 
-			unsigned int width = dRect.right - dRect.left;
-			unsigned int height = dRect.bottom - dRect.top;
+			unsigned int width = dRect.x1 - dRect.x0;
+			unsigned int height = dRect.y1 - dRect.y0;
 			unsigned int bytes = width * Image::bytes(source->getInternalFormat());
 
 			for(unsigned int y = 0; y < height; y++)
@@ -754,32 +684,32 @@
 		
 		if(sourceRect)
 		{
-			sRect.left = sourceRect->left;
-			sRect.top = sourceRect->top;
-			sRect.right = sourceRect->right;
-			sRect.bottom = sourceRect->bottom;
+			sRect.x0 = sourceRect->x0;
+			sRect.y0 = sourceRect->y0;
+			sRect.x1 = sourceRect->x1;
+			sRect.y1 = sourceRect->y1;
 		}
 		else
 		{
-			sRect.left = 0;
-			sRect.top = 0;
-			sRect.right = sourceSurface->getWidth();
-			sRect.bottom = sourceSurface->getHeight();
+			sRect.x0 = 0;
+			sRect.y0 = 0;
+			sRect.x1 = sourceSurface->getWidth();
+			sRect.y1 = sourceSurface->getHeight();
 		}
 
 		if(destPoint)
 		{
-			dRect.left = destPoint->x;
-			dRect.top = destPoint->y;
-			dRect.right = destPoint->x + sRect.right - sRect.left;
-			dRect.bottom = destPoint->y + sRect.bottom - sRect.top;
+			dRect.x0 = destPoint->x;
+			dRect.y0 = destPoint->y;
+			dRect.x1 = destPoint->x + sRect.x1 - sRect.x0;
+			dRect.y1 = destPoint->y + sRect.y1 - sRect.y0;
 		}
 		else
 		{
-			dRect.left = 0;
-			dRect.top = 0;
-			dRect.right = sRect.right - sRect.left;
-			dRect.bottom = sRect.bottom - sRect.top;
+			dRect.x0 = 0;
+			dRect.y0 = 0;
+			dRect.x1 = sRect.x1 - sRect.x0;
+			dRect.y1 = sRect.y1 - sRect.y0;
 		}
 
 		if(!validRectangle(&sRect, sourceSurface) || !validRectangle(&dRect, destinationSurface))
@@ -788,11 +718,11 @@
 			return false;
 		}
 
-		int sWidth = sRect.right - sRect.left;
-		int sHeight = sRect.bottom - sRect.top;
+		int sWidth = sRect.x1 - sRect.x0;
+		int sHeight = sRect.y1 - sRect.y0;
 
-		int dWidth = dRect.right - dRect.left;
-		int dHeight = dRect.bottom - dRect.top;
+		int dWidth = dRect.x1 - dRect.x0;
+		int dHeight = dRect.y1 - dRect.y0;
 
 		if(sourceSurface->getMultiSampleDepth() > 1 ||
 		   destinationSurface->getMultiSampleDepth() > 1 ||
@@ -802,8 +732,8 @@
 			return false;
 		}
 		
-		unsigned char *sourceBuffer = (unsigned char*)sourceSurface->lock(sRect.left, sRect.top, LOCK_READONLY);
-		unsigned char *destinationBuffer = (unsigned char*)destinationSurface->lock(dRect.left, dRect.top, LOCK_WRITEONLY);
+		unsigned char *sourceBuffer = (unsigned char*)sourceSurface->lock(sRect.x0, sRect.y0, LOCK_READONLY);
+		unsigned char *destinationBuffer = (unsigned char*)destinationSurface->lock(dRect.x0, dRect.y0, LOCK_WRITEONLY);
 
 		unsigned int width;
 		unsigned int height;
@@ -924,70 +854,40 @@
 
 		if(scissorEnable)
 		{
-			Rect scissor = scissorRect;
-
-			long viewportLeft = viewport.x;
-			long viewportRight = viewport.x + viewport.width;
-			long viewportTop = viewport.y;
-			long viewportBottom = viewport.y + viewport.height;
-
-			// Intersection of scissor rectangle and viewport
-			if(viewportLeft > scissor.left) scissor.left = viewportLeft;
-			if(viewportTop > scissor.top) scissor.top = viewportTop;
-			if(viewportRight < scissor.right) scissor.right = viewportRight;
-			if(viewportBottom < scissor.bottom) scissor.bottom = viewportBottom;
-
-			if(scissor.left == scissor.right ||
-			   scissor.top == scissor.bottom)
+			if(scissorRect.x0 >= scissorRect.x1 || scissorRect.y0 >= scissorRect.y1)
 			{
 				return false;
 			}
 
-			// Dimensions of scissor rectangle relative to viewport
-			float relativeLeft = (float)(scissor.left - viewportLeft) / viewport.width;
-			float relativeRight = (float)(scissor.right - viewportLeft) / viewport.width;
-			float relativeTop = (float)(scissor.top - viewportTop) / viewport.height;
-			float relativeBottom = (float)(scissor.bottom - viewportTop) / viewport.height;
-
-			// Transformation of clip space coordinates
-			float sX = 1.0f / (relativeRight - relativeLeft);   // Scale
-			float tX = sX * ((0.5f - relativeLeft) - (relativeRight - 0.5f));   // Translate
-			float sY = 1.0f / (relativeBottom - relativeTop);   // Scale
-			float tY = sY * ((0.5f - relativeTop) - (relativeBottom - 0.5f));   // Translate
-
-			// Set the new viewport
-			sw::Viewport view;
-
-			view.setLeft((float)scissor.left);
-			view.setTop((float)scissor.top);
-			view.setWidth((float)(scissor.right - scissor.left));
-			view.setHeight((float)(scissor.bottom - scissor.top));
-
-			view.setNear(viewport.minZ);
-			view.setFar(viewport.maxZ);
-
-			Renderer::setViewport(view);
-			setPostTransformEnable(true);
-			setPosScale(sX, sY);
-			setPosOffset(tX, -tY);
+			sw::Rect scissor;
+			scissor.x0 = scissorRect.x0;
+			scissor.x1 = scissorRect.x1;
+			scissor.y0 = scissorRect.y0;
+			scissor.y1 = scissorRect.y1;
+			
+			setScissor(scissor);
 		}
 		else
 		{
-			// Set viewport
-			sw::Viewport view;
-
-			view.setLeft((float)viewport.x);
-			view.setTop((float)viewport.y);
-			view.setWidth((float)viewport.width);
-			view.setHeight((float)viewport.height);
-
-			view.setNear(viewport.minZ);
-			view.setFar(viewport.maxZ);
-
-			Renderer::setViewport(view);
-			setPostTransformEnable(false);
+			sw::Rect scissor;
+			scissor.x0 = max(viewport.x0, 0);
+			scissor.x1 = min(viewport.x0 + viewport.width, renderTarget->getExternalWidth());
+			scissor.y0 = max(viewport.y0, 0);
+			scissor.y1 = min(viewport.y0 + viewport.height, renderTarget->getExternalHeight());
+			
+			setScissor(scissor);
 		}
 
+		sw::Viewport view;
+		view.x0 = (float)viewport.x0;
+		view.y0 = (float)viewport.y0;
+		view.width = (float)viewport.width;
+		view.height = (float)viewport.height;
+		view.minZ = viewport.minZ;
+		view.maxZ = viewport.maxZ;
+		
+		Renderer::setViewport(view);
+
 		return true;
 	}
 
@@ -998,17 +898,17 @@
 			return true;
 		}
 
-		if(rect->right <= rect->left || rect->bottom <= rect->top)
+		if(rect->x1 <= rect->x0 || rect->y1 <= rect->y0)
 		{
 			return false;
 		}
 
-		if(rect->left < 0 || rect->top < 0)
+		if(rect->x0 < 0 || rect->y0 < 0)
 		{
 			return false;
 		}
 
-		if(rect->right > (int)surface->getWidth() || rect->bottom > (int)surface->getHeight())
+		if(rect->x1 > (int)surface->getWidth() || rect->y1 > (int)surface->getHeight())
 		{
 			return false;
 		}
@@ -1018,11 +918,7 @@
 
 	void Device::finish()
 	{
-		if(renderTarget)
-		{
-			renderTarget->lock(0, 0, sw::LOCK_READWRITE);
-			renderTarget->unlock();
-		}
+		synchronize();
 	}
 }
 
diff --git a/src/OpenGL ES 2.0/libGLESv2/Device.hpp b/src/OpenGL ES 2.0/libGLESv2/Device.hpp
index ae39446..167fb1b 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Device.hpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Device.hpp
@@ -1,6 +1,6 @@
 // SwiftShader Software Renderer
 //
-// Copyright(c) 2005-2011 TransGaming Inc.
+// Copyright(c) 2005-2012 TransGaming Inc.
 //
 // All rights reserved. No part of this software may be copied, distributed, transmitted,
 // transcribed, stored in a retrieval system, translated into any human or computer
@@ -37,8 +37,8 @@
 
 	struct Viewport
 	{
-		unsigned int x;
-		unsigned int y;
+		int x0;
+		int y0;
 		unsigned int width;
 		unsigned int height;
 		float minZ;
@@ -61,7 +61,6 @@
 		virtual void drawIndexedPrimitive(PrimitiveType type, unsigned int indexOffset, unsigned int primitiveCount, int indexSize);
 		virtual void drawPrimitive(PrimitiveType primitiveType, unsigned int primiveCount);
 		virtual Image *getDepthStencilSurface();
-		virtual bool getRenderTargetData(Image *renderTarget, Image *destSurface);
 		virtual void setDepthStencilSurface(Image *newDepthStencil);
 		virtual void setPixelShader(sw::PixelShader *shader);
 		virtual void setPixelShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count);
diff --git a/src/OpenGL ES 2.0/libGLESv2/Fence.cpp b/src/OpenGL ES 2.0/libGLESv2/Fence.cpp
index 688940b..4b0c6ac 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Fence.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Fence.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Fence.cpp: Implements the Fence class, which supports the GL_NV_fence extension.
diff --git a/src/OpenGL ES 2.0/libGLESv2/Fence.h b/src/OpenGL ES 2.0/libGLESv2/Fence.h
index c7c0d3d..5f68353 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Fence.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Fence.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Fence.h: Defines the Fence class, which supports the GL_NV_fence extension.
diff --git a/src/OpenGL ES 2.0/libGLESv2/Framebuffer.cpp b/src/OpenGL ES 2.0/libGLESv2/Framebuffer.cpp
index e7ee0fe..dba29ee 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Framebuffer.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Framebuffer.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Framebuffer.cpp: Implements the Framebuffer class. Implements GL framebuffer
@@ -116,18 +121,6 @@
     }
 }
 
-unsigned int Framebuffer::getRenderTargetSerial()
-{
-    Renderbuffer *colorbuffer = mColorbufferPointer.get();
-
-    if(colorbuffer)
-    {
-        return colorbuffer->getSerial();
-    }
-
-    return 0;
-}
-
 Image *Framebuffer::getRenderTarget()
 {
     Renderbuffer *colorbuffer = mColorbufferPointer.get();
@@ -157,70 +150,40 @@
     return NULL;
 }
 
-unsigned int Framebuffer::getDepthbufferSerial()
-{
-    Renderbuffer *depthbuffer = mDepthbufferPointer.get();
-
-    if(depthbuffer)
-    {
-        return depthbuffer->getSerial();
-    }
-
-    return 0;
-}
-
-unsigned int Framebuffer::getStencilbufferSerial()
-{
-    Renderbuffer *stencilbuffer = mStencilbufferPointer.get();
-
-    if(stencilbuffer)
-    {
-        return stencilbuffer->getSerial();
-    }
-
-    return 0;
-}
-
 Colorbuffer *Framebuffer::getColorbuffer()
 {
-    Renderbuffer *rb = mColorbufferPointer.get();
+    Renderbuffer *renderbuffer = mColorbufferPointer.get();
 
-    if(rb != NULL && rb->isColorbuffer())
+    if (renderbuffer)
     {
-        return static_cast<Colorbuffer*>(rb->getStorage());
+        return renderbuffer->getColorbuffer();
     }
-    else
-    {
-        return NULL;
-    }
+    
+    return NULL;
 }
 
 DepthStencilbuffer *Framebuffer::getDepthbuffer()
 {
-    Renderbuffer *rb = mDepthbufferPointer.get();
+    Renderbuffer *renderbuffer = mDepthbufferPointer.get();
 
-    if(rb != NULL && rb->isDepthbuffer())
+    if (renderbuffer)
     {
-        return static_cast<DepthStencilbuffer*>(rb->getStorage());
+        return renderbuffer->getDepthbuffer();
     }
-    else
-    {
-        return NULL;
-    }
+
+    return NULL;
 }
 
 DepthStencilbuffer *Framebuffer::getStencilbuffer()
 {
-    Renderbuffer *rb = mStencilbufferPointer.get();
+    Renderbuffer *renderbuffer = mStencilbufferPointer.get();
 
-    if(rb != NULL && rb->isStencilbuffer())
+    if (renderbuffer)
     {
-        return static_cast<DepthStencilbuffer*>(rb->getStorage());
+        return renderbuffer->getStencilbuffer();
     }
-    else
-    {
-        return NULL;
-    }
+    
+    return NULL;
 }
 
 GLenum Framebuffer::getColorbufferType()
diff --git a/src/OpenGL ES 2.0/libGLESv2/Framebuffer.h b/src/OpenGL ES 2.0/libGLESv2/Framebuffer.h
index b9fcc7a..378de0b 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Framebuffer.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Framebuffer.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Framebuffer.h: Defines the Framebuffer class. Implements GL framebuffer
@@ -42,10 +47,6 @@
     Image *getRenderTarget();
     Image *getDepthStencil();
 
-    unsigned int getRenderTargetSerial();
-    unsigned int getDepthbufferSerial();
-    unsigned int getStencilbufferSerial();
-
     Colorbuffer *getColorbuffer();
     DepthStencilbuffer *getDepthbuffer();
     DepthStencilbuffer *getStencilbuffer();
diff --git a/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.cpp b/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.cpp
index e06baa9..7db672a 100644
--- a/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // HandleAllocator.cpp: Implements the HandleAllocator class, which is used
diff --git a/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.h b/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.h
index 76ea0f9..6bc0057 100644
--- a/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.h
+++ b/src/OpenGL ES 2.0/libGLESv2/HandleAllocator.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // HandleAllocator.h: Defines the HandleAllocator class, which is used to
diff --git a/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.cpp b/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.cpp
index 55688a3..a83078f 100644
--- a/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // IndexDataManager.cpp: Defines the IndexDataManager, a class that
@@ -10,8 +15,6 @@
 #include "IndexDataManager.h"
 
 #include "Buffer.h"
-#include "mathutil.h"
-#include "main.h"
 #include "common/debug.h"
 
 namespace
@@ -22,9 +25,9 @@
 namespace gl
 {
 
-IndexDataManager::IndexDataManager(Context *context, Device *device) : mDevice(device)
+IndexDataManager::IndexDataManager()
 {
-    mStreamingBuffer = new StreamingIndexBuffer(mDevice, INITIAL_INDEX_BUFFER_SIZE);
+    mStreamingBuffer = new StreamingIndexBuffer(INITIAL_INDEX_BUFFER_SIZE);
 
     if(!mStreamingBuffer)
     {
@@ -96,7 +99,7 @@
 
     if(buffer != NULL)
     {
-        switch (type)
+        switch(type)
         {
           case GL_UNSIGNED_BYTE:  alignedOffset = (offset % sizeof(GLubyte) == 0);  break;
           case GL_UNSIGNED_SHORT: alignedOffset = (offset % sizeof(GLushort) == 0); break;
@@ -151,7 +154,7 @@
 
 std::size_t IndexDataManager::typeSize(GLenum type)
 {
-    switch (type)
+    switch(type)
     {
     case GL_UNSIGNED_INT:   return sizeof(GLuint);
     case GL_UNSIGNED_SHORT: return sizeof(GLushort);
@@ -160,7 +163,7 @@
     }
 }
 
-StreamingIndexBuffer::StreamingIndexBuffer(Device *device, UINT initialSize) : mDevice(device), mBufferSize(initialSize), mIndexBuffer(NULL)
+StreamingIndexBuffer::StreamingIndexBuffer(UINT initialSize) : mBufferSize(initialSize), mIndexBuffer(NULL)
 {
 	if(initialSize > 0)
     {
@@ -228,7 +231,7 @@
     
         if(!mIndexBuffer)
         {
-            ERR("Out of memory allocating a vertex buffer of size %lu.", mBufferSize);
+            ERR("Out of memory allocating an index buffer of size %lu.", mBufferSize);
         }
 
         mWritePosition = 0;
diff --git a/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.h b/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.h
index 65efb85..9fab0a1 100644
--- a/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.h
+++ b/src/OpenGL ES 2.0/libGLESv2/IndexDataManager.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // IndexDataManager.h: Defines the IndexDataManager, a class that
@@ -11,14 +16,10 @@
 #define LIBGLESV2_INDEXDATAMANAGER_H_
 
 #include "Context.h"
-#include "Device.hpp"
 
 #define GL_APICALL
 #include <GLES2/gl2.h>
 
-#include <vector>
-#include <cstddef>
-
 namespace gl
 {
 
@@ -34,19 +35,16 @@
 class StreamingIndexBuffer
 {
   public:
-    StreamingIndexBuffer(Device *device, UINT initialSize);
+    StreamingIndexBuffer(UINT initialSize);
     virtual ~StreamingIndexBuffer();
 
     void *map(UINT requiredSpace, UINT *offset);
 	void unmap();
     void reserveSpace(UINT requiredSpace, GLenum type);
 
-	UINT size() const {return mBufferSize;}
 	sw::Resource *getResource() const;
 
   private:
-	Device *const mDevice;
-
     sw::Resource *mIndexBuffer;
     UINT mBufferSize;
     UINT mWritePosition;
@@ -55,7 +53,7 @@
 class IndexDataManager
 {
   public:
-    IndexDataManager(Context *context, Device *evice);
+    IndexDataManager();
     virtual ~IndexDataManager();
 
     GLenum prepareIndexData(GLenum type, GLsizei count, Buffer *arrayElementBuffer, const void *indices, TranslatedIndexData *translated);
@@ -63,10 +61,6 @@
 	static std::size_t typeSize(GLenum type);
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(IndexDataManager);
-
-    Device *const mDevice;
-
     StreamingIndexBuffer *mStreamingBuffer;
 };
 
diff --git a/src/OpenGL ES 2.0/libGLESv2/Program.cpp b/src/OpenGL ES 2.0/libGLESv2/Program.cpp
index 8b0d85f..20f80e5 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Program.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Program.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Program.cpp: Implements the Program class. Implements GL program objects
@@ -18,3100 +23,2221 @@
 
 #include <string>
 
-#if !defined(ANGLE_COMPILE_OPTIMIZATION_LEVEL)
-#define ANGLE_COMPILE_OPTIMIZATION_LEVEL D3DCOMPILE_OPTIMIZATION_LEVEL3
-#endif
-
 namespace gl
 {
-unsigned int Program::mCurrentSerial = 1;
-const char *fakepath = "C:\\fakepath";
+	unsigned int Program::currentSerial = 1;
 
-std::string str(int i)
-{
-    char buffer[20];
-    sprintf(buffer, "%d", i);
-    return buffer;
-}
+	std::string str(int i)
+	{
+		char buffer[20];
+		sprintf(buffer, "%d", i);
+		return buffer;
+	}
 
-Uniform::Uniform(GLenum type, const std::string &_name, unsigned int arraySize) : type(type), _name(_name), name(Program::undecorateUniform(_name)), arraySize(arraySize)
-{
-    int bytes = UniformTypeSize(type) * arraySize;
-    data = new unsigned char[bytes];
-    memset(data, 0, bytes);
-    dirty = true;
-    handlesSet = false;
-}
+	Uniform::Uniform(GLenum type, const std::string &name, unsigned int arraySize) : type(type), name(name), arraySize(arraySize)
+	{
+		int bytes = UniformTypeSize(type) * size();
+		data = new unsigned char[bytes];
+		memset(data, 0, bytes);
+		dirty = true;
 
-Uniform::~Uniform()
-{
-    delete[] data;
-}
+		psRegisterIndex = -1;
+		vsRegisterIndex = -1;
+	}
 
-bool Uniform::isArray()
-{
-    return _name.compare(0, 3, "ar_") == 0;
-}
+	Uniform::~Uniform()
+	{
+		delete[] data;
+	}
 
-UniformLocation::UniformLocation(const std::string &_name, unsigned int element, unsigned int index) 
-    : name(Program::undecorateUniform(_name)), element(element), index(index)
-{
-}
+	bool Uniform::isArray() const
+	{
+		return arraySize >= 1;
+	}
 
-Program::Program(ResourceManager *manager, GLuint handle) : mResourceManager(manager), mHandle(handle), mSerial(issueSerial())
-{
-    mFragmentShader = NULL;
-    mVertexShader = NULL;
+	int Uniform::size() const
+	{
+		return arraySize > 0 ? arraySize : 1;
+	}
 
-    mPixelExecutable = NULL;
-    mVertexExecutable = NULL;
-    mConstantTablePS = NULL;
-    mConstantTableVS = NULL;
+	int Uniform::registerCount() const
+	{
+		return size() * VariableRowCount(type);
+	}
 
-    mInfoLog = NULL;
-    mValidated = false;
+	UniformLocation::UniformLocation(const std::string &name, unsigned int element, unsigned int index) : name(name), element(element), index(index)
+	{
+	}
 
-    unlink();
+	Program::Program(ResourceManager *manager, GLuint handle) : resourceManager(manager), handle(handle), serial(issueSerial())
+	{
+		device = getDevice();
 
-    mDeleteStatus = false;
+		fragmentShader = 0;
+		vertexShader = 0;
+		pixelBinary = 0;
+		vertexBinary = 0;
 
-    mRefCount = 0;
-}
+		infoLog = 0;
+		validated = false;
 
-Program::~Program()
-{
-    unlink(true);
+		unlink();
 
-    if(mVertexShader != NULL)
-    {
-        mVertexShader->release();
-    }
+		orphaned = false;
+		referenceCount = 0;
+	}
 
-    if(mFragmentShader != NULL)
-    {
-        mFragmentShader->release();
-    }
-}
+	Program::~Program()
+	{
+		unlink();
 
-bool Program::attachShader(Shader *shader)
-{
-    if(shader->getType() == GL_VERTEX_SHADER)
-    {
-        if(mVertexShader)
-        {
-            return false;
-        }
-
-        mVertexShader = (VertexShader*)shader;
-        mVertexShader->addRef();
-    }
-    else if(shader->getType() == GL_FRAGMENT_SHADER)
-    {
-        if(mFragmentShader)
-        {
-            return false;
-        }
-
-        mFragmentShader = (FragmentShader*)shader;
-        mFragmentShader->addRef();
-    }
-    else UNREACHABLE();
-
-    return true;
-}
-
-bool Program::detachShader(Shader *shader)
-{
-    if(shader->getType() == GL_VERTEX_SHADER)
-    {
-        if(mVertexShader != shader)
-        {
-            return false;
-        }
-
-        mVertexShader->release();
-        mVertexShader = NULL;
-    }
-    else if(shader->getType() == GL_FRAGMENT_SHADER)
-    {
-        if(mFragmentShader != shader)
-        {
-            return false;
-        }
-
-        mFragmentShader->release();
-        mFragmentShader = NULL;
-    }
-    else UNREACHABLE();
-
-    return true;
-}
-
-int Program::getAttachedShadersCount() const
-{
-    return (mVertexShader ? 1 : 0) + (mFragmentShader ? 1 : 0);
-}
-
-sw::PixelShader *Program::getPixelShader()
-{
-    return mPixelExecutable;
-}
-
-sw::VertexShader *Program::getVertexShader()
-{
-    return mVertexExecutable;
-}
-
-void Program::bindAttributeLocation(GLuint index, const char *name)
-{
-    if(index < MAX_VERTEX_ATTRIBS)
-    {
-        for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
-        {
-            mAttributeBinding[i].erase(name);
-        }
-
-        mAttributeBinding[index].insert(name);
-    }
-}
-
-GLuint Program::getAttributeLocation(const char *name)
-{
-    if(name)
-    {
-        for(int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
-        {
-            if(mLinkedAttribute[index].name == std::string(name))
-            {
-                return index;
-            }
-        }
-    }
-
-    return -1;
-}
-
-int Program::getSemanticIndex(int attributeIndex)
-{
-    ASSERT(attributeIndex >= 0 && attributeIndex < MAX_VERTEX_ATTRIBS);
-    
-    return mSemanticIndex[attributeIndex];
-}
-
-// Returns the index of the texture image unit (0-19) corresponding to a Direct3D 9 sampler
-// index (0-15 for the pixel shader and 0-3 for the vertex shader).
-GLint Program::getSamplerMapping(sw::SamplerType type, unsigned int samplerIndex)
-{
-    GLuint logicalTextureUnit = -1;
-
-    switch(type)
-    {
-	case sw::SAMPLER_PIXEL:
-        ASSERT(samplerIndex < sizeof(mSamplersPS)/sizeof(mSamplersPS[0]));
-
-        if(mSamplersPS[samplerIndex].active)
-        {
-            logicalTextureUnit = mSamplersPS[samplerIndex].logicalTextureUnit;
-        }
-        break;
-	case sw::SAMPLER_VERTEX:
-        ASSERT(samplerIndex < sizeof(mSamplersVS)/sizeof(mSamplersVS[0]));
-
-        if(mSamplersVS[samplerIndex].active)
-        {
-            logicalTextureUnit = mSamplersVS[samplerIndex].logicalTextureUnit;
-        }
-        break;
-    default: UNREACHABLE();
-    }
-
-    if(logicalTextureUnit >= 0 && logicalTextureUnit < MAX_COMBINED_TEXTURE_IMAGE_UNITS)
-    {
-        return logicalTextureUnit;
-    }
-
-    return -1;
-}
-
-// Returns the texture type for a given Direct3D 9 sampler type and
-// index (0-15 for the pixel shader and 0-3 for the vertex shader).
-TextureType Program::getSamplerTextureType(sw::SamplerType type, unsigned int samplerIndex)
-{
-    switch(type)
-    {
-	case sw::SAMPLER_PIXEL:
-        ASSERT(samplerIndex < sizeof(mSamplersPS)/sizeof(mSamplersPS[0]));
-        ASSERT(mSamplersPS[samplerIndex].active);
-        return mSamplersPS[samplerIndex].textureType;
-	case sw::SAMPLER_VERTEX:
-        ASSERT(samplerIndex < sizeof(mSamplersVS)/sizeof(mSamplersVS[0]));
-        ASSERT(mSamplersVS[samplerIndex].active);
-        return mSamplersVS[samplerIndex].textureType;
-    default: UNREACHABLE();
-    }
-
-    return TEXTURE_2D;
-}
-
-GLint Program::getUniformLocation(std::string name)
-{
-    int subscript = 0;
-
-    // Strip any trailing array operator and retrieve the subscript
-    size_t open = name.find_last_of('[');
-    size_t close = name.find_last_of(']');
-    if(open != std::string::npos && close == name.length() - 1)
-    {
-        subscript = atoi(name.substr(open + 1).c_str());
-        name.erase(open);
-    }
-
-    unsigned int numUniforms = mUniformIndex.size();
-    for(unsigned int location = 0; location < numUniforms; location++)
-    {
-        if(mUniformIndex[location].name == name &&
-           mUniformIndex[location].element == subscript)
-        {
-            return location;
-        }
-    }
-
-    return -1;
-}
-
-bool Program::setUniform1fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type == GL_FLOAT)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat),
-               v, sizeof(GLfloat) * count);
-    }
-    else if(targetUniform->type == GL_BOOL)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-        GLboolean *boolParams = new GLboolean[count];
-
-        for(int i = 0; i < count; ++i)
-        {
-            if(v[i] == 0.0f)
-            {
-                boolParams[i] = GL_FALSE;
-            }
-            else
-            {
-                boolParams[i] = GL_TRUE;
-            }
-        }
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean),
-               boolParams, sizeof(GLboolean) * count);
-
-        delete [] boolParams;
-    }
-    else
-    {
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type == GL_FLOAT_VEC2)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 2,
-               v, 2 * sizeof(GLfloat) * count);
-    }
-    else if(targetUniform->type == GL_BOOL_VEC2)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-        GLboolean *boolParams = new GLboolean[count * 2];
-
-        for(int i = 0; i < count * 2; ++i)
-        {
-            if(v[i] == 0.0f)
-            {
-                boolParams[i] = GL_FALSE;
-            }
-            else
-            {
-                boolParams[i] = GL_TRUE;
-            }
-        }
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 2,
-               boolParams, 2 * sizeof(GLboolean) * count);
-
-        delete [] boolParams;
-    }
-    else 
-    {
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type == GL_FLOAT_VEC3)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 3,
-               v, 3 * sizeof(GLfloat) * count);
-    }
-    else if(targetUniform->type == GL_BOOL_VEC3)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-        GLboolean *boolParams = new GLboolean[count * 3];
-
-        for(int i = 0; i < count * 3; ++i)
-        {
-            if(v[i] == 0.0f)
-            {
-                boolParams[i] = GL_FALSE;
-            }
-            else
-            {
-                boolParams[i] = GL_TRUE;
-            }
-        }
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 3,
-               boolParams, 3 * sizeof(GLboolean) * count);
-
-        delete [] boolParams;
-    }
-    else 
-    {
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type == GL_FLOAT_VEC4)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 4,
-               v, 4 * sizeof(GLfloat) * count);
-    }
-    else if(targetUniform->type == GL_BOOL_VEC4)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-        GLboolean *boolParams = new GLboolean[count * 4];
-
-        for(int i = 0; i < count * 4; ++i)
-        {
-            if(v[i] == 0.0f)
-            {
-                boolParams[i] = GL_FALSE;
-            }
-            else
-            {
-                boolParams[i] = GL_TRUE;
-            }
-        }
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 4,
-               boolParams, 4 * sizeof(GLboolean) * count);
-
-        delete [] boolParams;
-    }
-    else 
-    {
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::setUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type != GL_FLOAT_MAT2)
-    {
-        return false;
-    }
-
-    int arraySize = targetUniform->arraySize;
-
-    if(arraySize == 1 && count > 1)
-        return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-    count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-    memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 4,
-           value, 4 * sizeof(GLfloat) * count);
-
-    return true;
-}
-
-bool Program::setUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type != GL_FLOAT_MAT3)
-    {
-        return false;
-    }
-
-    int arraySize = targetUniform->arraySize;
-
-    if(arraySize == 1 && count > 1)
-        return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-    count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-    memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 9,
-           value, 9 * sizeof(GLfloat) * count);
-
-    return true;
-}
-
-bool Program::setUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type != GL_FLOAT_MAT4)
-    {
-        return false;
-    }
-
-    int arraySize = targetUniform->arraySize;
-
-    if(arraySize == 1 && count > 1)
-        return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-    count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-    memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLfloat) * 16,
-           value, 16 * sizeof(GLfloat) * count);
-
-    return true;
-}
-
-bool Program::setUniform1iv(GLint location, GLsizei count, const GLint *v)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type == GL_INT ||
-        targetUniform->type == GL_SAMPLER_2D ||
-        targetUniform->type == GL_SAMPLER_CUBE)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLint),
-               v, sizeof(GLint) * count);
-    }
-    else if(targetUniform->type == GL_BOOL)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-        GLboolean *boolParams = new GLboolean[count];
-
-        for(int i = 0; i < count; ++i)
-        {
-            if(v[i] == 0)
-            {
-                boolParams[i] = GL_FALSE;
-            }
-            else
-            {
-                boolParams[i] = GL_TRUE;
-            }
-        }
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean),
-               boolParams, sizeof(GLboolean) * count);
-
-        delete [] boolParams;
-    }
-    else
-    {
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::setUniform2iv(GLint location, GLsizei count, const GLint *v)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type == GL_INT_VEC2)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLint) * 2,
-               v, 2 * sizeof(GLint) * count);
-    }
-    else if(targetUniform->type == GL_BOOL_VEC2)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-        GLboolean *boolParams = new GLboolean[count * 2];
-
-        for(int i = 0; i < count * 2; ++i)
-        {
-            if(v[i] == 0)
-            {
-                boolParams[i] = GL_FALSE;
-            }
-            else
-            {
-                boolParams[i] = GL_TRUE;
-            }
-        }
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 2,
-               boolParams, 2 * sizeof(GLboolean) * count);
-
-        delete [] boolParams;
-    }
-    else
-    {
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::setUniform3iv(GLint location, GLsizei count, const GLint *v)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type == GL_INT_VEC3)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLint) * 3,
-               v, 3 * sizeof(GLint) * count);
-    }
-    else if(targetUniform->type == GL_BOOL_VEC3)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-        GLboolean *boolParams = new GLboolean[count * 3];
-
-        for(int i = 0; i < count * 3; ++i)
-        {
-            if(v[i] == 0)
-            {
-                boolParams[i] = GL_FALSE;
-            }
-            else
-            {
-                boolParams[i] = GL_TRUE;
-            }
-        }
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 3,
-               boolParams, 3 * sizeof(GLboolean) * count);
-
-        delete [] boolParams;
-    }
-    else
-    {
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::setUniform4iv(GLint location, GLsizei count, const GLint *v)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-    targetUniform->dirty = true;
-
-    if(targetUniform->type == GL_INT_VEC4)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLint) * 4,
-               v, 4 * sizeof(GLint) * count);
-    }
-    else if(targetUniform->type == GL_BOOL_VEC4)
-    {
-        int arraySize = targetUniform->arraySize;
-
-        if(arraySize == 1 && count > 1)
-            return false; // attempting to write an array to a non-array uniform is an INVALID_OPERATION
-
-        count = std::min(arraySize - (int)mUniformIndex[location].element, count);
-        GLboolean *boolParams = new GLboolean[count * 4];
-
-        for(int i = 0; i < count * 4; ++i)
-        {
-            if(v[i] == 0)
-            {
-                boolParams[i] = GL_FALSE;
-            }
-            else
-            {
-                boolParams[i] = GL_TRUE;
-            }
-        }
-
-        memcpy(targetUniform->data + mUniformIndex[location].element * sizeof(GLboolean) * 4,
-               boolParams, 4 * sizeof(GLboolean) * count);
-
-        delete [] boolParams;
-    }
-    else
-    {
-        return false;
-    }
-
-    return true;
-}
-
-bool Program::getUniformfv(GLint location, GLfloat *params)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
-    unsigned int count = UniformComponentCount(targetUniform->type);
-
-    switch (UniformComponentType(targetUniform->type))
-    {
-      case GL_BOOL:
-        {
-            GLboolean *boolParams = (GLboolean*)targetUniform->data + mUniformIndex[location].element * count;
-
-            for(unsigned int i = 0; i < count; ++i)
-            {
-                params[i] = (boolParams[i] == GL_FALSE) ? 0.0f : 1.0f;
-            }
-        }
-        break;
-      case GL_FLOAT:
-        memcpy(params, targetUniform->data + mUniformIndex[location].element * count * sizeof(GLfloat),
-               count * sizeof(GLfloat));
-        break;
-      case GL_INT:
-        {
-            GLint *intParams = (GLint*)targetUniform->data + mUniformIndex[location].element * count;
-
-            for(unsigned int i = 0; i < count; ++i)
-            {
-                params[i] = (float)intParams[i];
-            }
-        }
-        break;
-      default: UNREACHABLE();
-    }
-
-    return true;
-}
-
-bool Program::getUniformiv(GLint location, GLint *params)
-{
-    if(location < 0 || location >= (int)mUniformIndex.size())
-    {
-        return false;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
-    unsigned int count = UniformComponentCount(targetUniform->type);
-
-    switch (UniformComponentType(targetUniform->type))
-    {
-      case GL_BOOL:
-        {
-            GLboolean *boolParams = targetUniform->data + mUniformIndex[location].element * count;
-
-            for(unsigned int i = 0; i < count; ++i)
-            {
-                params[i] = (GLint)boolParams[i];
-            }
-        }
-        break;
-      case GL_FLOAT:
-        {
-            GLfloat *floatParams = (GLfloat*)targetUniform->data + mUniformIndex[location].element * count;
-
-            for(unsigned int i = 0; i < count; ++i)
-            {
-                params[i] = (GLint)floatParams[i];
-            }
-        }
-        break;
-      case GL_INT:
-        memcpy(params, targetUniform->data + mUniformIndex[location].element * count * sizeof(GLint),
-               count * sizeof(GLint));
-        break;
-      default: UNREACHABLE();
-    }
-
-    return true;
-}
-
-void Program::dirtyAllUniforms()
-{
-    unsigned int numUniforms = mUniforms.size();
-    for(unsigned int index = 0; index < numUniforms; index++)
-    {
-        mUniforms[index]->dirty = true;
-    }
-}
-
-// Applies all the uniforms set for this program object to the Direct3D 9 device
-void Program::applyUniforms()
-{
-    unsigned int numUniforms = mUniformIndex.size();
-    for(unsigned int location = 0; location < numUniforms; location++)
-    {
-        if(mUniformIndex[location].element != 0)
-        {
-            continue;
-        }
-
-        Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
-        if(targetUniform->dirty)
-        {
-            int arraySize = targetUniform->arraySize;
-            GLfloat *f = (GLfloat*)targetUniform->data;
-            GLint *i = (GLint*)targetUniform->data;
-            GLboolean *b = (GLboolean*)targetUniform->data;
-
-            switch (targetUniform->type)
-            {
-              case GL_BOOL:       applyUniform1bv(location, arraySize, b);       break;
-              case GL_BOOL_VEC2:  applyUniform2bv(location, arraySize, b);       break;
-              case GL_BOOL_VEC3:  applyUniform3bv(location, arraySize, b);       break;
-              case GL_BOOL_VEC4:  applyUniform4bv(location, arraySize, b);       break;
-              case GL_FLOAT:      applyUniform1fv(location, arraySize, f);       break;
-              case GL_FLOAT_VEC2: applyUniform2fv(location, arraySize, f);       break;
-              case GL_FLOAT_VEC3: applyUniform3fv(location, arraySize, f);       break;
-              case GL_FLOAT_VEC4: applyUniform4fv(location, arraySize, f);       break;
-              case GL_FLOAT_MAT2: applyUniformMatrix2fv(location, arraySize, f); break;
-              case GL_FLOAT_MAT3: applyUniformMatrix3fv(location, arraySize, f); break;
-              case GL_FLOAT_MAT4: applyUniformMatrix4fv(location, arraySize, f); break;
-              case GL_SAMPLER_2D:
-              case GL_SAMPLER_CUBE:
-              case GL_INT:        applyUniform1iv(location, arraySize, i);       break;
-              case GL_INT_VEC2:   applyUniform2iv(location, arraySize, i);       break;
-              case GL_INT_VEC3:   applyUniform3iv(location, arraySize, i);       break;
-              case GL_INT_VEC4:   applyUniform4iv(location, arraySize, i);       break;
-              default:
-                UNREACHABLE();
-            }
-
-            targetUniform->dirty = false;
-        }
-    }
-}
-
-// Compiles the HLSL code of the attached shaders into executable binaries
-ID3D10Blob *Program::compileToBinary(const char *hlsl, const char *profile, ID3DXConstantTable **constantTable)
-{
-    if(!hlsl)
-    {
-        return NULL;
-    }
-
-    UINT flags = ANGLE_COMPILE_OPTIMIZATION_LEVEL;
-
-    ID3D10Blob *binary = NULL;
-    ID3D10Blob *errorMessage = NULL;
-    HRESULT result = D3DCompile(hlsl, strlen(hlsl), fakepath, NULL, NULL, "main", profile, flags, 0, &binary, &errorMessage);
-
-    if(errorMessage)
-    {
-        const char *message = (const char*)errorMessage->GetBufferPointer();
-
-        appendToInfoLogSanitized(message);
-        TRACE("\n%s", hlsl);
-        TRACE("\n%s", message);
-
-        errorMessage->Release();
-        errorMessage = NULL;
-    }
-
-    if(FAILED(result))
-    {
-        if(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
-        {
-            error(GL_OUT_OF_MEMORY);
-        }
-
-        return NULL;
-    }
-
-    result = D3DXGetShaderConstantTable(static_cast<const DWORD*>(binary->GetBufferPointer()), constantTable);
-
-    if(FAILED(result))
-    {
-        if(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
-        {
-            error(GL_OUT_OF_MEMORY);
-        }
-
-        binary->Release();
-
-        return NULL;
-    }
-
-    return binary;
-}
-
-// Packs varyings into generic varying registers, using the algorithm from [OpenGL ES Shading Language 1.00 rev. 17] appendix A section 7 page 111
-// Returns the number of used varying registers, or -1 if unsuccesful
-int Program::packVaryings(const Varying *packing[][4])
-{
-    Context *context = getContext();
-
-    for(VaryingList::iterator varying = mFragmentShader->varyings.begin(); varying != mFragmentShader->varyings.end(); varying++)
-    {
-        int n = VariableRowCount(varying->type) * varying->size;
-        int m = VariableColumnCount(varying->type);
-        bool success = false;
-
-        if(m == 2 || m == 3 || m == 4)
-        {
-            for(int r = 0; r <= MAX_VARYING_VECTORS - n && !success; r++)
-            {
-                bool available = true;
-
-                for(int y = 0; y < n && available; y++)
-                {
-                    for(int x = 0; x < m && available; x++)
-                    {
-                        if(packing[r + y][x])
-                        {
-                            available = false;
-                        }
-                    }
-                }
-
-                if(available)
-                {
-                    varying->reg = r;
-                    varying->col = 0;
-
-                    for(int y = 0; y < n; y++)
-                    {
-                        for(int x = 0; x < m; x++)
-                        {
-                            packing[r + y][x] = &*varying;
-                        }
-                    }
-
-                    success = true;
-                }
-            }
-
-            if(!success && m == 2)
-            {
-                for(int r = MAX_VARYING_VECTORS - n; r >= 0 && !success; r--)
-                {
-                    bool available = true;
-
-                    for(int y = 0; y < n && available; y++)
-                    {
-                        for(int x = 2; x < 4 && available; x++)
-                        {
-                            if(packing[r + y][x])
-                            {
-                                available = false;
-                            }
-                        }
-                    }
-
-                    if(available)
-                    {
-                        varying->reg = r;
-                        varying->col = 2;
-
-                        for(int y = 0; y < n; y++)
-                        {
-                            for(int x = 2; x < 4; x++)
-                            {
-                                packing[r + y][x] = &*varying;
-                            }
-                        }
-
-                        success = true;
-                    }
-                }
-            }
-        }
-        else if(m == 1)
-        {
-            int space[4] = {0};
-
-            for(int y = 0; y < MAX_VARYING_VECTORS; y++)
-            {
-                for(int x = 0; x < 4; x++)
-                {
-                    space[x] += packing[y][x] ? 0 : 1;
-                }
-            }
-
-            int column = 0;
-
-            for(int x = 0; x < 4; x++)
-            {
-                if(space[x] >= n && space[x] < space[column])
-                {
-                    column = x;
-                }
-            }
-
-            if(space[column] >= n)
-            {
-                for(int r = 0; r < MAX_VARYING_VECTORS; r++)
-                {
-                    if(!packing[r][column])
-                    {
-                        varying->reg = r;
-
-                        for(int y = r; y < r + n; y++)
-                        {
-                            packing[y][column] = &*varying;
-                        }
-
-                        break;
-                    }
-                }
-
-                varying->col = column;
-
-                success = true;
-            }
-        }
-        else UNREACHABLE();
-
-        if(!success)
-        {
-            appendToInfoLog("Could not pack varying %s", varying->name.c_str());
-
-            return -1;
-        }
-    }
-
-    // Return the number of used registers
-    int registers = 0;
-
-    for(int r = 0; r < MAX_VARYING_VECTORS; r++)
-    {
-        if(packing[r][0] || packing[r][1] || packing[r][2] || packing[r][3])
-        {
-            registers++;
-        }
-    }
-
-    return registers;
-}
-
-bool Program::linkVaryings()
-{
-    if(mPixelHLSL.empty() || mVertexHLSL.empty())
-    {
-        return false;
-    }
-
-    // Reset the varying register assignments
-    for(VaryingList::iterator fragVar = mFragmentShader->varyings.begin(); fragVar != mFragmentShader->varyings.end(); fragVar++)
-    {
-        fragVar->reg = -1;
-        fragVar->col = -1;
-    }
-
-    for(VaryingList::iterator vtxVar = mVertexShader->varyings.begin(); vtxVar != mVertexShader->varyings.end(); vtxVar++)
-    {
-        vtxVar->reg = -1;
-        vtxVar->col = -1;
-    }
-
-    // Map the varyings to the register file
-    const Varying *packing[MAX_VARYING_VECTORS][4] = {NULL};
-    int registers = packVaryings(packing);
-
-    if(registers < 0)
-    {
-        return false;
-    }
-
-    // Write the HLSL input/output declarations
-    Context *context = getContext();
-
-    if(registers == MAX_VARYING_VECTORS && mFragmentShader->mUsesFragCoord)
-    {
-        appendToInfoLog("No varying registers left to support gl_FragCoord");
-
-        return false;
-    }
-
-    for(VaryingList::iterator input = mFragmentShader->varyings.begin(); input != mFragmentShader->varyings.end(); input++)
-    {
-        bool matched = false;
-
-        for(VaryingList::iterator output = mVertexShader->varyings.begin(); output != mVertexShader->varyings.end(); output++)
-        {
-            if(output->name == input->name)
-            {
-                if(output->type != input->type || output->size != input->size)
-                {
-                    appendToInfoLog("Type of vertex varying %s does not match that of the fragment varying", output->name.c_str());
-
-                    return false;
-                }
-
-                output->reg = input->reg;
-                output->col = input->col;
-
-                matched = true;
-                break;
-            }
-        }
-
-        if(!matched)
-        {
-            appendToInfoLog("Fragment varying %s does not match any vertex varying", input->name.c_str());
-
-            return false;
-        }
-    }
-
-    mVertexHLSL += "struct VS_INPUT\n"
-                   "{\n";
-
-    int semanticIndex = 0;
-    for(AttributeArray::iterator attribute = mVertexShader->mAttributes.begin(); attribute != mVertexShader->mAttributes.end(); attribute++)
-    {
-        switch (attribute->type)
-        {
-          case GL_FLOAT:      mVertexHLSL += "    float ";    break;
-          case GL_FLOAT_VEC2: mVertexHLSL += "    float2 ";   break;
-          case GL_FLOAT_VEC3: mVertexHLSL += "    float3 ";   break;
-          case GL_FLOAT_VEC4: mVertexHLSL += "    float4 ";   break;
-          case GL_FLOAT_MAT2: mVertexHLSL += "    float2x2 "; break;
-          case GL_FLOAT_MAT3: mVertexHLSL += "    float3x3 "; break;
-          case GL_FLOAT_MAT4: mVertexHLSL += "    float4x4 "; break;
-          default:  UNREACHABLE();
-        }
-
-        mVertexHLSL += decorateAttribute(attribute->name) + " : TEXCOORD" + str(semanticIndex) + ";\n";
-
-        semanticIndex += VariableRowCount(attribute->type);
-    }
-
-    mVertexHLSL += "};\n"
-                   "\n"
-                   "struct VS_OUTPUT\n"
-                   "{\n"
-                   "    float4 gl_Position : POSITION;\n";
-
-    for(int r = 0; r < registers; r++)
-    {
-        int registerSize = packing[r][3] ? 4 : (packing[r][2] ? 3 : (packing[r][1] ? 2 : 1));
-
-        mVertexHLSL += "    float" + str(registerSize) + " v" + str(r) + " : COLOR" + str(r) + ";\n";
-    }
-
-    if(mFragmentShader->mUsesFragCoord)
-    {
-        mVertexHLSL += "    float4 gl_FragCoord : COLOR" + str(registers) + ";\n";
-    }
-
-    if(mVertexShader->mUsesPointSize)
-    {
-        mVertexHLSL += "    float gl_PointSize : PSIZE;\n";
-    }
-
-    mVertexHLSL += "};\n"
-                   "\n"
-                   "VS_OUTPUT main(VS_INPUT input)\n"
-                   "{\n";
-
-    for(AttributeArray::iterator attribute = mVertexShader->mAttributes.begin(); attribute != mVertexShader->mAttributes.end(); attribute++)
-    {
-        mVertexHLSL += "    " + decorateAttribute(attribute->name) + " = ";
-
-        if(VariableRowCount(attribute->type) > 1)   // Matrix
-        {
-            mVertexHLSL += "transpose";
-        }
-
-        mVertexHLSL += "(input." + decorateAttribute(attribute->name) + ");\n";
-    }
-
-    mVertexHLSL += "\n"
-                   "    gl_main();\n"
-                   "\n"
-                   "    VS_OUTPUT output;\n"
-                   "    output.gl_Position.x = gl_Position.x - dx_HalfPixelSize.x * gl_Position.w;\n"
-                   "    output.gl_Position.y = gl_Position.y - dx_HalfPixelSize.y * gl_Position.w;\n"
-                   "    output.gl_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n"
-                   "    output.gl_Position.w = gl_Position.w;\n";
-
-    if(mVertexShader->mUsesPointSize)
-    {
-        mVertexHLSL += "    output.gl_PointSize = clamp(gl_PointSize, 1.0, " + str((int)ALIASED_POINT_SIZE_RANGE_MAX) + ");\n";
-    }
-
-    if(mFragmentShader->mUsesFragCoord)
-    {
-        mVertexHLSL += "    output.gl_FragCoord = gl_Position;\n";
-    }
-
-    for(VaryingList::iterator varying = mVertexShader->varyings.begin(); varying != mVertexShader->varyings.end(); varying++)
-    {
-        if(varying->reg >= 0)
-        {
-            for(int i = 0; i < varying->size; i++)
-            {
-                int rows = VariableRowCount(varying->type);
-
-                for(int j = 0; j < rows; j++)
-                {
-                    int r = varying->reg + i * rows + j;
-                    mVertexHLSL += "    output.v" + str(r);
-
-                    bool sharedRegister = false;   // Register used by multiple varyings
-                    
-                    for(int x = 0; x < 4; x++)
-                    {
-                        if(packing[r][x] && packing[r][x] != packing[r][0])
-                        {
-                            sharedRegister = true;
-                            break;
-                        }
-                    }
-
-                    if(sharedRegister)
-                    {
-                        mVertexHLSL += ".";
-
-                        for(int x = 0; x < 4; x++)
-                        {
-                            if(packing[r][x] == &*varying)
-                            {
-                                switch(x)
-                                {
-                                  case 0: mVertexHLSL += "x"; break;
-                                  case 1: mVertexHLSL += "y"; break;
-                                  case 2: mVertexHLSL += "z"; break;
-                                  case 3: mVertexHLSL += "w"; break;
-                                }
-                            }
-                        }
-                    }
-
-                    mVertexHLSL += " = " + varying->name;
-                    
-                    if(varying->array)
-                    {
-                        mVertexHLSL += "[" + str(i) + "]";
-                    }
-
-                    if(rows > 1)
-                    {
-                        mVertexHLSL += "[" + str(j) + "]";
-                    }
-                    
-                    mVertexHLSL += ";\n";
-                }
-            }
-        }
-    }
-
-    mVertexHLSL += "\n"
-                   "    return output;\n"
-                   "}\n";
-
-    mPixelHLSL += "struct PS_INPUT\n"
-                  "{\n";
-    
-    for(VaryingList::iterator varying = mFragmentShader->varyings.begin(); varying != mFragmentShader->varyings.end(); varying++)
-    {
-        if(varying->reg >= 0)
-        {
-            for(int i = 0; i < varying->size; i++)
-            {
-                int rows = VariableRowCount(varying->type);
-                for(int j = 0; j < rows; j++)
-                {
-                    std::string n = str(varying->reg + i * rows + j);
-                    mPixelHLSL += "    float4 v" + n + " : COLOR" + n + ";\n";
-                }
-            }
-        }
-        else UNREACHABLE();
-    }
-
-    if(mFragmentShader->mUsesFragCoord)
-    {
-        mPixelHLSL += "    float4 gl_FragCoord : COLOR" + str(registers) + ";\n";
-        mPixelHLSL += "    float2 dx_VPos : VPOS;\n";
-    }
-
-    if(mFragmentShader->mUsesPointCoord)
-    {
-        mPixelHLSL += "    float2 gl_PointCoord : TEXCOORD0;\n";
-    }
-
-    if(mFragmentShader->mUsesFrontFacing)
-    {
-        mPixelHLSL += "    float vFace : VFACE;\n";
-    }
-
-    mPixelHLSL += "};\n"
-                  "\n"
-                  "struct PS_OUTPUT\n"
-                  "{\n"
-                  "    float4 gl_Color[1] : COLOR;\n"
-                  "};\n"
-                  "\n"
-                  "PS_OUTPUT main(PS_INPUT input)\n"
-                  "{\n";
-
-    if(mFragmentShader->mUsesFragCoord)
-    {
-        mPixelHLSL += "    float rhw = 1.0 / input.gl_FragCoord.w;\n";
-        mPixelHLSL += "    gl_FragCoord.x = input.dx_VPos.x + 0.5;\n"
-                      "    gl_FragCoord.y = 2.0 * dx_Viewport.y - input.dx_VPos.y - 0.5;\n";
-        mPixelHLSL += "    gl_FragCoord.z = (input.gl_FragCoord.z * rhw) * dx_Depth.x + dx_Depth.y;\n"
-                      "    gl_FragCoord.w = rhw;\n";
-    }
-
-    if(mFragmentShader->mUsesPointCoord)
-    {
-        mPixelHLSL += "    gl_PointCoord = input.gl_PointCoord;\n";
-    }
-
-    if(mFragmentShader->mUsesFrontFacing)
-    {
-        mPixelHLSL += "    gl_FrontFacing = dx_PointsOrLines || (dx_FrontCCW ? (input.vFace >= 0.0) : (input.vFace <= 0.0));\n";
-    }
-
-    for(VaryingList::iterator varying = mFragmentShader->varyings.begin(); varying != mFragmentShader->varyings.end(); varying++)
-    {
-        if(varying->reg >= 0)
-        {
-            for(int i = 0; i < varying->size; i++)
-            {
-                int rows = VariableRowCount(varying->type);
-                for(int j = 0; j < rows; j++)
-                {
-                    std::string n = str(varying->reg + i * rows + j);
-                    mPixelHLSL += "    " + varying->name;
-
-                    if(varying->array)
-                    {
-                        mPixelHLSL += "[" + str(i) + "]";
-                    }
-
-                    if(rows > 1)
-                    {
-                        mPixelHLSL += "[" + str(j) + "]";
-                    }
-
-                    mPixelHLSL += " = input.v" + n + ";\n";
-                }
-            }
-        }
-        else UNREACHABLE();
-    }
-
-    mPixelHLSL += "\n"
-                  "    gl_main();\n"
-                  "\n"
-                  "    PS_OUTPUT output;\n"                 
-                  "    output.gl_Color[0] = gl_Color[0];\n"
-                  "\n"
-                  "    return output;\n"
-                  "}\n";
-
-    return true;
-}
-
-// Links the HLSL code of the vertex and pixel shader by matching up their varyings,
-// compiling them into binaries, determining the attribute mappings, and collecting
-// a list of uniforms
-void Program::link()
-{
-    unlink();
-
-    if(!mFragmentShader || !mFragmentShader->isCompiled())
-    {
-        return;
-    }
-
-    if(!mVertexShader || !mVertexShader->isCompiled())
-    {
-        return;
-    }
-
-    mPixelHLSL = mFragmentShader->getHLSL();
-    mVertexHLSL = mVertexShader->getHLSL();
-
-    if(!linkVaryings())
-    {
-        return;
-    }
-
-    Context *context = getContext();
-
-    ID3D10Blob *vertexBinary = compileToBinary(mVertexHLSL.c_str(), "vs_3_0", &mConstantTableVS);
-    ID3D10Blob *pixelBinary = compileToBinary(mPixelHLSL.c_str(), "ps_3_0", &mConstantTablePS);
-
-    if(vertexBinary && pixelBinary)
-    {
-        Device *device = getDevice();
-        mVertexExecutable = new sw::VertexShader((unsigned long*)vertexBinary->GetBufferPointer());
-        mPixelExecutable = new sw::PixelShader((unsigned long*)pixelBinary->GetBufferPointer());
-
-        if(!mVertexExecutable || !mPixelExecutable)
-        {
-            return error(GL_OUT_OF_MEMORY);
-        }
-
-        vertexBinary->Release();
-        pixelBinary->Release();
-        vertexBinary = NULL;
-        pixelBinary = NULL;
-
-        if(mVertexExecutable && mPixelExecutable)
-        {
-            if(!linkAttributes())
-            {
-                return;
-            }
-
-            if(!linkUniforms(mConstantTablePS))
-            {
-                return;
-            }
-
-            if(!linkUniforms(mConstantTableVS))
-            {
-                return;
-            }
-
-            // these uniforms are searched as already-decorated because gl_ and dx_
-            // are reserved prefixes, and do not receive additional decoration
-            mDxDepthRangeLocation = getUniformLocation("dx_DepthRange");
-            mDxDepthLocation = getUniformLocation("dx_Depth");
-            mDxViewportLocation = getUniformLocation("dx_Viewport");
-            mDxHalfPixelSizeLocation = getUniformLocation("dx_HalfPixelSize");
-            mDxFrontCCWLocation = getUniformLocation("dx_FrontCCW");
-            mDxPointsOrLinesLocation = getUniformLocation("dx_PointsOrLines");
-
-            mLinked = true;   // Success
-        }
-    }
-}
-
-// Determines the mapping between GL attributes and Direct3D 9 vertex stream usage indices
-bool Program::linkAttributes()
-{
-    unsigned int usedLocations = 0;
-
-    // Link attributes that have a binding location
-    for(AttributeArray::iterator attribute = mVertexShader->mAttributes.begin(); attribute != mVertexShader->mAttributes.end(); attribute++)
-    {
-        int location = getAttributeBinding(attribute->name);
-
-        if(location != -1)   // Set by glBindAttribLocation
-        {
-            if(!mLinkedAttribute[location].name.empty())
-            {
-                // Multiple active attributes bound to the same location; not an error
-            }
-
-            mLinkedAttribute[location] = *attribute;
-
-            int rows = VariableRowCount(attribute->type);
-
-            if(rows + location > MAX_VERTEX_ATTRIBS)
-            {
-                appendToInfoLog("Active attribute (%s) at location %d is too big to fit", attribute->name.c_str(), location);
-
-                return false;
-            }
-
-            for(int i = 0; i < rows; i++)
-            {
-                usedLocations |= 1 << (location + i);
-            }
-        }
-    }
-
-    // Link attributes that don't have a binding location
-    for(AttributeArray::iterator attribute = mVertexShader->mAttributes.begin(); attribute != mVertexShader->mAttributes.end(); attribute++)
-    {
-        int location = getAttributeBinding(attribute->name);
-
-        if(location == -1)   // Not set by glBindAttribLocation
-        {
-            int rows = VariableRowCount(attribute->type);
-            int availableIndex = AllocateFirstFreeBits(&usedLocations, rows, MAX_VERTEX_ATTRIBS);
-
-            if(availableIndex == -1 || availableIndex + rows > MAX_VERTEX_ATTRIBS)
-            {
-                appendToInfoLog("Too many active attributes (%s)", attribute->name.c_str());
-
-                return false;   // Fail to link
-            }
-
-            mLinkedAttribute[availableIndex] = *attribute;
-        }
-    }
-
-    for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; )
-    {
-        int index = mVertexShader->getSemanticIndex(mLinkedAttribute[attributeIndex].name);
-        int rows = std::max(VariableRowCount(mLinkedAttribute[attributeIndex].type), 1);
-
-        for(int r = 0; r < rows; r++)
-        {
-            mSemanticIndex[attributeIndex++] = index++;
-        }
-    }
-
-    return true;
-}
-
-int Program::getAttributeBinding(const std::string &name)
-{
-    for(int location = 0; location < MAX_VERTEX_ATTRIBS; location++)
-    {
-        if(mAttributeBinding[location].find(name) != mAttributeBinding[location].end())
-        {
-            return location;
-        }
-    }
-
-    return -1;
-}
-
-bool Program::linkUniforms(ID3DXConstantTable *constantTable)
-{
-    D3DXCONSTANTTABLE_DESC constantTableDescription;
-    D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
-
-    constantTable->GetDesc(&constantTableDescription);
-
-    for(unsigned int constantIndex = 0; constantIndex < constantTableDescription.Constants; constantIndex++)
-    {
-        D3DXHANDLE constantHandle = constantTable->GetConstant(0, constantIndex);
-        HRESULT result = constantTable->GetConstantDesc(constantHandle, &constantDescription, &descriptionCount);
-        ASSERT(SUCCEEDED(result));
-
-        if(!defineUniform(constantHandle, constantDescription))
-        {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-// Adds the description of a constant found in the binary shader to the list of uniforms
-// Returns true if succesful (uniform not already defined)
-bool Program::defineUniform(const D3DXHANDLE &constantHandle, const D3DXCONSTANT_DESC &constantDescription, std::string name)
-{
-    if(constantDescription.RegisterSet == D3DXRS_SAMPLER)
-    {
-        for(unsigned int samplerIndex = constantDescription.RegisterIndex; samplerIndex < constantDescription.RegisterIndex + constantDescription.RegisterCount; samplerIndex++)
-        {
-            if(mConstantTablePS->GetConstantByName(NULL, constantDescription.Name) != NULL)
-            {
-                if(samplerIndex < MAX_TEXTURE_IMAGE_UNITS)
-                {
-                    mSamplersPS[samplerIndex].active = true;
-                    mSamplersPS[samplerIndex].textureType = (constantDescription.Type == D3DXPT_SAMPLERCUBE) ? TEXTURE_CUBE : TEXTURE_2D;
-                    mSamplersPS[samplerIndex].logicalTextureUnit = 0;
-                }
-                else
-                {
-                    appendToInfoLog("Pixel shader sampler count exceeds MAX_TEXTURE_IMAGE_UNITS (%d).", MAX_TEXTURE_IMAGE_UNITS);
-                    return false;
-                }
-            }
-            
-            if(mConstantTableVS->GetConstantByName(NULL, constantDescription.Name) != NULL)
-            {
-                if(samplerIndex < MAX_VERTEX_TEXTURE_IMAGE_UNITS)
-                {
-                    mSamplersVS[samplerIndex].active = true;
-                    mSamplersVS[samplerIndex].textureType = (constantDescription.Type == D3DXPT_SAMPLERCUBE) ? TEXTURE_CUBE : TEXTURE_2D;
-                    mSamplersVS[samplerIndex].logicalTextureUnit = 0;
-                }
-                else
-                {
-                    appendToInfoLog("Vertex shader sampler count exceeds MAX_VERTEX_TEXTURE_IMAGE_UNITS (%d).", MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-                    return false;
-                }
-            }
-        }
-    }
-
-    switch(constantDescription.Class)
-    {
-      case D3DXPC_STRUCT:
-        {
-            for(unsigned int arrayIndex = 0; arrayIndex < constantDescription.Elements; arrayIndex++)
-            {
-                for(unsigned int field = 0; field < constantDescription.StructMembers; field++)
-                {
-                    D3DXHANDLE fieldHandle = mConstantTablePS->GetConstant(constantHandle, field);
-
-                    D3DXCONSTANT_DESC fieldDescription;
-                    UINT descriptionCount = 1;
-
-                    HRESULT result = mConstantTablePS->GetConstantDesc(fieldHandle, &fieldDescription, &descriptionCount);
-                    ASSERT(SUCCEEDED(result));
-
-                    std::string structIndex = (constantDescription.Elements > 1) ? ("[" + str(arrayIndex) + "]") : "";
-
-                    if(!defineUniform(fieldHandle, fieldDescription, name + constantDescription.Name + structIndex + "."))
-                    {
-                        return false;
-                    }
-                }
-            }
-
-            return true;
-        }
-      case D3DXPC_SCALAR:
-      case D3DXPC_VECTOR:
-      case D3DXPC_MATRIX_COLUMNS:
-      case D3DXPC_OBJECT:
-        return defineUniform(constantDescription, name + constantDescription.Name);
-      default:
-        UNREACHABLE();
-        return false;
-    }
-}
-
-bool Program::defineUniform(const D3DXCONSTANT_DESC &constantDescription, std::string &_name)
-{
-    Uniform *uniform = createUniform(constantDescription, _name);
-
-    if(!uniform)
-    {
-        return false;
-    }
-
-    // Check if already defined
-    GLint location = getUniformLocation(uniform->name);
-    GLenum type = uniform->type;
-
-    if(location >= 0)
-    {
-        delete uniform;
-
-        if(mUniforms[mUniformIndex[location].index]->type != type)
-        {
-            return false;
-        }
-        else
-        {
-            return true;
-        }
-    }
-
-    mUniforms.push_back(uniform);
-    unsigned int uniformIndex = mUniforms.size() - 1;
-
-    for(unsigned int i = 0; i < uniform->arraySize; ++i)
-    {
-        mUniformIndex.push_back(UniformLocation(_name, i, uniformIndex));
-    }
-
-    return true;
-}
-
-Uniform *Program::createUniform(const D3DXCONSTANT_DESC &constantDescription, std::string &_name)
-{
-    if(constantDescription.Rows == 1)   // Vectors and scalars
-    {
-        switch (constantDescription.Type)
-        {
-          case D3DXPT_SAMPLER2D:
-            switch (constantDescription.Columns)
-            {
-              case 1: return new Uniform(GL_SAMPLER_2D, _name, constantDescription.Elements);
-              default: UNREACHABLE();
-            }
-            break;
-          case D3DXPT_SAMPLERCUBE:
-            switch (constantDescription.Columns)
-            {
-              case 1: return new Uniform(GL_SAMPLER_CUBE, _name, constantDescription.Elements);
-              default: UNREACHABLE();
-            }
-            break;
-          case D3DXPT_BOOL:
-            switch (constantDescription.Columns)
-            {
-              case 1: return new Uniform(GL_BOOL, _name, constantDescription.Elements);
-              case 2: return new Uniform(GL_BOOL_VEC2, _name, constantDescription.Elements);
-              case 3: return new Uniform(GL_BOOL_VEC3, _name, constantDescription.Elements);
-              case 4: return new Uniform(GL_BOOL_VEC4, _name, constantDescription.Elements);
-              default: UNREACHABLE();
-            }
-            break;
-          case D3DXPT_INT:
-            switch (constantDescription.Columns)
-            {
-              case 1: return new Uniform(GL_INT, _name, constantDescription.Elements);
-              case 2: return new Uniform(GL_INT_VEC2, _name, constantDescription.Elements);
-              case 3: return new Uniform(GL_INT_VEC3, _name, constantDescription.Elements);
-              case 4: return new Uniform(GL_INT_VEC4, _name, constantDescription.Elements);
-              default: UNREACHABLE();
-            }
-            break;
-          case D3DXPT_FLOAT:
-            switch (constantDescription.Columns)
-            {
-              case 1: return new Uniform(GL_FLOAT, _name, constantDescription.Elements);
-              case 2: return new Uniform(GL_FLOAT_VEC2, _name, constantDescription.Elements);
-              case 3: return new Uniform(GL_FLOAT_VEC3, _name, constantDescription.Elements);
-              case 4: return new Uniform(GL_FLOAT_VEC4, _name, constantDescription.Elements);
-              default: UNREACHABLE();
-            }
-            break;
-          default:
-            UNREACHABLE();
-        }
-    }
-    else if(constantDescription.Rows == constantDescription.Columns)  // Square matrices
-    {
-        switch (constantDescription.Type)
-        {
-          case D3DXPT_FLOAT:
-            switch (constantDescription.Rows)
-            {
-              case 2: return new Uniform(GL_FLOAT_MAT2, _name, constantDescription.Elements);
-              case 3: return new Uniform(GL_FLOAT_MAT3, _name, constantDescription.Elements);
-              case 4: return new Uniform(GL_FLOAT_MAT4, _name, constantDescription.Elements);
-              default: UNREACHABLE();
-            }
-            break;
-          default: UNREACHABLE();
-        }
-    }
-    else UNREACHABLE();
-
-    return 0;
-}
-
-// This method needs to match OutputHLSL::decorate
-std::string Program::decorateAttribute(const std::string &name)
-{
-    if(name.compare(0, 3, "gl_") != 0 && name.compare(0, 3, "dx_") != 0)
-    {
-        return "_" + name;
-    }
-    
-    return name;
-}
-
-std::string Program::undecorateUniform(const std::string &_name)
-{
-    if(_name[0] == '_')
-    {
-        return _name.substr(1);
-    }
-    else if(_name.compare(0, 3, "ar_") == 0)
-    {
-        return _name.substr(3);
-    }
-    
-    return _name;
-}
-
-bool Program::applyUniform1bv(GLint location, GLsizei count, const GLboolean *v)
-{
-	float (*vector)[4] = new float[count][4];
-
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = (v[0] == GL_FALSE ? 0.0f : 1.0f);
-        vector[i][1] = 0;
-		vector[i][2] = 0;
-		vector[i][3] = 0;
-
-        v += 1;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-
-    Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
-
-    if(constantPS)
-    {	
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		
-		if(constantDescription.RegisterSet == D3DXRS_FLOAT4)
+		if(vertexShader)
 		{
-			device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
+			vertexShader->release();
 		}
-		else if(constantDescription.RegisterSet == D3DXRS_BOOL)
+
+		if(fragmentShader)
 		{
-			device->setPixelShaderConstantB(constantDescription.RegisterIndex, (int*)vector, constantDescription.RegisterCount);
+			fragmentShader->release();
+		}
+	}
+
+	bool Program::attachShader(Shader *shader)
+	{
+		if(shader->getType() == GL_VERTEX_SHADER)
+		{
+			if(vertexShader)
+			{
+				return false;
+			}
+
+			vertexShader = (VertexShader*)shader;
+			vertexShader->addRef();
+		}
+		else if(shader->getType() == GL_FRAGMENT_SHADER)
+		{
+			if(fragmentShader)
+			{
+				return false;
+			}
+
+			fragmentShader = (FragmentShader*)shader;
+			fragmentShader->addRef();
 		}
 		else UNREACHABLE();
-    }
 
-    if(constantVS)
-    {
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		
-		if(constantDescription.RegisterSet == D3DXRS_FLOAT4)
+		return true;
+	}
+
+	bool Program::detachShader(Shader *shader)
+	{
+		if(shader->getType() == GL_VERTEX_SHADER)
 		{
-			device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
+			if(vertexShader != shader)
+			{
+				return false;
+			}
+
+			vertexShader->release();
+			vertexShader = 0;
 		}
-		else if(constantDescription.RegisterSet == D3DXRS_BOOL)
+		else if(shader->getType() == GL_FRAGMENT_SHADER)
 		{
-			device->setVertexShaderConstantB(constantDescription.RegisterIndex, (int*)vector, constantDescription.RegisterCount);
+			if(fragmentShader != shader)
+			{
+				return false;
+			}
+
+			fragmentShader->release();
+			fragmentShader = 0;
 		}
 		else UNREACHABLE();
-    }
 
-    delete [] vector;
+		return true;
+	}
 
-    return true;
-}
+	int Program::getAttachedShadersCount() const
+	{
+		return (vertexShader ? 1 : 0) + (fragmentShader ? 1 : 0);
+	}
 
-bool Program::applyUniform2bv(GLint location, GLsizei count, const GLboolean *v)
-{
-    float (*vector)[4] = new float[count][4];
+	sw::PixelShader *Program::getPixelShader()
+	{
+		return pixelBinary;
+	}
 
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = (v[0] == GL_FALSE ? 0.0f : 1.0f);
-        vector[i][1] = (v[1] == GL_FALSE ? 0.0f : 1.0f);
-		vector[i][2] = 0;
-		vector[i][3] = 0;
+	sw::VertexShader *Program::getVertexShader()
+	{
+		return vertexBinary;
+	}
 
-        v += 2;
-    }
+	void Program::bindAttributeLocation(GLuint index, const char *name)
+	{
+		if(index < MAX_VERTEX_ATTRIBS)
+		{
+			for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
+			{
+				attributeBinding[i].erase(name);
+			}
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+			attributeBinding[index].insert(name);
+		}
+	}
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
+	GLuint Program::getAttributeLocation(const char *name)
+	{
+		if(name)
+		{
+			for(int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
+			{
+				if(linkedAttribute[index].name == std::string(name))
+				{
+					return index;
+				}
+			}
+		}
 
-    Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		return -1;
+	}
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
-
-    if(constantVS)
-    {
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
-
-    delete[] vector;
-
-    return true;
-}
-
-bool Program::applyUniform3bv(GLint location, GLsizei count, const GLboolean *v)
-{
-    float (*vector)[4] = new float[count][4];
-
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = (v[0] == GL_FALSE ? 0.0f : 1.0f);
-        vector[i][1] = (v[1] == GL_FALSE ? 0.0f : 1.0f);
-		vector[i][2] = (v[2] == GL_FALSE ? 0.0f : 1.0f);
-		vector[i][3] = 0;
-
-        v += 3;
-    }
-
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
-
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
+	int Program::getAttributeStream(int attributeIndex)
+	{
+		ASSERT(attributeIndex >= 0 && attributeIndex < MAX_VERTEX_ATTRIBS);
     
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		return attributeStream[attributeIndex];
+	}
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+	// Returns the index of the texture image unit (0-19) corresponding to a sampler index (0-15 for the pixel shader and 0-3 for the vertex shader)
+	GLint Program::getSamplerMapping(sw::SamplerType type, unsigned int samplerIndex)
+	{
+		GLuint logicalTextureUnit = -1;
 
-    if(constantVS)
-    {
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		switch(type)
+		{
+		case sw::SAMPLER_PIXEL:
+			ASSERT(samplerIndex < sizeof(samplersPS) / sizeof(samplersPS[0]));
 
-    delete[] vector;
+			if(samplersPS[samplerIndex].active)
+			{
+				logicalTextureUnit = samplersPS[samplerIndex].logicalTextureUnit;
+			}
+			break;
+		case sw::SAMPLER_VERTEX:
+			ASSERT(samplerIndex < sizeof(samplersVS) / sizeof(samplersVS[0]));
 
-    return true;
-}
+			if(samplersVS[samplerIndex].active)
+			{
+				logicalTextureUnit = samplersVS[samplerIndex].logicalTextureUnit;
+			}
+			break;
+		default: UNREACHABLE();
+		}
 
-bool Program::applyUniform4bv(GLint location, GLsizei count, const GLboolean *v)
-{
-    float (*vector)[4] = new float[count][4];
+		if(logicalTextureUnit >= 0 && logicalTextureUnit < MAX_COMBINED_TEXTURE_IMAGE_UNITS)
+		{
+			return logicalTextureUnit;
+		}
 
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = (v[0] == GL_FALSE ? 0.0f : 1.0f);
-        vector[i][1] = (v[1] == GL_FALSE ? 0.0f : 1.0f);
-		vector[i][2] = (v[2] == GL_FALSE ? 0.0f : 1.0f);
-		vector[i][3] = (v[3] == GL_FALSE ? 0.0f : 1.0f);
+		return -1;
+	}
 
-        v += 4;
-    }
+	// Returns the texture type for a given sampler type and index (0-15 for the pixel shader and 0-3 for the vertex shader)
+	TextureType Program::getSamplerTextureType(sw::SamplerType type, unsigned int samplerIndex)
+	{
+		switch(type)
+		{
+		case sw::SAMPLER_PIXEL:
+			ASSERT(samplerIndex < sizeof(samplersPS)/sizeof(samplersPS[0]));
+			ASSERT(samplersPS[samplerIndex].active);
+			return samplersPS[samplerIndex].textureType;
+		case sw::SAMPLER_VERTEX:
+			ASSERT(samplerIndex < sizeof(samplersVS)/sizeof(samplersVS[0]));
+			ASSERT(samplersVS[samplerIndex].active);
+			return samplersVS[samplerIndex].textureType;
+		default: UNREACHABLE();
+		}
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+		return TEXTURE_2D;
+	}
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+	GLint Program::getUniformLocation(std::string name)
+	{
+		int subscript = 0;
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		// Strip any trailing array operator and retrieve the subscript
+		size_t open = name.find_last_of('[');
+		size_t close = name.find_last_of(']');
+		if(open != std::string::npos && close == name.length() - 1)
+		{
+			subscript = atoi(name.substr(open + 1).c_str());
+			name.erase(open);
+		}
 
-    if(constantVS)
-    {
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		unsigned int numUniforms = uniformIndex.size();
+		for(unsigned int location = 0; location < numUniforms; location++)
+		{
+			if(uniformIndex[location].name == name &&
+			   uniformIndex[location].element == subscript)
+			{
+				return location;
+			}
+		}
 
-    delete [] vector;
+		return -1;
+	}
 
-    return true;
-}
+	bool Program::setUniform1fv(GLint location, GLsizei count, const GLfloat* v)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
 
-bool Program::applyUniform1fv(GLint location, GLsizei count, const GLfloat *v)
-{
-	float (*vector)[4] = new float[count][4];
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
 
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = v[0];
-		vector[i][1] = 0;
-		vector[i][2] = 0;
-		vector[i][3] = 0;
+		int size = targetUniform->size();
 
-        v += 1;
-    }
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+	
+		count = std::min(size - (int)uniformIndex[location].element, count);
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+		if(targetUniform->type == GL_FLOAT)
+		{
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat),
+				   v, sizeof(GLfloat) * count);
+		}
+		else if(targetUniform->type == GL_BOOL)
+		{
+			GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element;
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+			for(int i = 0; i < count; i++)
+			{
+				if(v[i] == 0.0f)
+				{
+					boolParams[i] = GL_FALSE;
+				}
+				else
+				{
+					boolParams[i] = GL_TRUE;
+				}
+			}
+		}
+		else
+		{
+			return false;
+		}
 
-    if(constantPS)
-    {	
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		return true;
+	}
 
-    if(constantVS)
-    {
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+	bool Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
 
-	delete[] vector;
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
 
-    return true;
-}
+		int size = targetUniform->size();
 
-bool Program::applyUniform2fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    float (*vector)[4] = new float[count][4];
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+	
+		count = std::min(size - (int)uniformIndex[location].element, count);
 
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = v[0];
-		vector[i][1] = v[1];
-		vector[i][2] = 0;
-		vector[i][3] = 0;
+		if(targetUniform->type == GL_FLOAT_VEC2)
+		{
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 2,
+				   v, 2 * sizeof(GLfloat) * count);
+		}
+		else if(targetUniform->type == GL_BOOL_VEC2)
+		{
+			GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element * 2;
 
-        v += 2;
-    }
+			for(int i = 0; i < count * 2; i++)
+			{
+				if(v[i] == 0.0f)
+				{
+					boolParams[i] = GL_FALSE;
+				}
+				else
+				{
+					boolParams[i] = GL_TRUE;
+				}
+			}
+		}
+		else 
+		{
+			return false;
+		}
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+		return true;
+	}
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+	bool Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
 
-    if(constantVS)
-    {
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		int size = targetUniform->size();
 
-    delete[] vector;
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+	
+		count = std::min(size - (int)uniformIndex[location].element, count);
 
-    return true;
-}
+		if(targetUniform->type == GL_FLOAT_VEC3)
+		{
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 3,
+				   v, 3 * sizeof(GLfloat) * count);
+		}
+		else if(targetUniform->type == GL_BOOL_VEC3)
+		{
+			GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element * 3;
 
-bool Program::applyUniform3fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    float (*vector)[4] = new float[count][4];
+			for(int i = 0; i < count * 3; i++)
+			{
+				if(v[i] == 0.0f)
+				{
+					boolParams[i] = GL_FALSE;
+				}
+				else
+				{
+					boolParams[i] = GL_TRUE;
+				}
+			}
+		}
+		else 
+		{
+			return false;
+		}
 
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = v[0];
-		vector[i][1] = v[1];
-		vector[i][2] = v[2];
-		vector[i][3] = 0;
+		return true;
+	}
 
-        v += 3;
-    }
+	bool Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		int size = targetUniform->size();
+
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+	
+		count = std::min(size - (int)uniformIndex[location].element, count);
+
+		if(targetUniform->type == GL_FLOAT_VEC4)
+		{
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 4,
+				   v, 4 * sizeof(GLfloat) * count);
+		}
+		else if(targetUniform->type == GL_BOOL_VEC4)
+		{
+			GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element * 4;
+
+			for(int i = 0; i < count * 4; i++)
+			{
+				if(v[i] == 0.0f)
+				{
+					boolParams[i] = GL_FALSE;
+				}
+				else
+				{
+					boolParams[i] = GL_TRUE;
+				}
+			}
+		}
+		else 
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Program::setUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
+
+		if(targetUniform->type != GL_FLOAT_MAT2)
+		{
+			return false;
+		}
+
+		int size = targetUniform->size();
+
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+
+		count = std::min(size - (int)uniformIndex[location].element, count);
+
+		memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 4,
+			   value, 4 * sizeof(GLfloat) * count);
+
+		return true;
+	}
+
+	bool Program::setUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
+
+		if(targetUniform->type != GL_FLOAT_MAT3)
+		{
+			return false;
+		}
+
+		int size = targetUniform->size();
+
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+
+		count = std::min(size - (int)uniformIndex[location].element, count);
+
+		memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 9,
+			   value, 9 * sizeof(GLfloat) * count);
+
+		return true;
+	}
+
+	bool Program::setUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
+
+		if(targetUniform->type != GL_FLOAT_MAT4)
+		{
+			return false;
+		}
+
+		int size = targetUniform->size();
+
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+
+		count = std::min(size - (int)uniformIndex[location].element, count);
+
+		memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLfloat) * 16,
+			   value, 16 * sizeof(GLfloat) * count);
+
+		return true;
+	}
+
+	bool Program::setUniform1iv(GLint location, GLsizei count, const GLint *v)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
+
+		int size = targetUniform->size();
+
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+	
+		count = std::min(size - (int)uniformIndex[location].element, count);
+
+		if(targetUniform->type == GL_INT ||
+		   targetUniform->type == GL_SAMPLER_2D ||
+		   targetUniform->type == GL_SAMPLER_CUBE)
+		{
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLint),
+				   v, sizeof(GLint) * count);
+		}
+		else if(targetUniform->type == GL_BOOL)
+		{
+			GLboolean *boolParams = new GLboolean[count];
+
+			for(int i = 0; i < count; i++)
+			{
+				if(v[i] == 0)
+				{
+					boolParams[i] = GL_FALSE;
+				}
+				else
+				{
+					boolParams[i] = GL_TRUE;
+				}
+			}
+
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLboolean),
+				   boolParams, sizeof(GLboolean) * count);
+
+			delete[] boolParams;
+		}
+		else
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Program::setUniform2iv(GLint location, GLsizei count, const GLint *v)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
+
+		int size = targetUniform->size();
+
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+	
+		count = std::min(size - (int)uniformIndex[location].element, count);
+
+		if(targetUniform->type == GL_INT_VEC2)
+		{
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLint) * 2,
+				   v, 2 * sizeof(GLint) * count);
+		}
+		else if(targetUniform->type == GL_BOOL_VEC2)
+		{
+			GLboolean *boolParams = new GLboolean[count * 2];
+
+			for(int i = 0; i < count * 2; i++)
+			{
+				if(v[i] == 0)
+				{
+					boolParams[i] = GL_FALSE;
+				}
+				else
+				{
+					boolParams[i] = GL_TRUE;
+				}
+			}
+
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLboolean) * 2,
+				   boolParams, 2 * sizeof(GLboolean) * count);
+
+			delete[] boolParams;
+		}
+		else
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Program::setUniform3iv(GLint location, GLsizei count, const GLint *v)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
+
+		int size = targetUniform->size();
+
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+	
+		count = std::min(size - (int)uniformIndex[location].element, count);
+
+		if(targetUniform->type == GL_INT_VEC3)
+		{
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLint) * 3,
+				   v, 3 * sizeof(GLint) * count);
+		}
+		else if(targetUniform->type == GL_BOOL_VEC3)
+		{
+			GLboolean *boolParams = new GLboolean[count * 3];
+
+			for(int i = 0; i < count * 3; i++)
+			{
+				if(v[i] == 0)
+				{
+					boolParams[i] = GL_FALSE;
+				}
+				else
+				{
+					boolParams[i] = GL_TRUE;
+				}
+			}
+
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLboolean) * 3,
+				   boolParams, 3 * sizeof(GLboolean) * count);
+
+			delete[] boolParams;
+		}
+		else
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Program::setUniform4iv(GLint location, GLsizei count, const GLint *v)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		targetUniform->dirty = true;
+
+		int size = targetUniform->size();
+
+		if(size == 1 && count > 1)
+		{
+			return false;   // Attempting to write an array to a non-array uniform is an INVALID_OPERATION
+		}
+	
+		count = std::min(size - (int)uniformIndex[location].element, count);
+
+		if(targetUniform->type == GL_INT_VEC4)
+		{
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLint) * 4,
+				   v, 4 * sizeof(GLint) * count);
+		}
+		else if(targetUniform->type == GL_BOOL_VEC4)
+		{
+			GLboolean *boolParams = new GLboolean[count * 4];
+
+			for(int i = 0; i < count * 4; i++)
+			{
+				if(v[i] == 0)
+				{
+					boolParams[i] = GL_FALSE;
+				}
+				else
+				{
+					boolParams[i] = GL_TRUE;
+				}
+			}
+
+			memcpy(targetUniform->data + uniformIndex[location].element * sizeof(GLboolean) * 4,
+				   boolParams, 4 * sizeof(GLboolean) * count);
+
+			delete[] boolParams;
+		}
+		else
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Program::getUniformfv(GLint location, GLsizei *bufSize, GLfloat *params)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		unsigned int count = UniformComponentCount(targetUniform->type);
+
+		// Sized query - ensure the provided buffer is large enough
+		if(bufSize && *bufSize < count * sizeof(GLfloat))
+		{
+			return false;
+		}
+
+		switch (UniformComponentType(targetUniform->type))
+		{
+		  case GL_BOOL:
+			{
+				GLboolean *boolParams = (GLboolean*)targetUniform->data + uniformIndex[location].element * count;
+
+				for(unsigned int i = 0; i < count; i++)
+				{
+					params[i] = (boolParams[i] == GL_FALSE) ? 0.0f : 1.0f;
+				}
+			}
+			break;
+		  case GL_FLOAT:
+			memcpy(params, targetUniform->data + uniformIndex[location].element * count * sizeof(GLfloat),
+				   count * sizeof(GLfloat));
+			break;
+		  case GL_INT:
+			{
+				GLint *intParams = (GLint*)targetUniform->data + uniformIndex[location].element * count;
+
+				for(unsigned int i = 0; i < count; i++)
+				{
+					params[i] = (float)intParams[i];
+				}
+			}
+			break;
+		  default: UNREACHABLE();
+		}
+
+		return true;
+	}
+
+	bool Program::getUniformiv(GLint location, GLsizei *bufSize, GLint *params)
+	{
+		if(location < 0 || location >= (int)uniformIndex.size())
+		{
+			return false;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+		unsigned int count = UniformComponentCount(targetUniform->type);
+
+		// Sized query - ensure the provided buffer is large enough
+		if(bufSize && *bufSize < count * sizeof(GLint))
+		{
+			return false;
+		}
+
+		switch (UniformComponentType(targetUniform->type))
+		{
+		  case GL_BOOL:
+			{
+				GLboolean *boolParams = targetUniform->data + uniformIndex[location].element * count;
+
+				for(unsigned int i = 0; i < count; i++)
+				{
+					params[i] = (GLint)boolParams[i];
+				}
+			}
+			break;
+		  case GL_FLOAT:
+			{
+				GLfloat *floatParams = (GLfloat*)targetUniform->data + uniformIndex[location].element * count;
+
+				for(unsigned int i = 0; i < count; i++)
+				{
+					params[i] = (GLint)floatParams[i];
+				}
+			}
+			break;
+		  case GL_INT:
+			memcpy(params, targetUniform->data + uniformIndex[location].element * count * sizeof(GLint),
+				   count * sizeof(GLint));
+			break;
+		  default: UNREACHABLE();
+		}
+
+		return true;
+	}
+
+	void Program::dirtyAllUniforms()
+	{
+		unsigned int numUniforms = uniforms.size();
+		for(unsigned int index = 0; index < numUniforms; index++)
+		{
+			uniforms[index]->dirty = true;
+		}
+	}
+
+	// Applies all the uniforms set for this program object to the device
+	void Program::applyUniforms()
+	{
+		unsigned int numUniforms = uniformIndex.size();
+		for(unsigned int location = 0; location < numUniforms; location++)
+		{
+			if(uniformIndex[location].element != 0)
+			{
+				continue;
+			}
+
+			Uniform *targetUniform = uniforms[uniformIndex[location].index];
+
+			if(targetUniform->dirty)
+			{
+				int size = targetUniform->size();
+				GLfloat *f = (GLfloat*)targetUniform->data;
+				GLint *i = (GLint*)targetUniform->data;
+				GLboolean *b = (GLboolean*)targetUniform->data;
+
+				switch(targetUniform->type)
+				{
+				  case GL_BOOL:       applyUniform1bv(location, size, b);       break;
+				  case GL_BOOL_VEC2:  applyUniform2bv(location, size, b);       break;
+				  case GL_BOOL_VEC3:  applyUniform3bv(location, size, b);       break;
+				  case GL_BOOL_VEC4:  applyUniform4bv(location, size, b);       break;
+				  case GL_FLOAT:      applyUniform1fv(location, size, f);       break;
+				  case GL_FLOAT_VEC2: applyUniform2fv(location, size, f);       break;
+				  case GL_FLOAT_VEC3: applyUniform3fv(location, size, f);       break;
+				  case GL_FLOAT_VEC4: applyUniform4fv(location, size, f);       break;
+				  case GL_FLOAT_MAT2: applyUniformMatrix2fv(location, size, f); break;
+				  case GL_FLOAT_MAT3: applyUniformMatrix3fv(location, size, f); break;
+				  case GL_FLOAT_MAT4: applyUniformMatrix4fv(location, size, f); break;
+				  case GL_SAMPLER_2D:
+				  case GL_SAMPLER_CUBE:
+				  case GL_INT:        applyUniform1iv(location, size, i);       break;
+				  case GL_INT_VEC2:   applyUniform2iv(location, size, i);       break;
+				  case GL_INT_VEC3:   applyUniform3iv(location, size, i);       break;
+				  case GL_INT_VEC4:   applyUniform4iv(location, size, i);       break;
+				  default:
+					UNREACHABLE();
+				}
+
+				targetUniform->dirty = false;
+			}
+		}
+	}
+
+	// Packs varyings into generic varying registers, using the algorithm from [OpenGL ES Shading Language 1.00 rev. 17] appendix A section 7 page 111
+	// Returns the number of used varying registers, or -1 if unsuccesful
+	int Program::packVaryings(const Varying *packing[][4])
+	{
+		Context *context = getContext();
+
+		for(VaryingList::iterator varying = fragmentShader->varyings.begin(); varying != fragmentShader->varyings.end(); varying++)
+		{
+			int n = VariableRowCount(varying->type) * varying->size();
+			int m = VariableColumnCount(varying->type);
+			bool success = false;
+
+			if(m == 2 || m == 3 || m == 4)
+			{
+				for(int r = 0; r <= MAX_VARYING_VECTORS - n && !success; r++)
+				{
+					bool available = true;
+
+					for(int y = 0; y < n && available; y++)
+					{
+						for(int x = 0; x < m && available; x++)
+						{
+							if(packing[r + y][x])
+							{
+								available = false;
+							}
+						}
+					}
+
+					if(available)
+					{
+						varying->reg = r;
+						varying->col = 0;
+
+						for(int y = 0; y < n; y++)
+						{
+							for(int x = 0; x < m; x++)
+							{
+								packing[r + y][x] = &*varying;
+							}
+						}
+
+						success = true;
+					}
+				}
+
+				if(!success && m == 2)
+				{
+					for(int r = MAX_VARYING_VECTORS - n; r >= 0 && !success; r--)
+					{
+						bool available = true;
+
+						for(int y = 0; y < n && available; y++)
+						{
+							for(int x = 2; x < 4 && available; x++)
+							{
+								if(packing[r + y][x])
+								{
+									available = false;
+								}
+							}
+						}
+
+						if(available)
+						{
+							varying->reg = r;
+							varying->col = 2;
+
+							for(int y = 0; y < n; y++)
+							{
+								for(int x = 2; x < 4; x++)
+								{
+									packing[r + y][x] = &*varying;
+								}
+							}
+
+							success = true;
+						}
+					}
+				}
+			}
+			else if(m == 1)
+			{
+				int space[4] = {0};
+
+				for(int y = 0; y < MAX_VARYING_VECTORS; y++)
+				{
+					for(int x = 0; x < 4; x++)
+					{
+						space[x] += packing[y][x] ? 0 : 1;
+					}
+				}
+
+				int column = 0;
+
+				for(int x = 0; x < 4; x++)
+				{
+					if(space[x] >= n && space[x] < space[column])
+					{
+						column = x;
+					}
+				}
+
+				if(space[column] >= n)
+				{
+					for(int r = 0; r < MAX_VARYING_VECTORS; r++)
+					{
+						if(!packing[r][column])
+						{
+							varying->reg = r;
+
+							for(int y = r; y < r + n; y++)
+							{
+								packing[y][column] = &*varying;
+							}
+
+							break;
+						}
+					}
+
+					varying->col = column;
+
+					success = true;
+				}
+			}
+			else UNREACHABLE();
+
+			if(!success)
+			{
+				appendToInfoLog("Could not pack varying %s", varying->name.c_str());
+
+				return -1;
+			}
+		}
+
+		// Return the number of used registers
+		int registers = 0;
+
+		for(int r = 0; r < MAX_VARYING_VECTORS; r++)
+		{
+			if(packing[r][0] || packing[r][1] || packing[r][2] || packing[r][3])
+			{
+				registers++;
+			}
+		}
+
+		return registers;
+	}
+
+	bool Program::linkVaryings()
+	{
+		Context *context = getContext();
+
+		for(VaryingList::iterator input = fragmentShader->varyings.begin(); input != fragmentShader->varyings.end(); input++)
+		{
+			bool matched = false;
+
+			for(VaryingList::iterator output = vertexShader->varyings.begin(); output != vertexShader->varyings.end(); output++)
+			{
+				if(output->name == input->name)
+				{
+					if(output->type != input->type || output->size() != input->size())
+					{
+						appendToInfoLog("Type of vertex varying %s does not match that of the fragment varying", output->name.c_str());
+
+						return false;
+					}
+
+					matched = true;
+					break;
+				}
+			}
+
+			if(!matched)
+			{
+				appendToInfoLog("Fragment varying %s does not match any vertex varying", input->name.c_str());
+
+				return false;
+			}
+		}
+
+		VaryingList &psVaryings = fragmentShader->varyings;
+		VaryingList &vsVaryings = vertexShader->varyings;
+
+		for(VaryingList::iterator output = vsVaryings.begin(); output != vsVaryings.end(); output++)
+		{
+			for(VaryingList::iterator input = psVaryings.begin(); input != psVaryings.end(); input++)
+			{
+				if(output->name == input->name)
+				{
+					int in = input->reg;
+					int out = output->reg;
+					int components = VariableColumnCount(output->type);
+					int registers = VariableRowCount(output->type) * output->size();
+
+					ASSERT(in >= 0 && out >= 0);
+
+					for(int i = 0; i < registers; i++)
+					{
+						if(components >= 1) vertexBinary->output[out + i][0] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, in + i);
+						if(components >= 2) vertexBinary->output[out + i][1] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, in + i);
+						if(components >= 3) vertexBinary->output[out + i][2] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, in + i);
+						if(components >= 4) vertexBinary->output[out + i][3] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, in + i);
+					}
+
+					break;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	// Links the code of the vertex and pixel shader by matching up their varyings,
+	// compiling them into binaries, determining the attribute mappings, and collecting
+	// a list of uniforms
+	void Program::link()
+	{
+		unlink();
+
+		if(!fragmentShader || !fragmentShader->isCompiled())
+		{
+			return;
+		}
+
+		if(!vertexShader || !vertexShader->isCompiled())
+		{
+			return;
+		}
+
+		vertexBinary = new sw::VertexShader(vertexShader->getVertexShader());
+		pixelBinary = new sw::PixelShader(fragmentShader->getPixelShader());
+			
+		if(!linkVaryings())
+		{
+			return;
+		}
+
+		if(!linkAttributes())
+		{
+			return;
+		}
+
+		if(!linkUniforms(fragmentShader))
+		{
+			return;
+		}
+
+		if(!linkUniforms(vertexShader))
+		{
+			return;
+		}
+
+		linked = true;   // Success
+	}
+
+	// Determines the mapping between GL attributes and vertex stream usage indices
+	bool Program::linkAttributes()
+	{
+		unsigned int usedLocations = 0;
+
+		// Link attributes that have a binding location
+		for(sh::ActiveAttributes::iterator attribute = vertexShader->activeAttributes.begin(); attribute != vertexShader->activeAttributes.end(); attribute++)
+		{
+			int location = getAttributeBinding(attribute->name);
+
+			if(location != -1)   // Set by glBindAttribLocation
+			{
+				if(!linkedAttribute[location].name.empty())
+				{
+					// Multiple active attributes bound to the same location; not an error
+				}
+
+				linkedAttribute[location] = *attribute;
+
+				int rows = VariableRowCount(attribute->type);
+
+				if(rows + location > MAX_VERTEX_ATTRIBS)
+				{
+					appendToInfoLog("Active attribute (%s) at location %d is too big to fit", attribute->name.c_str(), location);
+
+					return false;
+				}
+
+				for(int i = 0; i < rows; i++)
+				{
+					usedLocations |= 1 << (location + i);
+				}
+			}
+		}
+
+		// Link attributes that don't have a binding location
+		for(sh::ActiveAttributes::iterator attribute = vertexShader->activeAttributes.begin(); attribute != vertexShader->activeAttributes.end(); attribute++)
+		{
+			int location = getAttributeBinding(attribute->name);
+
+			if(location == -1)   // Not set by glBindAttribLocation
+			{
+				int rows = VariableRowCount(attribute->type);
+				int availableIndex = AllocateFirstFreeBits(&usedLocations, rows, MAX_VERTEX_ATTRIBS);
+
+				if(availableIndex == -1 || availableIndex + rows > MAX_VERTEX_ATTRIBS)
+				{
+					appendToInfoLog("Too many active attributes (%s)", attribute->name.c_str());
+
+					return false;   // Fail to link
+				}
+
+				linkedAttribute[availableIndex] = *attribute;
+			}
+		}
+
+		for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; )
+		{
+			int index = vertexShader->getSemanticIndex(linkedAttribute[attributeIndex].name);
+			int rows = std::max(VariableRowCount(linkedAttribute[attributeIndex].type), 1);
+
+			for(int r = 0; r < rows; r++)
+			{
+				attributeStream[attributeIndex++] = index++;
+			}
+		}
+
+		return true;
+	}
+
+	int Program::getAttributeBinding(const std::string &name)
+	{
+		for(int location = 0; location < MAX_VERTEX_ATTRIBS; location++)
+		{
+			if(attributeBinding[location].find(name) != attributeBinding[location].end())
+			{
+				return location;
+			}
+		}
+
+		return -1;
+	}
+
+	bool Program::linkUniforms(Shader *shader)
+	{
+		const sh::ActiveUniforms &activeUniforms = shader->activeUniforms;
+
+		for(unsigned int uniformIndex = 0; uniformIndex < activeUniforms.size(); uniformIndex++)
+		{
+			const sh::Uniform &uniform = activeUniforms[uniformIndex];
+
+			if(!defineUniform(shader->getType(), uniform.type, uniform.name, uniform.arraySize, uniform.registerIndex))
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	bool Program::defineUniform(GLenum shader, GLenum type, const std::string &name, unsigned int arraySize, int registerIndex)
+	{
+		if(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE)
+	    {
+			int index = registerIndex;
+			
+			do
+			{
+				if(shader == GL_VERTEX_SHADER)
+				{
+					if(index < MAX_VERTEX_TEXTURE_IMAGE_UNITS)
+					{
+						samplersVS[index].active = true;
+						samplersVS[index].textureType = (type == GL_SAMPLER_CUBE) ? TEXTURE_CUBE : TEXTURE_2D;
+						samplersVS[index].logicalTextureUnit = 0;
+					}
+					else
+					{
+					   appendToInfoLog("Vertex shader sampler count exceeds MAX_VERTEX_TEXTURE_IMAGE_UNITS (%d).", MAX_VERTEX_TEXTURE_IMAGE_UNITS);
+					   return false;
+					}
+				}
+				else if(shader == GL_FRAGMENT_SHADER)
+				{
+					if(index < MAX_TEXTURE_IMAGE_UNITS)
+					{
+						samplersPS[index].active = true;
+						samplersPS[index].textureType = (type == GL_SAMPLER_CUBE) ? TEXTURE_CUBE : TEXTURE_2D;
+						samplersPS[index].logicalTextureUnit = 0;
+					}
+					else
+					{
+						appendToInfoLog("Pixel shader sampler count exceeds MAX_TEXTURE_IMAGE_UNITS (%d).", MAX_TEXTURE_IMAGE_UNITS);
+						return false;
+					}
+				}
+				else UNREACHABLE();
+
+				index++;
+			}
+			while(index < registerIndex + arraySize);
+	    }
+
+		Uniform *uniform = 0;
+		GLint location = getUniformLocation(name);
+
+		if(location >= 0)   // Previously defined, types must match
+		{
+			uniform = uniforms[uniformIndex[location].index];
+
+			if(uniform->type != type)
+			{
+				return false;
+			}
+		}
+		else
+		{
+			uniform = new Uniform(type, name, arraySize);
+		}
+
+		if(!uniform)
+		{
+			return false;
+		}
+
+		if(shader == GL_VERTEX_SHADER)
+		{
+			uniform->vsRegisterIndex = registerIndex;
+		}
+		else if(shader == GL_FRAGMENT_SHADER)
+		{
+			uniform->psRegisterIndex = registerIndex;
+		}
+		else UNREACHABLE();
+
+		if(location == -1)   // Not previously defined
+		{
+			uniforms.push_back(uniform);
+			unsigned int index = uniforms.size() - 1;
+
+			for(unsigned int i = 0; i < uniform->size(); i++)
+			{
+				uniformIndex.push_back(UniformLocation(name, i, index));
+			}
+		}
+
+		return true;
+	}
+
+	bool Program::applyUniform1bv(GLint location, GLsizei count, const GLboolean *v)
+	{
+		int vector[MAX_UNIFORM_VECTORS][4];
+
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = (v[0] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+			vector[i][1] = 0;
+			vector[i][2] = 0;
+			vector[i][3] = 0;
+
+			v += 1;
+		}
+
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    if(constantVS)
-    {
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		return true;
+	}
 
-    delete[] vector;
+	bool Program::applyUniform2bv(GLint location, GLsizei count, const GLboolean *v)
+	{
+		int vector[MAX_UNIFORM_VECTORS][4];
 
-    return true;
-}
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = (v[0] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+			vector[i][1] = (v[1] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+			vector[i][2] = 0;
+			vector[i][3] = 0;
 
-bool Program::applyUniform4fv(GLint location, GLsizei count, const GLfloat *v)
-{
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+			v += 2;
+		}
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)v, constantDescription.RegisterCount);
-    }
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    if(constantVS)
-    {
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)v, constantDescription.RegisterCount);
-    }
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    return true;
-}
+		return true;
+	}
 
-bool Program::applyUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    float (*matrix)[2][4] = new float[count][2][4];
+	bool Program::applyUniform3bv(GLint location, GLsizei count, const GLboolean *v)
+	{
+		int vector[MAX_UNIFORM_VECTORS][4];
 
-    for(int i = 0; i < count; i++)
-    {
-        matrix[i][0][0] = value[0];	matrix[i][0][1] = value[2];	matrix[i][0][2] = 0; matrix[i][0][3] = 0;
-		matrix[i][1][0] = value[1];	matrix[i][1][1] = value[3];	matrix[i][1][2] = 0; matrix[i][1][3] = 0;
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = (v[0] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+			vector[i][1] = (v[1] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+			vector[i][2] = (v[2] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+			vector[i][3] = 0;
 
-        value += 4;
-    }
+			v += 3;
+		}
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
-    }
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    if(constantVS)
-    {	
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
-    }
+		return true;
+	}
 
-    delete[] matrix;
+	bool Program::applyUniform4bv(GLint location, GLsizei count, const GLboolean *v)
+	{
+		int vector[MAX_UNIFORM_VECTORS][4];
 
-    return true;
-}
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = (v[0] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+			vector[i][1] = (v[1] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+			vector[i][2] = (v[2] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
+			vector[i][3] = (v[3] == GL_FALSE ? 0x00000000 : 0xFFFFFFFF);
 
-bool Program::applyUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value)
-{
-    float (*matrix)[3][4] = new float[count][3][4];
+			v += 4;
+		}
 
-    for(int i = 0; i < count; i++)
-    {
-        matrix[i][0][0] = value[0];	matrix[i][0][1] = value[3];	matrix[i][0][2] = value[6];	matrix[i][0][3] = 0;
-		matrix[i][1][0] = value[1];	matrix[i][1][1] = value[4];	matrix[i][1][2] = value[7];	matrix[i][1][3] = 0;
-		matrix[i][2][0] = value[2];	matrix[i][2][1] = value[5];	matrix[i][2][2] = value[8];	matrix[i][2][3] = 0;
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-        value += 9;
-    }
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		return true;
+	}
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
-    }
+	bool Program::applyUniform1fv(GLint location, GLsizei count, const GLfloat *v)
+	{
+		float vector[MAX_UNIFORM_VECTORS][4];
 
-    if(constantVS)
-    {	
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
-    }
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = v[0];
+			vector[i][1] = 0;
+			vector[i][2] = 0;
+			vector[i][3] = 0;
 
-    delete[] matrix;
+			v += 1;
+		}
 
-    return true;
-}
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-bool Program::applyUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value)
-{
-	float (*matrix)[4][4] = new float[count][4][4];
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    for(int i = 0; i < count; i++)
-    {
-        matrix[i][0][0] = value[0]; matrix[i][0][1] = value[4];	matrix[i][0][2] = value[8];  matrix[i][0][3] = value[12];
-		matrix[i][1][0] = value[1];	matrix[i][1][1] = value[5];	matrix[i][1][2] = value[9];	 matrix[i][1][3] = value[13];
-		matrix[i][2][0] = value[2];	matrix[i][2][1] = value[6];	matrix[i][2][2] = value[10]; matrix[i][2][3] = value[14];
-		matrix[i][3][0] = value[3];	matrix[i][3][1] = value[7];	matrix[i][3][2] = value[11]; matrix[i][3][3] = value[15];
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-        value += 16;
-    }
+		return true;
+	}
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+	bool Program::applyUniform2fv(GLint location, GLsizei count, const GLfloat *v)
+	{
+		float vector[MAX_UNIFORM_VECTORS][4];
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = v[0];
+			vector[i][1] = v[1];
+			vector[i][2] = 0;
+			vector[i][3] = 0;
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
-    }
+			v += 2;
+		}
 
-    if(constantVS)
-    {	
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)matrix, constantDescription.RegisterCount);
-    }
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-    delete[] matrix;
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    return true;
-}
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-bool Program::applyUniform1iv(GLint location, GLsizei count, const GLint *v)
-{
-	float (*vector)[4] = new float[count][4];
+		return true;
+	}
 
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = (float)v[i];
-		vector[i][1] = 0;
-		vector[i][2] = 0;
-		vector[i][3] = 0;
-    }
+	bool Program::applyUniform3fv(GLint location, GLsizei count, const GLfloat *v)
+	{
+		float vector[MAX_UNIFORM_VECTORS][4];
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = v[0];
+			vector[i][1] = v[1];
+			vector[i][2] = v[2];
+			vector[i][3] = 0;
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    Device *device = getDevice();
+			v += 3;
+		}
 
-    if(constantPS)
-    {
-        D3DXCONSTANT_DESC constantDescription;
-        UINT descriptionCount = 1;
-        HRESULT result = mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-        ASSERT(SUCCEEDED(result));
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-        if(constantDescription.RegisterSet == D3DXRS_SAMPLER)
-        {
-            unsigned int firstIndex = mConstantTablePS->GetSamplerIndex(constantPS);
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-            for(int i = 0; i < count; i++)
-            {
-                unsigned int samplerIndex = firstIndex + i;
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-                if(samplerIndex < MAX_TEXTURE_IMAGE_UNITS)
-                {
-                    ASSERT(mSamplersPS[samplerIndex].active);
-                    mSamplersPS[samplerIndex].logicalTextureUnit = v[i];
-                }
-            }
-        }
-        else
-        {
-			ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-			device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-        }
-    }
+		return true;
+	}
 
-    if(constantVS)
-    {
-        D3DXCONSTANT_DESC constantDescription;
-        UINT descriptionCount = 1;
-        HRESULT result = mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-        ASSERT(SUCCEEDED(result));
+	bool Program::applyUniform4fv(GLint location, GLsizei count, const GLfloat *v)
+	{
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-        if(constantDescription.RegisterSet == D3DXRS_SAMPLER)
-        {
-            unsigned int firstIndex = mConstantTableVS->GetSamplerIndex(constantVS);
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)v, targetUniform->registerCount());
+		}
 
-            for(int i = 0; i < count; i++)
-            {
-                unsigned int samplerIndex = firstIndex + i;
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)v, targetUniform->registerCount());
+		}
 
-                if(samplerIndex < MAX_VERTEX_TEXTURE_IMAGE_UNITS)
-                {
-                    ASSERT(mSamplersVS[samplerIndex].active);
-                    mSamplersVS[samplerIndex].logicalTextureUnit = v[i];
-                }
-            }
-        }
-        else
-        {
-			ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-			device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-        }
-    }
+		return true;
+	}
 
-	delete[] vector;
+	bool Program::applyUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value)
+	{
+		float matrix[(MAX_UNIFORM_VECTORS + 1) / 2][2][4];
 
-    return true;
-}
+		for(int i = 0; i < count; i++)
+		{
+			matrix[i][0][0] = value[0];	matrix[i][0][1] = value[1];	matrix[i][0][2] = 0; matrix[i][0][3] = 0;
+			matrix[i][1][0] = value[2];	matrix[i][1][1] = value[3];	matrix[i][1][2] = 0; matrix[i][1][3] = 0;
 
-bool Program::applyUniform2iv(GLint location, GLsizei count, const GLint *v)
-{
-    float (*vector)[4] = new float[count][4];
+			value += 4;
+		}
 
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = (float)v[0];
-		vector[i][1] = (float)v[1];
-		vector[i][2] = 0;
-		vector[i][3] = 0;
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-        v += 2;
-    }
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)matrix, targetUniform->registerCount());
+		}
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)matrix, targetUniform->registerCount());
+		}
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		return true;
+	}
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+	bool Program::applyUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value)
+	{
+		float matrix[(MAX_UNIFORM_VECTORS + 2) / 3][3][4];
 
-    if(constantVS)
-    {	
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		for(int i = 0; i < count; i++)
+		{
+			matrix[i][0][0] = value[0];	matrix[i][0][1] = value[1];	matrix[i][0][2] = value[2];	matrix[i][0][3] = 0;
+			matrix[i][1][0] = value[3];	matrix[i][1][1] = value[4];	matrix[i][1][2] = value[5];	matrix[i][1][3] = 0;
+			matrix[i][2][0] = value[6];	matrix[i][2][1] = value[7];	matrix[i][2][2] = value[8];	matrix[i][2][3] = 0;
 
-    delete[] vector;
+			value += 9;
+		}
 
-    return true;
-}
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-bool Program::applyUniform3iv(GLint location, GLsizei count, const GLint *v)
-{
-    float (*vector)[4] = new float[count][4];
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)matrix, targetUniform->registerCount());
+		}
 
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = (float)v[0];
-		vector[i][1] = (float)v[1];
-		vector[i][2] = (float)v[2];
-		vector[i][3] = 0;
+		if(targetUniform->vsRegisterIndex != -1)
+		{	
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)matrix, targetUniform->registerCount());
+		}
 
-        v += 3;
-    }
+		return true;
+	}
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+	bool Program::applyUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value)
+	{
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
+	
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)value, targetUniform->registerCount());
+		}
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)value, targetUniform->registerCount());
+		}
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		return true;
+	}
 
-    if(constantVS)
-    {	
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		ASSERT(constantDescription.RegisterSet == D3DXRS_FLOAT4);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+	bool Program::applyUniform1iv(GLint location, GLsizei count, const GLint *v)
+	{
+		float vector[MAX_UNIFORM_VECTORS][4];
 
-    delete[] vector;
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = (float)v[i];
+			vector[i][1] = 0;
+			vector[i][2] = 0;
+			vector[i][3] = 0;
+		}
 
-    return true;
-}
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-bool Program::applyUniform4iv(GLint location, GLsizei count, const GLint *v)
-{
-    float (*vector)[4] = new float[count][4];
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			if(targetUniform->type == GL_SAMPLER_2D ||
+			   targetUniform->type == GL_SAMPLER_CUBE)
+			{
+				for(int i = 0; i < count; i++)
+				{
+					unsigned int samplerIndex = targetUniform->psRegisterIndex + i;
 
-    for(int i = 0; i < count; i++)
-    {
-        vector[i][0] = (float)v[0];
-		vector[i][1] = (float)v[1];
-		vector[i][2] = (float)v[2];
-		vector[i][3] = (float)v[3];
+					if(samplerIndex < MAX_TEXTURE_IMAGE_UNITS)
+					{
+						ASSERT(samplersPS[samplerIndex].active);
+						samplersPS[samplerIndex].logicalTextureUnit = v[i];
+					}
+				}
+			}
+			else
+			{
+				device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+			}
+		}
 
-        v += 4;
-    }
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			if(targetUniform->type == GL_SAMPLER_2D ||
+			   targetUniform->type == GL_SAMPLER_CUBE)
+			{
+				for(int i = 0; i < count; i++)
+				{
+					unsigned int samplerIndex = targetUniform->vsRegisterIndex + i;
 
-    Uniform *targetUniform = mUniforms[mUniformIndex[location].index];
+					if(samplerIndex < MAX_VERTEX_TEXTURE_IMAGE_UNITS)
+					{
+						ASSERT(samplersVS[samplerIndex].active);
+						samplersVS[samplerIndex].logicalTextureUnit = v[i];
+					}
+				}
+			}
+			else
+			{
+				device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+			}
+		}
 
-    D3DXHANDLE constantPS;
-    D3DXHANDLE constantVS;
-    getConstantHandles(targetUniform, &constantPS, &constantVS);
-    
-	Device *device = getDevice();
-	D3DXCONSTANT_DESC constantDescription;
-    UINT descriptionCount = 1;
+		return true;
+	}
 
-    if(constantPS)
-    {
-		mConstantTablePS->GetConstantDesc(constantPS, &constantDescription, &descriptionCount);
-		device->setPixelShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+	bool Program::applyUniform2iv(GLint location, GLsizei count, const GLint *v)
+	{
+		float vector[MAX_UNIFORM_VECTORS][4];
 
-    if(constantVS)
-    {	
-		mConstantTableVS->GetConstantDesc(constantVS, &constantDescription, &descriptionCount);
-		device->setVertexShaderConstantF(constantDescription.RegisterIndex, (float*)vector, constantDescription.RegisterCount);
-    }
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = (float)v[0];
+			vector[i][1] = (float)v[1];
+			vector[i][2] = 0;
+			vector[i][3] = 0;
 
-    delete [] vector;
+			v += 2;
+		}
 
-    return true;
-}
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-// append a santized message to the program info log.
-// The D3D compiler includes a fake file path in some of the warning or error 
-// messages, so lets remove all occurrences of this fake file path from the log.
-void Program::appendToInfoLogSanitized(const char *message)
-{
-    std::string msg(message);
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    size_t found;
-    do
-    {
-        found = msg.find(fakepath);
-        if(found != std::string::npos)
-        {
-            msg.erase(found, strlen(fakepath));
-        }
-    }
-    while(found != std::string::npos);
+		return true;
+	}
 
-    appendToInfoLog("%s\n", msg.c_str());
-}
+	bool Program::applyUniform3iv(GLint location, GLsizei count, const GLint *v)
+	{
+		float vector[MAX_UNIFORM_VECTORS][4];
 
-void Program::appendToInfoLog(const char *format, ...)
-{
-    if(!format)
-    {
-        return;
-    }
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = (float)v[0];
+			vector[i][1] = (float)v[1];
+			vector[i][2] = (float)v[2];
+			vector[i][3] = 0;
 
-    char info[1024];
+			v += 3;
+		}
 
-    va_list vararg;
-    va_start(vararg, format);
-    vsnprintf(info, sizeof(info), format, vararg);
-    va_end(vararg);
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-    size_t infoLength = strlen(info);
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    if(!mInfoLog)
-    {
-        mInfoLog = new char[infoLength + 1];
-        strcpy(mInfoLog, info);
-    }
-    else
-    {
-        size_t logLength = strlen(mInfoLog);
-        char *newLog = new char[logLength + infoLength + 1];
-        strcpy(newLog, mInfoLog);
-        strcpy(newLog + logLength, info);
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-        delete[] mInfoLog;
-        mInfoLog = newLog;
-    }
-}
+		return true;
+	}
 
-void Program::resetInfoLog()
-{
-    if(mInfoLog)
-    {
-        delete [] mInfoLog;
-        mInfoLog = NULL;
-    }
-}
+	bool Program::applyUniform4iv(GLint location, GLsizei count, const GLint *v)
+	{
+		float vector[MAX_UNIFORM_VECTORS][4];
 
-// Returns the program object to an unlinked state, before re-linking, or at destruction
-void Program::unlink(bool destroy)
-{
-    if(destroy)   // Object being destructed
-    {
-        if(mFragmentShader)
-        {
-            mFragmentShader->release();
-            mFragmentShader = NULL;
-        }
+		for(int i = 0; i < count; i++)
+		{
+			vector[i][0] = (float)v[0];
+			vector[i][1] = (float)v[1];
+			vector[i][2] = (float)v[2];
+			vector[i][3] = (float)v[3];
 
-        if(mVertexShader)
-        {
-            mVertexShader->release();
-            mVertexShader = NULL;
-        }
-    }
+			v += 4;
+		}
 
-    delete mPixelExecutable;
-    mPixelExecutable = NULL;
+		Uniform *targetUniform = uniforms[uniformIndex[location].index];
 
-    delete mVertexExecutable;
-    mVertexExecutable = NULL;
+		if(targetUniform->psRegisterIndex != -1)
+		{
+			device->setPixelShaderConstantF(targetUniform->psRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    if(mConstantTablePS)
-    {
-        mConstantTablePS->Release();
-        mConstantTablePS = NULL;
-    }
+		if(targetUniform->vsRegisterIndex != -1)
+		{
+			device->setVertexShaderConstantF(targetUniform->vsRegisterIndex, (float*)vector, targetUniform->registerCount());
+		}
 
-    if(mConstantTableVS)
-    {
-        mConstantTableVS->Release();
-        mConstantTableVS = NULL;
-    }
+		return true;
+	}
 
-    for(int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
-    {
-        mLinkedAttribute[index].name.clear();
-        mSemanticIndex[index] = -1;
-    }
+	void Program::appendToInfoLog(const char *format, ...)
+	{
+		if(!format)
+		{
+			return;
+		}
 
-    for(int index = 0; index < MAX_TEXTURE_IMAGE_UNITS; index++)
-    {
-        mSamplersPS[index].active = false;
-    }
+		char info[1024];
 
-    for(int index = 0; index < MAX_VERTEX_TEXTURE_IMAGE_UNITS; index++)
-    {
-        mSamplersVS[index].active = false;
-    }
+		va_list vararg;
+		va_start(vararg, format);
+		vsnprintf(info, sizeof(info), format, vararg);
+		va_end(vararg);
 
-    while(!mUniforms.empty())
-    {
-        delete mUniforms.back();
-        mUniforms.pop_back();
-    }
+		size_t infoLength = strlen(info);
 
-    mDxDepthRangeLocation = -1;
-    mDxDepthLocation = -1;
-    mDxViewportLocation = -1;
-    mDxHalfPixelSizeLocation = -1;
-    mDxFrontCCWLocation = -1;
-    mDxPointsOrLinesLocation = -1;
+		if(!infoLog)
+		{
+			infoLog = new char[infoLength + 1];
+			strcpy(infoLog, info);
+		}
+		else
+		{
+			size_t logLength = strlen(infoLog);
+			char *newLog = new char[logLength + infoLength + 1];
+			strcpy(newLog, infoLog);
+			strcpy(newLog + logLength, info);
 
-    mUniformIndex.clear();
+			delete[] infoLog;
+			infoLog = newLog;
+		}
+	}
 
-    mPixelHLSL.clear();
-    mVertexHLSL.clear();
+	void Program::resetInfoLog()
+	{
+		if(infoLog)
+		{
+			delete[] infoLog;
+			infoLog = 0;
+		}
+	}
 
-    delete[] mInfoLog;
-    mInfoLog = NULL;
+	// Returns the program object to an unlinked state, before re-linking, or at destruction
+	void Program::unlink()
+	{
+		delete vertexBinary;
+		vertexBinary = 0;
+		delete pixelBinary;
+		pixelBinary = 0;
 
-    mLinked = false;
-}
+		for(int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
+		{
+			linkedAttribute[index].name.clear();
+			attributeStream[index] = -1;
+		}
 
-bool Program::isLinked()
-{
-    return mLinked;
-}
+		for(int index = 0; index < MAX_TEXTURE_IMAGE_UNITS; index++)
+		{
+			samplersPS[index].active = false;
+		}
 
-bool Program::isValidated() const 
-{
-    return mValidated;
-}
+		for(int index = 0; index < MAX_VERTEX_TEXTURE_IMAGE_UNITS; index++)
+		{
+			samplersVS[index].active = false;
+		}
 
-void Program::release()
-{
-    mRefCount--;
+		while(!uniforms.empty())
+		{
+			delete uniforms.back();
+			uniforms.pop_back();
+		}
 
-    if(mRefCount == 0 && mDeleteStatus)
-    {
-        mResourceManager->deleteProgram(mHandle);
-    }
-}
+		uniformIndex.clear();
 
-void Program::addRef()
-{
-    mRefCount++;
-}
+		delete[] infoLog;
+		infoLog = 0;
 
-unsigned int Program::getRefCount() const
-{
-    return mRefCount;
-}
+		linked = false;
+	}
 
-unsigned int Program::getSerial() const
-{
-    return mSerial;
-}
+	bool Program::isLinked()
+	{
+		return linked;
+	}
 
-unsigned int Program::issueSerial()
-{
-    return mCurrentSerial++;
-}
+	bool Program::isValidated() const 
+	{
+		return validated;
+	}
 
-int Program::getInfoLogLength() const
-{
-    if(!mInfoLog)
-    {
-        return 0;
-    }
-    else
-    {
-       return strlen(mInfoLog) + 1;
-    }
-}
+	void Program::release()
+	{
+		referenceCount--;
 
-void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog)
-{
-    int index = 0;
+		if(referenceCount == 0 && orphaned)
+		{
+			resourceManager->deleteProgram(handle);
+		}
+	}
 
-    if(mInfoLog)
-    {
-        while(index < bufSize - 1 && index < (int)strlen(mInfoLog))
-        {
-            infoLog[index] = mInfoLog[index];
-            index++;
-        }
-    }
+	void Program::addRef()
+	{
+		referenceCount++;
+	}
 
-    if(bufSize)
-    {
-        infoLog[index] = '\0';
-    }
+	unsigned int Program::getRefCount() const
+	{
+		return referenceCount;
+	}
 
-    if(length)
-    {
-        *length = index;
-    }
-}
+	unsigned int Program::getSerial() const
+	{
+		return serial;
+	}
 
-void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders)
-{
-    int total = 0;
+	unsigned int Program::issueSerial()
+	{
+		return currentSerial++;
+	}
 
-    if(mVertexShader)
-    {
-        if(total < maxCount)
-        {
-            shaders[total] = mVertexShader->getHandle();
-        }
+	int Program::getInfoLogLength() const
+	{
+		if(!infoLog)
+		{
+			return 0;
+		}
+		else
+		{
+		   return strlen(infoLog) + 1;
+		}
+	}
 
-        total++;
-    }
+	void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *buffer)
+	{
+		int index = 0;
 
-    if(mFragmentShader)
-    {
-        if(total < maxCount)
-        {
-            shaders[total] = mFragmentShader->getHandle();
-        }
+		if(bufSize > 0)
+		{
+			if(infoLog)
+			{
+				index = std::min(bufSize - 1, (int)strlen(infoLog));
+				memcpy(buffer, infoLog, index);
+			}
 
-        total++;
-    }
+			buffer[index] = '\0';
+		}
 
-    if(count)
-    {
-        *count = total;
-    }
-}
+		if(length)
+		{
+			*length = index;
+		}
+	}
 
-void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    // Skip over inactive attributes
-    unsigned int activeAttribute = 0;
-    unsigned int attribute;
-    for(attribute = 0; attribute < MAX_VERTEX_ATTRIBS; attribute++)
-    {
-        if(mLinkedAttribute[attribute].name.empty())
-        {
-            continue;
-        }
+	void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders)
+	{
+		int total = 0;
 
-        if(activeAttribute == index)
-        {
-            break;
-        }
+		if(vertexShader)
+		{
+			if(total < maxCount)
+			{
+				shaders[total] = vertexShader->getHandle();
+			}
 
-        activeAttribute++;
-    }
+			total++;
+		}
 
-    if(bufsize > 0)
-    {
-        const char *string = mLinkedAttribute[attribute].name.c_str();
+		if(fragmentShader)
+		{
+			if(total < maxCount)
+			{
+				shaders[total] = fragmentShader->getHandle();
+			}
 
-        strncpy(name, string, bufsize);
-        name[bufsize - 1] = '\0';
+			total++;
+		}
 
-        if(length)
-        {
-            *length = strlen(name);
-        }
-    }
+		if(count)
+		{
+			*count = total;
+		}
+	}
 
-    *size = 1;   // Always a single 'type' instance
+	void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
+	{
+		// Skip over inactive attributes
+		unsigned int activeAttribute = 0;
+		unsigned int attribute;
+		for(attribute = 0; attribute < MAX_VERTEX_ATTRIBS; attribute++)
+		{
+			if(linkedAttribute[attribute].name.empty())
+			{
+				continue;
+			}
 
-    *type = mLinkedAttribute[attribute].type;
-}
+			if(activeAttribute == index)
+			{
+				break;
+			}
 
-GLint Program::getActiveAttributeCount()
-{
-    int count = 0;
+			activeAttribute++;
+		}
 
-    for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
-    {
-        if(!mLinkedAttribute[attributeIndex].name.empty())
-        {
-            count++;
-        }
-    }
+		if(bufsize > 0)
+		{
+			const char *string = linkedAttribute[attribute].name.c_str();
 
-    return count;
-}
+			strncpy(name, string, bufsize);
+			name[bufsize - 1] = '\0';
 
-GLint Program::getActiveAttributeMaxLength()
-{
-    int maxLength = 0;
+			if(length)
+			{
+				*length = strlen(name);
+			}
+		}
 
-    for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
-    {
-        if(!mLinkedAttribute[attributeIndex].name.empty())
-        {
-            maxLength = std::max((int)(mLinkedAttribute[attributeIndex].name.length() + 1), maxLength);
-        }
-    }
+		*size = 1;   // Always a single 'type' instance
 
-    return maxLength;
-}
+		*type = linkedAttribute[attribute].type;
+	}
 
-void Program::getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-{
-    // Skip over internal uniforms
-    unsigned int activeUniform = 0;
-    unsigned int uniform;
-    for(uniform = 0; uniform < mUniforms.size(); uniform++)
-    {
-        if(mUniforms[uniform]->name.compare(0, 3, "dx_") == 0)
-        {
-            continue;
-        }
+	GLint Program::getActiveAttributeCount()
+	{
+		int count = 0;
 
-        if(activeUniform == index)
-        {
-            break;
-        }
+		for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
+		{
+			if(!linkedAttribute[attributeIndex].name.empty())
+			{
+				count++;
+			}
+		}
 
-        activeUniform++;
-    }
+		return count;
+	}
 
-    ASSERT(uniform < mUniforms.size());   // index must be smaller than getActiveUniformCount()
+	GLint Program::getActiveAttributeMaxLength()
+	{
+		int maxLength = 0;
 
-    if(bufsize > 0)
-    {
-        std::string string = mUniforms[uniform]->name;
+		for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
+		{
+			if(!linkedAttribute[attributeIndex].name.empty())
+			{
+				maxLength = std::max((int)(linkedAttribute[attributeIndex].name.length() + 1), maxLength);
+			}
+		}
 
-        if(mUniforms[uniform]->isArray())
-        {
-            string += "[0]";
-        }
+		return maxLength;
+	}
 
-        strncpy(name, string.c_str(), bufsize);
-        name[bufsize - 1] = '\0';
+	void Program::getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
+	{
+		if(bufsize > 0)
+		{
+			std::string string = uniforms[index]->name;
 
-        if(length)
-        {
-            *length = strlen(name);
-        }
-    }
+			if(uniforms[index]->isArray())
+			{
+				string += "[0]";
+			}
 
-    *size = mUniforms[uniform]->arraySize;
+			strncpy(name, string.c_str(), bufsize);
+			name[bufsize - 1] = '\0';
 
-    *type = mUniforms[uniform]->type;
-}
+			if(length)
+			{
+				*length = strlen(name);
+			}
+		}
 
-GLint Program::getActiveUniformCount()
-{
-    int count = 0;
+		*size = uniforms[index]->size();
 
-    unsigned int numUniforms = mUniforms.size();
-    for(unsigned int uniformIndex = 0; uniformIndex < numUniforms; uniformIndex++)
-    {
-        if(mUniforms[uniformIndex]->name.compare(0, 3, "dx_") != 0)
-        {
-            count++;
-        }
-    }
+		*type = uniforms[index]->type;
+	}
 
-    return count;
-}
+	GLint Program::getActiveUniformCount()
+	{
+		return uniforms.size();
+	}
 
-GLint Program::getActiveUniformMaxLength()
-{
-    int maxLength = 0;
+	GLint Program::getActiveUniformMaxLength()
+	{
+		int maxLength = 0;
 
-    unsigned int numUniforms = mUniforms.size();
-    for(unsigned int uniformIndex = 0; uniformIndex < numUniforms; uniformIndex++)
-    {
-        if(!mUniforms[uniformIndex]->name.empty() && mUniforms[uniformIndex]->name.compare(0, 3, "dx_") != 0)
-        {
-            int length = (int)(mUniforms[uniformIndex]->name.length() + 1);
-            if(mUniforms[uniformIndex]->isArray())
-            {
-                length += 3;  // Counting in "[0]".
-            }
-            maxLength = std::max(length, maxLength);
-        }
-    }
+		unsigned int numUniforms = uniforms.size();
+		for(unsigned int uniformIndex = 0; uniformIndex < numUniforms; uniformIndex++)
+		{
+			if(!uniforms[uniformIndex]->name.empty())
+			{
+				int length = (int)(uniforms[uniformIndex]->name.length() + 1);
+				if(uniforms[uniformIndex]->isArray())
+				{
+					length += 3;  // Counting in "[0]".
+				}
+				maxLength = std::max(length, maxLength);
+			}
+		}
 
-    return maxLength;
-}
+		return maxLength;
+	}
 
-void Program::flagForDeletion()
-{
-    mDeleteStatus = true;
-}
+	void Program::flagForDeletion()
+	{
+		orphaned = true;
+	}
 
-bool Program::isFlaggedForDeletion() const
-{
-    return mDeleteStatus;
-}
+	bool Program::isFlaggedForDeletion() const
+	{
+		return orphaned;
+	}
 
-void Program::validate()
-{
-    resetInfoLog();
+	void Program::validate()
+	{
+		resetInfoLog();
 
-    if(!isLinked()) 
-    {
-        appendToInfoLog("Program has not been successfully linked.");
-        mValidated = false;
-    }
-    else
-    {
-        applyUniforms();
-        if(!validateSamplers(true))
-        {
-            mValidated = false;
-        }
-        else
-        {
-            mValidated = true;
-        }
-    }
-}
+		if(!isLinked()) 
+		{
+			appendToInfoLog("Program has not been successfully linked.");
+			validated = false;
+		}
+		else
+		{
+			applyUniforms();
+			if(!validateSamplers(true))
+			{
+				validated = false;
+			}
+			else
+			{
+				validated = true;
+			}
+		}
+	}
 
-bool Program::validateSamplers(bool logErrors)
-{
-    // if any two active samplers in a program are of different types, but refer to the same
-    // texture image unit, and this is the current program, then ValidateProgram will fail, and
-    // DrawArrays and DrawElements will issue the INVALID_OPERATION error.
+	bool Program::validateSamplers(bool logErrors)
+	{
+		// if any two active samplers in a program are of different types, but refer to the same
+		// texture image unit, and this is the current program, then ValidateProgram will fail, and
+		// DrawArrays and DrawElements will issue the INVALID_OPERATION error.
 
-    TextureType textureUnitType[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
+		TextureType textureUnitType[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
 
-    for(unsigned int i = 0; i < MAX_COMBINED_TEXTURE_IMAGE_UNITS; ++i)
-    {
-        textureUnitType[i] = TEXTURE_UNKNOWN;
-    }
+		for(unsigned int i = 0; i < MAX_COMBINED_TEXTURE_IMAGE_UNITS; i++)
+		{
+			textureUnitType[i] = TEXTURE_UNKNOWN;
+		}
 
-    for(unsigned int i = 0; i < MAX_TEXTURE_IMAGE_UNITS; ++i)
-    {
-        if(mSamplersPS[i].active)
-        {
-            unsigned int unit = mSamplersPS[i].logicalTextureUnit;
+		for(unsigned int i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)
+		{
+			if(samplersPS[i].active)
+			{
+				unsigned int unit = samplersPS[i].logicalTextureUnit;
             
-            if(unit >= MAX_COMBINED_TEXTURE_IMAGE_UNITS)
-            {
-                if(logErrors)
-                {
-                    appendToInfoLog("Sampler uniform (%d) exceeds MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-                }
+				if(unit >= MAX_COMBINED_TEXTURE_IMAGE_UNITS)
+				{
+					if(logErrors)
+					{
+						appendToInfoLog("Sampler uniform (%d) exceeds MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+					}
 
-                return false;
-            }
+					return false;
+				}
 
-            if(textureUnitType[unit] != TEXTURE_UNKNOWN)
-            {
-                if(mSamplersPS[i].textureType != textureUnitType[unit])
-                {
-                    if(logErrors)
-                    {
-                        appendToInfoLog("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
-                    }
+				if(textureUnitType[unit] != TEXTURE_UNKNOWN)
+				{
+					if(samplersPS[i].textureType != textureUnitType[unit])
+					{
+						if(logErrors)
+						{
+							appendToInfoLog("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
+						}
 
-                    return false;
-                }
-            }
-            else
-            {
-                textureUnitType[unit] = mSamplersPS[i].textureType;
-            }
-        }
-    }
+						return false;
+					}
+				}
+				else
+				{
+					textureUnitType[unit] = samplersPS[i].textureType;
+				}
+			}
+		}
 
-    for(unsigned int i = 0; i < MAX_VERTEX_TEXTURE_IMAGE_UNITS; ++i)
-    {
-        if(mSamplersVS[i].active)
-        {
-            unsigned int unit = mSamplersVS[i].logicalTextureUnit;
+		for(unsigned int i = 0; i < MAX_VERTEX_TEXTURE_IMAGE_UNITS; i++)
+		{
+			if(samplersVS[i].active)
+			{
+				unsigned int unit = samplersVS[i].logicalTextureUnit;
             
-            if(unit >= MAX_COMBINED_TEXTURE_IMAGE_UNITS)
-            {
-                if(logErrors)
-                {
-                    appendToInfoLog("Sampler uniform (%d) exceeds MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-                }
+				if(unit >= MAX_COMBINED_TEXTURE_IMAGE_UNITS)
+				{
+					if(logErrors)
+					{
+						appendToInfoLog("Sampler uniform (%d) exceeds MAX_COMBINED_TEXTURE_IMAGE_UNITS (%d)", unit, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+					}
 
-                return false;
-            }
+					return false;
+				}
 
-            if(textureUnitType[unit] != TEXTURE_UNKNOWN)
-            {
-                if(mSamplersVS[i].textureType != textureUnitType[unit])
-                {
-                    if(logErrors)
-                    {
-                        appendToInfoLog("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
-                    }
+				if(textureUnitType[unit] != TEXTURE_UNKNOWN)
+				{
+					if(samplersVS[i].textureType != textureUnitType[unit])
+					{
+						if(logErrors)
+						{
+							appendToInfoLog("Samplers of conflicting types refer to the same texture image unit (%d).", unit);
+						}
 
-                    return false;
-                }
-            }
-            else
-            {
-                textureUnitType[unit] = mSamplersVS[i].textureType;
-            }
-        }
-    }
+						return false;
+					}
+				}
+				else
+				{
+					textureUnitType[unit] = samplersVS[i].textureType;
+				}
+			}
+		}
 
-    return true;
-}
-
-void Program::getConstantHandles(Uniform *targetUniform, D3DXHANDLE *constantPS, D3DXHANDLE *constantVS)
-{
-    if(!targetUniform->handlesSet)
-    {
-        targetUniform->psHandle = mConstantTablePS->GetConstantByName(0, targetUniform->_name.c_str());
-        targetUniform->vsHandle = mConstantTableVS->GetConstantByName(0, targetUniform->_name.c_str());
-        targetUniform->handlesSet = true;
-    }
-
-    *constantPS = targetUniform->psHandle;
-    *constantVS = targetUniform->vsHandle;
-}
-
-GLint Program::getDxDepthRangeLocation() const
-{
-    return mDxDepthRangeLocation;
-}
-
-GLint Program::getDxDepthLocation() const
-{
-    return mDxDepthLocation;
-}
-
-GLint Program::getDxViewportLocation() const
-{
-    return mDxViewportLocation;
-}
-
-GLint Program::getDxHalfPixelSizeLocation() const
-{
-    return mDxHalfPixelSizeLocation;
-}
-
-GLint Program::getDxFrontCCWLocation() const
-{
-    return mDxFrontCCWLocation;
-}
-
-GLint Program::getDxPointsOrLinesLocation() const
-{
-    return mDxPointsOrLinesLocation;
-}
-
+		return true;
+	}
 }
diff --git a/src/OpenGL ES 2.0/libGLESv2/Program.h b/src/OpenGL ES 2.0/libGLESv2/Program.h
index 6bfd41d..8501e5e 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Program.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Program.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Program.h: Defines the Program class. Implements GL program objects
@@ -15,217 +20,189 @@
 #include "Shader/PixelShader.hpp"
 #include "Shader/VertexShader.hpp"
 
-#include <d3dx9.h>
-#include <d3dcompiler.h>
 #include <string>
 #include <vector>
 #include <set>
 
 namespace gl
 {
-class ResourceManager;
-class FragmentShader;
-class VertexShader;
+	class Device;
+	class ResourceManager;
+	class FragmentShader;
+	class VertexShader;
 
-// Helper struct representing a single shader uniform
-struct Uniform
-{
-    Uniform(GLenum type, const std::string &_name, unsigned int arraySize);
+	// Helper struct representing a single shader uniform
+	struct Uniform
+	{
+		Uniform(GLenum type, const std::string &name, unsigned int arraySize);
 
-    ~Uniform();
+		~Uniform();
 
-    bool isArray();
+		bool isArray() const;
+		int size() const;
+		int registerCount() const;
 
-    const GLenum type;
-    const std::string _name;   // Decorated name
-    const std::string name;    // Undecorated name
-    const unsigned int arraySize;
+		const GLenum type;
+		const std::string name;
+		const unsigned int arraySize;
 
-    unsigned char *data;
-    bool dirty;
+		unsigned char *data;
+		bool dirty;
 
-    D3DXHANDLE vsHandle;
-    D3DXHANDLE psHandle;
-    bool handlesSet;
-};
+		short psRegisterIndex;
+		short vsRegisterIndex;
+	};
 
-// Struct used for correlating uniforms/elements of uniform arrays to handles
-struct UniformLocation
-{
-    UniformLocation(const std::string &_name, unsigned int element, unsigned int index);
+	// Struct used for correlating uniforms/elements of uniform arrays to handles
+	struct UniformLocation
+	{
+		UniformLocation(const std::string &name, unsigned int element, unsigned int index);
 
-    std::string name;
-    unsigned int element;
-    unsigned int index;
-};
+		std::string name;
+		unsigned int element;
+		unsigned int index;
+	};
 
-class Program
-{
-  public:
-    Program(ResourceManager *manager, GLuint handle);
+	class Program
+	{
+	public:
+		Program(ResourceManager *manager, GLuint handle);
 
-    ~Program();
+		~Program();
 
-    bool attachShader(Shader *shader);
-    bool detachShader(Shader *shader);
-    int getAttachedShadersCount() const;
+		bool attachShader(Shader *shader);
+		bool detachShader(Shader *shader);
+		int getAttachedShadersCount() const;
 
-    sw::PixelShader *getPixelShader();
-    sw::VertexShader *getVertexShader();
+		sw::PixelShader *getPixelShader();
+		sw::VertexShader *getVertexShader();
 
-    void bindAttributeLocation(GLuint index, const char *name);
-    GLuint getAttributeLocation(const char *name);
-    int getSemanticIndex(int attributeIndex);
+		void bindAttributeLocation(GLuint index, const char *name);
+		GLuint getAttributeLocation(const char *name);
+		int getAttributeStream(int attributeIndex);
 
-    GLint getSamplerMapping(sw::SamplerType type, unsigned int samplerIndex);
-    TextureType getSamplerTextureType(sw::SamplerType type, unsigned int samplerIndex);
+		GLint getSamplerMapping(sw::SamplerType type, unsigned int samplerIndex);
+		TextureType getSamplerTextureType(sw::SamplerType type, unsigned int samplerIndex);
 
-    GLint getUniformLocation(std::string name);
-    bool setUniform1fv(GLint location, GLsizei count, const GLfloat *v);
-    bool setUniform2fv(GLint location, GLsizei count, const GLfloat *v);
-    bool setUniform3fv(GLint location, GLsizei count, const GLfloat *v);
-    bool setUniform4fv(GLint location, GLsizei count, const GLfloat *v);
-    bool setUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value);
-    bool setUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value);
-    bool setUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value);
-    bool setUniform1iv(GLint location, GLsizei count, const GLint *v);
-    bool setUniform2iv(GLint location, GLsizei count, const GLint *v);
-    bool setUniform3iv(GLint location, GLsizei count, const GLint *v);
-    bool setUniform4iv(GLint location, GLsizei count, const GLint *v);
+		GLint getUniformLocation(std::string name);
+		bool setUniform1fv(GLint location, GLsizei count, const GLfloat *v);
+		bool setUniform2fv(GLint location, GLsizei count, const GLfloat *v);
+		bool setUniform3fv(GLint location, GLsizei count, const GLfloat *v);
+		bool setUniform4fv(GLint location, GLsizei count, const GLfloat *v);
+		bool setUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value);
+		bool setUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value);
+		bool setUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value);
+		bool setUniform1iv(GLint location, GLsizei count, const GLint *v);
+		bool setUniform2iv(GLint location, GLsizei count, const GLint *v);
+		bool setUniform3iv(GLint location, GLsizei count, const GLint *v);
+		bool setUniform4iv(GLint location, GLsizei count, const GLint *v);
 
-    bool getUniformfv(GLint location, GLfloat *params);
-    bool getUniformiv(GLint location, GLint *params);
+		bool getUniformfv(GLint location, GLsizei *bufSize, GLfloat *params);
+		bool getUniformiv(GLint location, GLsizei *bufSize, GLint *params);
 
-    GLint getDxDepthRangeLocation() const;
-    GLint getDxDepthLocation() const;
-    GLint getDxViewportLocation() const;
-    GLint getDxHalfPixelSizeLocation() const;
-    GLint getDxFrontCCWLocation() const;
-    GLint getDxPointsOrLinesLocation() const;
+		void dirtyAllUniforms();
+		void applyUniforms();
 
-    void dirtyAllUniforms();
-    void applyUniforms();
+		void link();
+		bool isLinked();
+		int getInfoLogLength() const;
+		void getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog);
+		void getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders);
 
-    void link();
-    bool isLinked();
-    int getInfoLogLength() const;
-    void getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog);
-    void getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders);
+		void getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+		GLint getActiveAttributeCount();
+		GLint getActiveAttributeMaxLength();
 
-    void getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    GLint getActiveAttributeCount();
-    GLint getActiveAttributeMaxLength();
+		void getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+		GLint getActiveUniformCount();
+		GLint getActiveUniformMaxLength();
 
-    void getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    GLint getActiveUniformCount();
-    GLint getActiveUniformMaxLength();
+		void addRef();
+		void release();
+		unsigned int getRefCount() const;
+		void flagForDeletion();
+		bool isFlaggedForDeletion() const;
 
-    void addRef();
-    void release();
-    unsigned int getRefCount() const;
-    void flagForDeletion();
-    bool isFlaggedForDeletion() const;
+		void validate();
+		bool validateSamplers(bool logErrors);
+		bool isValidated() const;
 
-    void validate();
-    bool validateSamplers(bool logErrors);
-    bool isValidated() const;
+		unsigned int getSerial() const;
 
-    unsigned int getSerial() const;
+	private:
+		DISALLOW_COPY_AND_ASSIGN(Program);
 
-    static std::string decorateAttribute(const std::string &name);    // Prepend an underscore
-    static std::string undecorateUniform(const std::string &_name);   // Remove leading underscore
+		void unlink();
 
-  private:
-    DISALLOW_COPY_AND_ASSIGN(Program);
+		int packVaryings(const Varying *packing[][4]);
+		bool linkVaryings();
 
-    ID3D10Blob *compileToBinary(const char *hlsl, const char *profile, ID3DXConstantTable **constantTable);
-    void unlink(bool destroy = false);
+		bool linkAttributes();
+		int getAttributeBinding(const std::string &name);
 
-    int packVaryings(const Varying *packing[][4]);
-    bool linkVaryings();
+		bool linkUniforms(Shader *shader);
+		bool defineUniform(GLenum shader, GLenum type, const std::string &_name, unsigned int arraySize, int registerIndex);
+		bool applyUniform1bv(GLint location, GLsizei count, const GLboolean *v);
+		bool applyUniform2bv(GLint location, GLsizei count, const GLboolean *v);
+		bool applyUniform3bv(GLint location, GLsizei count, const GLboolean *v);
+		bool applyUniform4bv(GLint location, GLsizei count, const GLboolean *v);
+		bool applyUniform1fv(GLint location, GLsizei count, const GLfloat *v);
+		bool applyUniform2fv(GLint location, GLsizei count, const GLfloat *v);
+		bool applyUniform3fv(GLint location, GLsizei count, const GLfloat *v);
+		bool applyUniform4fv(GLint location, GLsizei count, const GLfloat *v);
+		bool applyUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value);
+		bool applyUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value);
+		bool applyUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value);
+		bool applyUniform1iv(GLint location, GLsizei count, const GLint *v);
+		bool applyUniform2iv(GLint location, GLsizei count, const GLint *v);
+		bool applyUniform3iv(GLint location, GLsizei count, const GLint *v);
+		bool applyUniform4iv(GLint location, GLsizei count, const GLint *v);    
 
-    bool linkAttributes();
-    int getAttributeBinding(const std::string &name);
+		void appendToInfoLog(const char *info, ...);
+		void resetInfoLog();
 
-    bool linkUniforms(ID3DXConstantTable *constantTable);
-    bool defineUniform(const D3DXHANDLE &constantHandle, const D3DXCONSTANT_DESC &constantDescription, std::string name = "");
-    bool defineUniform(const D3DXCONSTANT_DESC &constantDescription, std::string &name);
-    Uniform *createUniform(const D3DXCONSTANT_DESC &constantDescription, std::string &name);
-    bool applyUniform1bv(GLint location, GLsizei count, const GLboolean *v);
-    bool applyUniform2bv(GLint location, GLsizei count, const GLboolean *v);
-    bool applyUniform3bv(GLint location, GLsizei count, const GLboolean *v);
-    bool applyUniform4bv(GLint location, GLsizei count, const GLboolean *v);
-    bool applyUniform1fv(GLint location, GLsizei count, const GLfloat *v);
-    bool applyUniform2fv(GLint location, GLsizei count, const GLfloat *v);
-    bool applyUniform3fv(GLint location, GLsizei count, const GLfloat *v);
-    bool applyUniform4fv(GLint location, GLsizei count, const GLfloat *v);
-    bool applyUniformMatrix2fv(GLint location, GLsizei count, const GLfloat *value);
-    bool applyUniformMatrix3fv(GLint location, GLsizei count, const GLfloat *value);
-    bool applyUniformMatrix4fv(GLint location, GLsizei count, const GLfloat *value);
-    bool applyUniform1iv(GLint location, GLsizei count, const GLint *v);
-    bool applyUniform2iv(GLint location, GLsizei count, const GLint *v);
-    bool applyUniform3iv(GLint location, GLsizei count, const GLint *v);
-    bool applyUniform4iv(GLint location, GLsizei count, const GLint *v);
+		static unsigned int issueSerial();
 
-    void getConstantHandles(Uniform *targetUniform, D3DXHANDLE *constantPS, D3DXHANDLE *constantVS);
+	private:
+		gl::Device *device;
+		FragmentShader *fragmentShader;
+		VertexShader *vertexShader;
 
-    void appendToInfoLogSanitized(const char *message);
-    void appendToInfoLog(const char *info, ...);
-    void resetInfoLog();
+		sw::PixelShader *pixelBinary;
+		sw::VertexShader *vertexBinary;
+    
+		std::set<std::string> attributeBinding[MAX_VERTEX_ATTRIBS];
+		sh::Attribute linkedAttribute[MAX_VERTEX_ATTRIBS];
+		int attributeStream[MAX_VERTEX_ATTRIBS];
 
-    static unsigned int issueSerial();
+		struct Sampler
+		{
+			bool active;
+			GLint logicalTextureUnit;
+			TextureType textureType;
+		};
 
-    FragmentShader *mFragmentShader;
-    VertexShader *mVertexShader;
+		Sampler samplersPS[MAX_TEXTURE_IMAGE_UNITS];
+		Sampler samplersVS[MAX_VERTEX_TEXTURE_IMAGE_UNITS];
 
-    std::string mPixelHLSL;
-    std::string mVertexHLSL;
+		typedef std::vector<Uniform*> UniformArray;
+		UniformArray uniforms;
+		typedef std::vector<UniformLocation> UniformIndex;
+		UniformIndex uniformIndex;
 
-    sw::PixelShader *mPixelExecutable;
-    sw::VertexShader *mVertexExecutable;
-    ID3DXConstantTable *mConstantTablePS;
-    ID3DXConstantTable *mConstantTableVS;
+		bool linked;
+		bool orphaned;   // Flag to indicate that the program can be deleted when no longer in use
+		char *infoLog;
+		bool validated;
 
-    std::set<std::string> mAttributeBinding[MAX_VERTEX_ATTRIBS];
-    Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS];
-    int mSemanticIndex[MAX_VERTEX_ATTRIBS];
+		unsigned int referenceCount;
+		const unsigned int serial;
 
-    struct Sampler
-    {
-        bool active;
-        GLint logicalTextureUnit;
-        TextureType textureType;
-    };
+		static unsigned int currentSerial;
 
-    Sampler mSamplersPS[MAX_TEXTURE_IMAGE_UNITS];
-    Sampler mSamplersVS[MAX_VERTEX_TEXTURE_IMAGE_UNITS];
-
-    typedef std::vector<Uniform*> UniformArray;
-    UniformArray mUniforms;
-    typedef std::vector<UniformLocation> UniformIndex;
-    UniformIndex mUniformIndex;
-
-    GLint mDxDepthRangeLocation;
-    GLint mDxDepthLocation;
-    GLint mDxViewportLocation;
-    GLint mDxHalfPixelSizeLocation;
-    GLint mDxFrontCCWLocation;
-    GLint mDxPointsOrLinesLocation;
-
-    bool mLinked;
-    bool mDeleteStatus;   // Flag to indicate that the program can be deleted when no longer in use
-    char *mInfoLog;
-    bool mValidated;
-
-    unsigned int mRefCount;
-
-    const unsigned int mSerial;
-
-    static unsigned int mCurrentSerial;
-
-    ResourceManager *mResourceManager;
-    const GLuint mHandle;
-};
+		ResourceManager *resourceManager;
+		const GLuint handle;
+	};
 }
 
 #endif   // LIBGLESV2_PROGRAM_H_
diff --git a/src/OpenGL ES 2.0/libGLESv2/Query.cpp b/src/OpenGL ES 2.0/libGLESv2/Query.cpp
new file mode 100644
index 0000000..7334d08
--- /dev/null
+++ b/src/OpenGL ES 2.0/libGLESv2/Query.cpp
@@ -0,0 +1,125 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+// Query.cpp: Implements the gl::Query class
+
+#include "Query.h"
+#include "main.h"
+
+namespace gl
+{
+
+Query::Query(GLuint id, GLenum type) : RefCountObject(id)
+{ 
+    mQuery = NULL;
+    mStatus = GL_FALSE;
+    mResult = GL_FALSE;
+    mType = type;
+}
+
+Query::~Query()
+{
+    if(mQuery != NULL)
+    {
+        delete mQuery;
+    }
+}
+
+void Query::begin()
+{
+    if(mQuery == NULL)
+    {
+		mQuery = new sw::Query();
+        
+		if(!mQuery)
+        {
+            return error(GL_OUT_OF_MEMORY);
+        }
+    }
+
+	Device *device = getDevice();
+
+	mQuery->begin();
+	device->addQuery(mQuery);
+	device->setOcclusionEnabled(true);
+}
+
+void Query::end()
+{
+    if(mQuery == NULL)
+    {
+        return error(GL_INVALID_OPERATION);
+	}
+
+	Device *device = getDevice();
+
+    mQuery->end();
+	device->removeQuery(mQuery);
+	device->setOcclusionEnabled(false);
+    
+    mStatus = GL_FALSE;
+    mResult = GL_FALSE;
+}
+
+GLuint Query::getResult()
+{
+    if(mQuery != NULL)
+    {
+        while(!testQuery())
+        {
+            Sleep(0);
+        }
+    }
+
+    return (GLuint)mResult;
+}
+
+GLboolean Query::isResultAvailable()
+{
+    if(mQuery != NULL)
+    {
+        testQuery();
+    }
+    
+    return mStatus;
+}
+
+GLenum Query::getType() const
+{
+    return mType;
+}
+
+GLboolean Query::testQuery()
+{
+    if(mQuery != NULL && mStatus != GL_TRUE)
+    {
+        if(!mQuery->building && mQuery->reference == 0)
+        {
+			DWORD numPixels = mQuery->data;
+            mStatus = GL_TRUE;
+
+            switch(mType)
+            {
+            case GL_ANY_SAMPLES_PASSED_EXT:
+            case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+                mResult = (numPixels > 0) ? GL_TRUE : GL_FALSE;
+                break;
+            default:
+                ASSERT(false);
+            }
+        }
+        
+        return mStatus;
+    }
+
+    return GL_TRUE;   // Prevent blocking when query is null
+}
+}
diff --git a/src/OpenGL ES 2.0/libGLESv2/Query.h b/src/OpenGL ES 2.0/libGLESv2/Query.h
new file mode 100644
index 0000000..e2e05c8
--- /dev/null
+++ b/src/OpenGL ES 2.0/libGLESv2/Query.h
@@ -0,0 +1,53 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+// Query.h: Defines the gl::Query class
+
+#ifndef LIBGLESV2_QUERY_H_
+#define LIBGLESV2_QUERY_H_
+
+#include "RefCountObject.h"
+#include "common/angleutils.h"
+#include "Renderer/Renderer.hpp"
+
+#define GL_APICALL
+#include <GLES2/gl2.h>
+
+namespace gl
+{
+
+class Query : public RefCountObject
+{
+  public:
+    Query(GLuint id, GLenum type);
+    virtual ~Query();
+
+    void begin();
+    void end();
+    GLuint getResult();
+    GLboolean isResultAvailable();
+
+    GLenum getType() const;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(Query);
+
+    GLboolean testQuery();
+
+    sw::Query* mQuery;
+    GLenum mType;
+    GLboolean mStatus;
+    GLint mResult;
+};
+
+}
+
+#endif   // LIBGLESV2_QUERY_H_
diff --git a/src/OpenGL ES 2.0/libGLESv2/RefCountObject.cpp b/src/OpenGL ES 2.0/libGLESv2/RefCountObject.cpp
index efa57a4..d9d88ac 100644
--- a/src/OpenGL ES 2.0/libGLESv2/RefCountObject.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/RefCountObject.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // RefCountObject.cpp: Defines the RefCountObject base class that provides
diff --git a/src/OpenGL ES 2.0/libGLESv2/RefCountObject.h b/src/OpenGL ES 2.0/libGLESv2/RefCountObject.h
index c6940e0..31264c2 100644
--- a/src/OpenGL ES 2.0/libGLESv2/RefCountObject.h
+++ b/src/OpenGL ES 2.0/libGLESv2/RefCountObject.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // RefCountObject.h: Defines the RefCountObject base class that provides
diff --git a/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.cpp b/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.cpp
index 3bdca1f..1ab1f61 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Renderbuffer.cpp: the Renderbuffer class and its derived classes
@@ -29,19 +34,19 @@
     delete mStorage;
 }
 
-bool Renderbuffer::isColorbuffer() const
+Colorbuffer *Renderbuffer::getColorbuffer()
 {
-    return mStorage->isColorbuffer();
+    return mStorage->getColorbuffer();
 }
 
-bool Renderbuffer::isDepthbuffer() const
+DepthStencilbuffer *Renderbuffer::getDepthbuffer()
 {
-    return mStorage->isDepthbuffer();
+    return mStorage->getDepthbuffer();
 }
 
-bool Renderbuffer::isStencilbuffer() const
+DepthStencilbuffer *Renderbuffer::getStencilbuffer()
 {
-    return mStorage->isStencilbuffer();
+    return mStorage->getStencilbuffer();
 }
 
 Image *Renderbuffer::getRenderTarget()
@@ -135,19 +140,19 @@
 {
 }
 
-bool RenderbufferStorage::isColorbuffer() const
+Colorbuffer *RenderbufferStorage::getColorbuffer()
 {
-    return false;
+    return NULL;
 }
 
-bool RenderbufferStorage::isDepthbuffer() const
+DepthStencilbuffer *RenderbufferStorage::getDepthbuffer()
 {
-    return false;
+    return NULL;
 }
 
-bool RenderbufferStorage::isStencilbuffer() const
+DepthStencilbuffer *RenderbufferStorage::getStencilbuffer()
 {
-    return false;
+    return NULL;
 }
 
 Image *RenderbufferStorage::getRenderTarget()
@@ -343,21 +348,28 @@
     return format;
 }
 
-bool Colorbuffer::isColorbuffer() const
+Colorbuffer *Colorbuffer::getColorbuffer()
 {
-    return true;
+    return this;
 }
 
 Image *Colorbuffer::getRenderTarget()
 {
     if(mTexture)
     {
-        if(mRenderTarget)
+        Image *newRenderTarget = mTexture->getRenderTarget(mTarget);
+
+		if(mRenderTarget)
         {
             mRenderTarget->release();
         }
 
-        mRenderTarget = mTexture->getRenderTarget(mTarget);
+		mRenderTarget = newRenderTarget;
+    }
+
+	if(mRenderTarget)
+    {
+        mRenderTarget->addRef();
     }
 
     return mRenderTarget;
@@ -418,14 +430,14 @@
     }
 }
 
-bool DepthStencilbuffer::isDepthbuffer() const
+DepthStencilbuffer *DepthStencilbuffer::getDepthbuffer()
 {
-    return true;
+    return this;
 }
 
-bool DepthStencilbuffer::isStencilbuffer() const
+DepthStencilbuffer *DepthStencilbuffer::getStencilbuffer()
 {
-    return true;
+    return this;
 }
 
 Image *DepthStencilbuffer::getDepthStencil()
@@ -457,14 +469,14 @@
 {
 }
 
-bool Depthbuffer::isDepthbuffer() const
+DepthStencilbuffer *Depthbuffer::getDepthbuffer()
 {
-    return true;
+    return this;
 }
 
-bool Depthbuffer::isStencilbuffer() const
+DepthStencilbuffer *Depthbuffer::getStencilbuffer()
 {
-    return false;
+    return NULL;
 }
 
 Stencilbuffer::Stencilbuffer(Image *depthStencil) : DepthStencilbuffer(depthStencil)
@@ -491,13 +503,13 @@
 {
 }
 
-bool Stencilbuffer::isDepthbuffer() const
+DepthStencilbuffer *Stencilbuffer::getDepthbuffer()
 {
-    return false;
+    return NULL;
 }
 
-bool Stencilbuffer::isStencilbuffer() const
+DepthStencilbuffer *Stencilbuffer::getStencilbuffer()
 {
-    return true;
+    return this;
 }
 }
diff --git a/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.h b/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.h
index da339a8..5248194 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Renderbuffer.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Renderbuffer.h: Defines the wrapper class Renderbuffer, as well as the
@@ -22,6 +27,8 @@
 namespace gl
 {
 class Texture;
+class Colorbuffer;
+class DepthStencilbuffer;
 
 // A class derived from RenderbufferStorage is created whenever glRenderbufferStorage
 // is called. The specific concrete type depends on whether the internal format is
@@ -33,9 +40,9 @@
 
     virtual ~RenderbufferStorage() = 0;
 
-    virtual bool isColorbuffer() const;
-    virtual bool isDepthbuffer() const;
-    virtual bool isStencilbuffer() const;
+    virtual Colorbuffer *getColorbuffer();
+    virtual DepthStencilbuffer *getDepthbuffer();
+    virtual DepthStencilbuffer *getStencilbuffer();
 
     virtual Image *getRenderTarget();
     virtual Image *getDepthStencil();
@@ -82,9 +89,9 @@
 
     ~Renderbuffer();
 
-    bool isColorbuffer() const;
-    bool isDepthbuffer() const;
-    bool isStencilbuffer() const;
+    Colorbuffer *getColorbuffer();
+    DepthStencilbuffer *getDepthbuffer();
+    DepthStencilbuffer *getStencilbuffer();
 
     Image *getRenderTarget();
     Image *getDepthStencil();
@@ -121,7 +128,7 @@
 
     virtual ~Colorbuffer();
 
-    virtual bool isColorbuffer() const;
+    virtual Colorbuffer *getColorbuffer();
 
     virtual Image *getRenderTarget();
 
@@ -148,8 +155,8 @@
 
     ~DepthStencilbuffer();
 
-    virtual bool isDepthbuffer() const;
-    virtual bool isStencilbuffer() const;
+    virtual DepthStencilbuffer *getDepthbuffer();
+    virtual DepthStencilbuffer *getStencilbuffer();
 
     virtual Image *getDepthStencil();
 
@@ -166,8 +173,8 @@
 
     virtual ~Depthbuffer();
 
-    virtual bool isDepthbuffer() const;
-    virtual bool isStencilbuffer() const;
+    virtual DepthStencilbuffer *getDepthbuffer();
+    virtual DepthStencilbuffer *getStencilbuffer();
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Depthbuffer);
@@ -181,8 +188,8 @@
 
     virtual ~Stencilbuffer();
 
-    virtual bool isDepthbuffer() const;
-    virtual bool isStencilbuffer() const;
+    virtual DepthStencilbuffer *getDepthbuffer();
+    virtual DepthStencilbuffer *getStencilbuffer();
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Stencilbuffer);
diff --git a/src/OpenGL ES 2.0/libGLESv2/ResourceManager.cpp b/src/OpenGL ES 2.0/libGLESv2/ResourceManager.cpp
index 9318d8c..c7cf33f 100644
--- a/src/OpenGL ES 2.0/libGLESv2/ResourceManager.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/ResourceManager.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // ResourceManager.cpp: Implements the ResourceManager class, which tracks and 
diff --git a/src/OpenGL ES 2.0/libGLESv2/ResourceManager.h b/src/OpenGL ES 2.0/libGLESv2/ResourceManager.h
index e8f41c4..3cc0633 100644
--- a/src/OpenGL ES 2.0/libGLESv2/ResourceManager.h
+++ b/src/OpenGL ES 2.0/libGLESv2/ResourceManager.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // ResourceManager.h : Defines the ResourceManager class, which tracks objects
diff --git a/src/OpenGL ES 2.0/libGLESv2/Shader.cpp b/src/OpenGL ES 2.0/libGLESv2/Shader.cpp
index d32eae6..6c55db9 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Shader.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Shader.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Shader.cpp: Implements the Shader class and its  derived classes
@@ -25,34 +30,10 @@
 Shader::Shader(ResourceManager *manager, GLuint handle) : mHandle(handle), mResourceManager(manager)
 {
     mSource = NULL;
-    mHlsl = NULL;
     mInfoLog = NULL;
 
-    // Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
-    if(!mFragmentCompiler)
-    {
-        int result = ShInitialize();
-
-        if(result)
-        {
-            ShBuiltInResources resources;
-            ShInitBuiltInResources(&resources);
-            Context *context = getContext();            
-
-            resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
-            resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
-            resources.MaxVaryingVectors = MAX_VARYING_VECTORS;
-            resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
-            resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
-            resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
-            resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
-            resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
-            resources.OES_standard_derivatives = 1;
-
-            mFragmentCompiler = ShConstructCompiler(SH_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources);
-            mVertexCompiler = ShConstructCompiler(SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources);
-        }
-    }
+	clear();
+	initializeCompiler();
 
     mRefCount = 0;
     mDeleteStatus = false;
@@ -61,7 +42,6 @@
 Shader::~Shader()
 {
     delete[] mSource;
-    delete[] mHlsl;
     delete[] mInfoLog;
 }
 
@@ -126,17 +106,14 @@
 {
     int index = 0;
 
-    if(mInfoLog)
-    {
-        while(index < bufSize - 1 && index < (int)strlen(mInfoLog))
-        {
-            infoLog[index] = mInfoLog[index];
-            index++;
-        }
-    }
+	if(bufSize > 0)
+	{
+		if(mInfoLog)
+		{
+			index = std::min(bufSize - 1, (int)strlen(mInfoLog));
+			memcpy(infoLog, mInfoLog, index);
+		}
 
-    if(bufSize)
-    {
         infoLog[index] = '\0';
     }
 
@@ -162,17 +139,14 @@
 {
     int index = 0;
 
-    if(mSource)
-    {
-        while(index < bufSize - 1 && index < (int)strlen(mSource))
-        {
-            source[index] = mSource[index];
-            index++;
-        }
-    }
+	if(bufSize > 0)
+	{
+		if(mSource)
+		{
+			index = std::min(bufSize - 1, (int)strlen(mSource));
+			memcpy(source, mSource, index);
+		}
 
-    if(bufSize)
-    {
         source[index] = '\0';
     }
 
@@ -182,14 +156,28 @@
     }
 }
 
-bool Shader::isCompiled()
+void Shader::clear()
 {
-    return mHlsl != NULL;
+    delete[] mInfoLog;
+    mInfoLog = NULL;
+
+    varyings.clear();
+	activeAttributes.clear();
 }
 
-const char *Shader::getHLSL()
+bool Shader::isCompiled()
 {
-    return mHlsl;
+    return getShader() != 0;
+}
+
+sw::PixelShader *Shader::getPixelShader() const
+{
+	return 0;
+}
+
+sw::VertexShader *Shader::getVertexShader() const
+{
+	return 0;
 }
 
 void Shader::addRef()
@@ -222,6 +210,35 @@
     mDeleteStatus = true;
 }
 
+// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
+void Shader::initializeCompiler()
+{
+    if(!mFragmentCompiler)
+    {
+        int result = ShInitialize();
+
+        if(result)
+        {
+            ShBuiltInResources resources;
+            ShInitBuiltInResources(&resources);
+            Context *context = getContext();            
+
+            resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
+            resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
+            resources.MaxVaryingVectors = MAX_VARYING_VECTORS;
+            resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+            resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+            resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
+            resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
+            resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
+            resources.OES_standard_derivatives = 1;
+
+            mFragmentCompiler = ShConstructCompiler(SH_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources);
+            mVertexCompiler = ShConstructCompiler(SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources);
+        }
+    }
+}
+
 void Shader::releaseCompiler()
 {
     ShDestruct(mFragmentCompiler);
@@ -233,92 +250,6 @@
     ShFinalize();
 }
 
-void Shader::parseVaryings()
-{
-    if(mHlsl)
-    {
-        const char *input = strstr(mHlsl, "// Varyings") + 12;
-
-        while(true)
-        {
-            char varyingType[256];
-            char varyingName[256];
-
-            int matches = sscanf(input, "static %255s %255s", varyingType, varyingName);
-
-            if(matches != 2)
-            {
-                break;
-            }
-
-            char *array = strstr(varyingName, "[");
-            int size = 1;
-
-            if(array)
-            {
-                size = atoi(array + 1);
-                *array = '\0';
-            }
-
-            varyings.push_back(Varying(parseType(varyingType), varyingName, size, array != NULL));
-
-            input = strstr(input, ";") + 2;
-        }
-
-        mUsesFragCoord = strstr(mHlsl, "GL_USES_FRAG_COORD") != NULL;
-        mUsesFrontFacing = strstr(mHlsl, "GL_USES_FRONT_FACING") != NULL;
-        mUsesPointSize = strstr(mHlsl, "GL_USES_POINT_SIZE") != NULL;
-        mUsesPointCoord = strstr(mHlsl, "GL_USES_POINT_COORD") != NULL;
-    }
-}
-
-void Shader::compileToHLSL(void *compiler)
-{
-    if(isCompiled() || !mSource)
-    {
-        return;
-    }
-
-    delete[] mInfoLog;
-    mInfoLog = NULL;
-
-    int compileOptions = SH_OBJECT_CODE;
-    std::string sourcePath;
-
-    int result;
-    if(sourcePath.empty())
-    {
-        result = ShCompile(compiler, &mSource, 1, compileOptions);
-    }
-    else
-    {
-        const char* sourceStrings[2] =
-        {
-            sourcePath.c_str(),
-            mSource
-        };
-
-        result = ShCompile(compiler, sourceStrings, 2, compileOptions | SH_SOURCE_PATH);
-    }
-
-    if(result)
-    {
-        int objCodeLen = 0;
-        ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &objCodeLen);
-        mHlsl = new char[objCodeLen];
-        ShGetObjectCode(compiler, mHlsl);
-    }
-    else
-    {
-        int infoLogLen = 0;
-        ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &infoLogLen);
-        mInfoLog = new char[infoLogLen];
-        ShGetInfoLog(compiler, mInfoLog);
-
-        TRACE("\n%s", mInfoLog);
-    }
-}
-
 GLenum Shader::parseType(const std::string &type)
 {
     if(type == "float")
@@ -359,7 +290,7 @@
 {
     if(x.type == y.type)
     {
-        return x.size > y.size;
+        return x.size() > y.size();
     }
 
     switch (x.type)
@@ -439,10 +370,12 @@
 
 VertexShader::VertexShader(ResourceManager *manager, GLuint handle) : Shader(manager, handle)
 {
+	vertexShader = 0;
 }
 
 VertexShader::~VertexShader()
 {
+	delete vertexShader;
 }
 
 GLenum VertexShader::getType()
@@ -452,61 +385,97 @@
 
 void VertexShader::compile()
 {
-    compileToHLSL(mVertexCompiler);
-    parseAttributes();
-    parseVaryings();
+	clear();
+	initializeCompiler();
+
+	delete vertexShader;
+	vertexShader = new sw::VertexShader();
+
+	TranslatorASM *assembler = new TranslatorASM(this, SH_VERTEX_SHADER, SH_GLES2_SPEC);
+
+	ShBuiltInResources resources;
+	ShInitBuiltInResources(&resources);     
+	resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
+	resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
+	resources.MaxVaryingVectors = MAX_VARYING_VECTORS;
+	resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+	resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+	resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
+	resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
+	resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
+	resources.OES_standard_derivatives = 1;
+	assembler->Init(resources);
+
+	// Ensure we don't pass a NULL source to the compiler
+    char *source = "\0";
+	if(mSource)
+    {
+        source = mSource;
+    }
+
+	int success = ShCompile(assembler, &source, 1, SH_OBJECT_CODE);
+
+	if(false)
+	{
+		static int serial = 1;
+		char buffer[256];
+		sprintf(buffer, "vertex-input-%d-%d.txt", getHandle(), serial);
+		FILE *file = fopen(buffer, "wt");
+		fprintf(file, mSource);
+		fclose(file);
+		vertexShader->print("vertex-output-%d-%d.txt", getHandle(), serial);
+		serial++;
+	}
+
+	if(!success)
+	{
+		delete vertexShader;
+		vertexShader = 0;
+
+		int infoLogLen = 0;
+        ShGetInfo(assembler, SH_INFO_LOG_LENGTH, &infoLogLen);
+        mInfoLog = new char[infoLogLen];
+        ShGetInfoLog(assembler, mInfoLog);
+        TRACE("\n%s", mInfoLog);
+	}
+
+	delete assembler;
 }
 
 int VertexShader::getSemanticIndex(const std::string &attributeName)
 {
     if(!attributeName.empty())
     {
-        int semanticIndex = 0;
-        for(AttributeArray::iterator attribute = mAttributes.begin(); attribute != mAttributes.end(); attribute++)
+		for(sh::ActiveAttributes::iterator attribute = activeAttributes.begin(); attribute != activeAttributes.end(); attribute++)
         {
             if(attribute->name == attributeName)
             {
-                return semanticIndex;
+				return attribute->registerIndex;
             }
-
-            semanticIndex += VariableRowCount(attribute->type);
         }
     }
 
     return -1;
 }
 
-void VertexShader::parseAttributes()
+sw::Shader *VertexShader::getShader() const
 {
-    if(mHlsl)
-    {
-        const char *input = strstr(mHlsl, "// Attributes") + 14;
+	return vertexShader;
+}
 
-        while(true)
-        {
-            char attributeType[256];
-            char attributeName[256];
-
-            int matches = sscanf(input, "static %255s _%255s", attributeType, attributeName);
-
-            if(matches != 2)
-            {
-                break;
-            }
-
-            mAttributes.push_back(Attribute(parseType(attributeType), attributeName));
-
-            input = strstr(input, ";") + 2;
-        }
-    }
+sw::VertexShader *VertexShader::getVertexShader() const
+{
+	return vertexShader;
 }
 
 FragmentShader::FragmentShader(ResourceManager *manager, GLuint handle) : Shader(manager, handle)
 {
+	pixelShader = 0;
 }
 
 FragmentShader::~FragmentShader()
 {
+	delete pixelShader;
 }
 
 GLenum FragmentShader::getType()
@@ -516,8 +485,70 @@
 
 void FragmentShader::compile()
 {
-    compileToHLSL(mFragmentCompiler);
-    parseVaryings();
-    varyings.sort(compareVarying);
+	clear();
+	initializeCompiler();
+
+	delete pixelShader;
+	pixelShader = new sw::PixelShader();
+
+	TranslatorASM *assembler = new TranslatorASM(this, SH_FRAGMENT_SHADER, SH_GLES2_SPEC);
+
+	ShBuiltInResources resources;
+	ShInitBuiltInResources(&resources);     
+	resources.MaxVertexAttribs = MAX_VERTEX_ATTRIBS;
+	resources.MaxVertexUniformVectors = MAX_VERTEX_UNIFORM_VECTORS;
+	resources.MaxVaryingVectors = MAX_VARYING_VECTORS;
+	resources.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+	resources.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+	resources.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
+	resources.MaxFragmentUniformVectors = MAX_FRAGMENT_UNIFORM_VECTORS;
+	resources.MaxDrawBuffers = MAX_DRAW_BUFFERS;
+	resources.OES_standard_derivatives = 1;
+	assembler->Init(resources);
+
+	// Ensure we don't pass a NULL source to the compiler
+    char *source = "\0";
+	if(mSource)
+    {
+        source = mSource;
+    }
+
+	int success = ShCompile(assembler, &source, 1, SH_OBJECT_CODE);
+	
+	if(false)
+	{
+		static int serial = 1;
+		char buffer[256];
+		sprintf(buffer, "pixel-input-%d-%d.txt", getHandle(), serial);
+		FILE *file = fopen(buffer, "wt");
+		fprintf(file, mSource);
+		fclose(file);
+		pixelShader->print("pixel-output-%d-%d.txt", getHandle(), serial);
+		serial++;
+	}
+
+	if(!success)
+	{
+		delete pixelShader;
+		pixelShader = 0;
+
+		int infoLogLen = 0;
+        ShGetInfo(assembler, SH_INFO_LOG_LENGTH, &infoLogLen);
+        mInfoLog = new char[infoLogLen];
+        ShGetInfoLog(assembler, mInfoLog);
+        TRACE("\n%s", mInfoLog);
+	}
+
+	delete assembler;
+}
+
+sw::Shader *FragmentShader::getShader() const
+{
+	return pixelShader;
+}
+
+sw::PixelShader *FragmentShader::getPixelShader() const
+{
+	return pixelShader;
 }
 }
diff --git a/src/OpenGL ES 2.0/libGLESv2/Shader.h b/src/OpenGL ES 2.0/libGLESv2/Shader.h
index 52474ca..eaad0da 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Shader.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Shader.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Shader.h: Defines the abstract Shader class and its concrete derived
@@ -14,26 +19,41 @@
 
 #include "ResourceManager.h"
 
+#include "compiler/TranslatorASM.h"
+
 #define GL_APICALL
 #include <GLES2/gl2.h>
-#include <d3dx9.h>
 
 #include <list>
 #include <vector>
 
+namespace sh
+{
+	class OutputASM;
+}
+
 namespace gl
 {
 struct Varying
 {
-    Varying(GLenum type, const std::string &name, int size, bool array)
-        : type(type), name(name), size(size), array(array), reg(-1), col(-1)
+    Varying(GLenum type, const std::string &name, int arraySize, int reg = -1, int col = -1)
+        : type(type), name(name), arraySize(arraySize), reg(reg), col(col)
     {
     }
 
+	bool isArray() const
+	{
+		return arraySize >= 1;
+	}
+
+	int size() const   // Unify with gl::Uniform?
+	{
+		return arraySize > 0 ? arraySize : 1;
+	}
+
     GLenum type;
     std::string name;
-    int size;   // Number of 'type' elements
-    bool array;
+    int arraySize;
 
     int reg;    // First varying register, assigned during link
     int col;    // First register element, assigned during link
@@ -44,8 +64,9 @@
 class Shader
 {
     friend Program;
+	friend sh::OutputASM;
 
-  public:
+public:
     Shader(ResourceManager *manager, GLuint handle);
 
     virtual ~Shader();
@@ -62,7 +83,10 @@
 
     virtual void compile() = 0;
     bool isCompiled();
-    const char *getHLSL();
+    
+	virtual sw::Shader *getShader() const = 0;
+	virtual sw::PixelShader *getPixelShader() const;
+	virtual sw::VertexShader *getVertexShader() const;
 
     void addRef();
     void release();
@@ -72,58 +96,38 @@
 
     static void releaseCompiler();
 
-  protected:
-    DISALLOW_COPY_AND_ASSIGN(Shader);
-
-    void parseVaryings();
-
-    void compileToHLSL(void *compiler);
+protected:
+	void clear();
+	void initializeCompiler();
 
     static GLenum parseType(const std::string &type);
     static bool compareVarying(const Varying &x, const Varying &y);
 
-    const GLuint mHandle;
+	char *mSource;
+	char *mInfoLog;
+
+    VaryingList varyings;
+	sh::ActiveUniforms activeUniforms;
+	sh::ActiveAttributes activeAttributes;
+
+private:
+	DISALLOW_COPY_AND_ASSIGN(Shader);
+
+	const GLuint mHandle;
     unsigned int mRefCount;     // Number of program objects this shader is attached to
     bool mDeleteStatus;         // Flag to indicate that the shader can be deleted when no longer in use
 
-    char *mSource;
-    char *mHlsl;
-    char *mInfoLog;
+	ResourceManager *mResourceManager;
 
-    VaryingList varyings;
-
-    bool mUsesFragCoord;
-    bool mUsesFrontFacing;
-    bool mUsesPointSize;
-    bool mUsesPointCoord;
-
-    ResourceManager *mResourceManager;
-
-    static void *mFragmentCompiler;
-    static void *mVertexCompiler;
+	static void *mFragmentCompiler;
+	static void *mVertexCompiler;
 };
 
-struct Attribute
-{
-    Attribute() : type(GL_NONE), name("")
-    {
-    }
-
-    Attribute(GLenum type, const std::string &name) : type(type), name(name)
-    {
-    }
-
-    GLenum type;
-    std::string name;
-};
-
-typedef std::vector<Attribute> AttributeArray;
-
 class VertexShader : public Shader
 {
     friend Program;
 
-  public:
+public:
     VertexShader(ResourceManager *manager, GLuint handle);
 
     ~VertexShader();
@@ -132,17 +136,18 @@
     virtual void compile();
     int getSemanticIndex(const std::string &attributeName);
 
-  private:
+	virtual sw::Shader *getShader() const;
+	virtual sw::VertexShader *getVertexShader() const;
+
+private:
     DISALLOW_COPY_AND_ASSIGN(VertexShader);
 
-    void parseAttributes();
-
-    AttributeArray mAttributes;
+	sw::VertexShader *vertexShader;
 };
 
 class FragmentShader : public Shader
 {
-  public:
+public:
     FragmentShader(ResourceManager *manager, GLuint handle);
 
     ~FragmentShader();
@@ -150,8 +155,13 @@
     virtual GLenum getType();
     virtual void compile();
 
-  private:
+	virtual sw::Shader *getShader() const;
+	virtual sw::PixelShader *getPixelShader() const;
+
+private:
     DISALLOW_COPY_AND_ASSIGN(FragmentShader);
+
+	sw::PixelShader *pixelShader;
 };
 }
 
diff --git a/src/OpenGL ES 2.0/libGLESv2/Texture.cpp b/src/OpenGL ES 2.0/libGLESv2/Texture.cpp
index 7656ab4..b537581 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Texture.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/Texture.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Texture.cpp: Implements the Texture class and its derived classes
@@ -32,6 +37,14 @@
     {
         return sw::FORMAT_DXT1;
     }
+	else if(type == GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE)
+    {
+        return sw::FORMAT_DXT3;
+    }
+    else if(type == GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE)
+    {
+        return sw::FORMAT_DXT5;
+    }
     else
 	#endif
 	if(type == GL_FLOAT)
@@ -180,9 +193,8 @@
 void Texture::loadImageData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
                             GLint unpackAlignment, const void *input, size_t outputPitch, void *output, Image *image) const
 {
-    GLsizei inputPitch = -ComputePitch(width, format, type, unpackAlignment);
-    input = ((char*)input) - inputPitch * (height - 1);
-
+    GLsizei inputPitch = ComputePitch(width, format, type, unpackAlignment);
+    
     switch (type)
     {
       case GL_UNSIGNED_BYTE:
@@ -714,67 +726,6 @@
     }
 }
 
-void Texture::loadCompressedImageData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
-                                      int inputPitch, const void *input, size_t outputPitch, void *output) const
-{
-    ASSERT(xoffset % 4 == 0);
-    ASSERT(yoffset % 4 == 0);
-    ASSERT(width % 4 == 0 || width == 2 || width == 1);
-    ASSERT(inputPitch % 8 == 0);
-    ASSERT(outputPitch % 8 == 0);
-
-    const unsigned int *source = reinterpret_cast<const unsigned int*>(input);
-    unsigned int *dest = reinterpret_cast<unsigned int*>(output);
-
-    switch (height)
-    {
-        case 1:
-            // Round width up in case it is 1.
-            for(int x = 0; x < (width + 1) / 2; x += 2)
-            {
-                // First 32-bits is two RGB565 colors shared by tile and does not need to be modified.
-                dest[x] = source[x];
-
-                // Second 32-bits contains 4 rows of 4 2-bit interpolants between the colors, the last 3 rows being unused. No flipping should occur.
-                dest[x + 1] = source[x + 1];
-            }
-            break;
-        case 2:
-            // Round width up in case it is 1.
-            for(int x = 0; x < (width + 1) / 2; x += 2)
-            {
-                // First 32-bits is two RGB565 colors shared by tile and does not need to be modified.
-                dest[x] = source[x];
-
-                // Second 32-bits contains 4 rows of 4 2-bit interpolants between the colors, the last 2 rows being unused. Only the top 2 rows should be flipped.
-                dest[x + 1] = ((source[x + 1] << 8) & 0x0000FF00) |
-                              ((source[x + 1] >> 8) & 0x000000FF);       
-            }
-            break;
-        default:
-            ASSERT(height % 4 == 0);
-            for(int y = 0; y < height / 4; ++y)
-            {
-                const unsigned int *source = reinterpret_cast<const unsigned int*>(static_cast<const unsigned char*>(input) + y * inputPitch);
-                unsigned int *dest = reinterpret_cast<unsigned int*>(static_cast<unsigned char*>(output) + (y + yoffset) * outputPitch + xoffset * 8);
-
-                // Round width up in case it is 1.
-                for(int x = 0; x < (width + 1) / 2; x += 2)
-                {
-                    // First 32-bits is two RGB565 colors shared by tile and does not need to be modified.
-                    dest[x] = source[x];
-
-                    // Second 32-bits contains 4 rows of 4 2-bit interpolants between the colors. All rows should be flipped.
-                    dest[x + 1] = (source[x + 1] >> 24) | 
-                                  ((source[x + 1] << 8) & 0x00FF0000) |
-                                  ((source[x + 1] >> 8) & 0x0000FF00) |
-                                  (source[x + 1] << 24);                    
-                }
-            }
-            break;
-    }
-}
-
 void Texture::setImage(GLint unpackAlignment, const void *pixels, Image *image)
 {
     if(pixels && image)
@@ -797,9 +748,7 @@
 
         if(buffer)
         {
-            int inputPitch = ComputeCompressedPitch(image->getWidth(), image->getFormat());
-            int inputSize = ComputeCompressedSize(image->getWidth(), image->getHeight(), image->getFormat());
-            loadCompressedImageData(0, 0, image->getWidth(), image->getHeight(), -inputPitch, static_cast<const char*>(pixels) + inputSize - inputPitch, image->getPitch(), buffer);
+			memcpy(buffer, pixels, imageSize);
             image->unlock();
         }
     }
@@ -830,7 +779,7 @@
     if(pixels)
     {
 		void *buffer = image->lock(0, 0, sw::LOCK_WRITEONLY);
-        loadImageData(xoffset, transformPixelYOffset(yoffset, height, image->getHeight()), width, height, format, type, unpackAlignment, pixels, image->getPitch(), buffer, image);
+        loadImageData(xoffset, yoffset, width, height, format, type, unpackAlignment, pixels, image->getPitch(), buffer, image);
 		image->unlock();
     }
 }
@@ -856,8 +805,13 @@
     {
         void *buffer = image->lock(xoffset, yoffset, sw::LOCK_WRITEONLY);
         int inputPitch = ComputeCompressedPitch(width, format);
-        int inputSize = ComputeCompressedSize(width, height, format);
-        loadCompressedImageData(xoffset, transformPixelYOffset(yoffset, height, image->getHeight()), width, height, -inputPitch, static_cast<const char*>(pixels) + inputSize - inputPitch, image->getPitch(), buffer);
+		int rows = imageSize / inputPitch;
+		
+		for(int i = 0; i < rows; i++)
+		{
+			memcpy((void*)((BYTE*)buffer + i * image->getPitch()), (void*)((BYTE*)pixels + i * inputPitch), inputPitch);
+		}
+
         image->unlock();
     }
 }
@@ -866,7 +820,7 @@
 {
     Device *device = getDevice();
 	
-    sw::Rect destRect = {xoffset, yoffset, xoffset + (sourceRect.right - sourceRect.left), yoffset + (sourceRect.bottom - sourceRect.top)};
+    sw::Rect destRect = {xoffset, yoffset, xoffset + (sourceRect.x1 - sourceRect.x0), yoffset + (sourceRect.y1 - sourceRect.y0)};
     bool success = device->stretchRect(source, &sourceRect, dest, &destRect, false);
 
     if(!success)
@@ -921,14 +875,14 @@
     return GL_TEXTURE_2D;
 }
 
-GLsizei Texture2D::getWidth() const
+GLsizei Texture2D::getWidth(GLint level) const
 {
-    return image[0] ? image[0]->getWidth() : 0;
+    return image[level] ? image[level]->getWidth() : 0;
 }
 
-GLsizei Texture2D::getHeight() const
+GLsizei Texture2D::getHeight(GLint level) const
 {
-    return image[0] ? image[0]->getHeight() : 0;
+    return image[level] ? image[level]->getHeight() : 0;
 }
 
 GLenum Texture2D::getFormat() const
@@ -965,7 +919,7 @@
 		image[level]->unbind();
 	}
 
-	image[level] = new Image(getResource(), width, height, format, type);
+	image[level] = new Image(resource, width, height, format, type);
 
 	if(!image[level])
 	{
@@ -1005,6 +959,7 @@
 
 	image[0] = surface->getRenderTarget();
 	image[0]->bind();
+	image[0]->release();
 
     mSurface = surface;
     mSurface->setBoundTexture(this);
@@ -1024,6 +979,20 @@
 
 void Texture2D::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels)
 {
+	if(image[level])
+	{
+		image[level]->unbind();
+	}
+
+	image[level] = new Image(resource, width, height, format, GL_UNSIGNED_BYTE);
+
+	if(!image[level])
+	{
+		return error(GL_OUT_OF_MEMORY);
+	}
+
+	image[level]->bind();
+
     Texture::setCompressedImage(imageSize, pixels, image[level]);
 }
 
@@ -1052,7 +1021,7 @@
 		image[level]->unbind();
 	}
 
-	image[level] = new Image(getResource(), width, height, format, GL_UNSIGNED_BYTE);
+	image[level] = new Image(resource, width, height, format, GL_UNSIGNED_BYTE);
 
 	if(!image[level])
 	{
@@ -1063,16 +1032,13 @@
 
     if(width != 0 && height != 0)
     {
-        sw::Rect sourceRect = transformPixelRect(x, y, width, height, source->getColorbuffer()->getHeight());
-        sourceRect.left = clamp(sourceRect.left, 0, source->getColorbuffer()->getWidth());
-        sourceRect.top = clamp(sourceRect.top, 0, source->getColorbuffer()->getHeight());
-        sourceRect.right = clamp(sourceRect.right, 0, source->getColorbuffer()->getWidth());
-        sourceRect.bottom = clamp(sourceRect.bottom, 0, source->getColorbuffer()->getHeight());
+		sw::Rect sourceRect = {x, y, x + width, y + height};
+		sourceRect.clip(0, 0, source->getColorbuffer()->getWidth(), source->getColorbuffer()->getHeight());
 
-        GLint destYOffset = transformPixelYOffset(0, height, image[level]->getHeight());
-        
-        copy(source->getRenderTarget(), sourceRect, format, 0, destYOffset, image[level]);
+        copy(renderTarget, sourceRect, format, 0, 0, image[level]);
     }
+
+	renderTarget->release();
 }
 
 void Texture2D::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source)
@@ -1095,19 +1061,16 @@
         return error(GL_OUT_OF_MEMORY);
     }
 
-    sw::Rect sourceRect = transformPixelRect(x, y, width, height, source->getColorbuffer()->getHeight());
-    sourceRect.left = clamp(sourceRect.left, 0, source->getColorbuffer()->getWidth());
-    sourceRect.top = clamp(sourceRect.top, 0, source->getColorbuffer()->getHeight());
-    sourceRect.right = clamp(sourceRect.right, 0, source->getColorbuffer()->getWidth());
-    sourceRect.bottom = clamp(sourceRect.bottom, 0, source->getColorbuffer()->getHeight());
+	sw::Rect sourceRect = {x, y, x + width, y + height};
+	sourceRect.clip(0, 0, source->getColorbuffer()->getWidth(), source->getColorbuffer()->getHeight());
 
-    GLint destYOffset = transformPixelYOffset(yoffset, height, image[level]->getHeight());
+	copy(renderTarget, sourceRect, image[level]->getFormat(), xoffset, yoffset, image[level]);
 
-	copy(source->getRenderTarget(), sourceRect, image[level]->getFormat(), xoffset, destYOffset, image[level]);
+	renderTarget->release();
 }
 
-// Tests for GL texture object completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
-bool Texture2D::isComplete() const
+// Tests for 2D texture sampling completeness. [OpenGL ES 2.0.24] section 3.8.2 page 85.
+bool Texture2D::isSamplerComplete() const
 {
 	if(!image[0])
 	{
@@ -1141,34 +1104,48 @@
 
     if(mipmapping)
     {
-        int q = log2(std::max(width, height));
-
-        for(int level = 1; level <= q; level++)
+        if(!isMipmapComplete())
         {
-			if(!image[level])
-			{
-				return false;
-			}
+            return false;
+        }
+    }
 
-            if(image[level]->getFormat() != image[0]->getFormat())
-            {
-                return false;
-            }
+    return true;
+}
 
-            if(image[level]->getType() != image[0]->getType())
-            {
-                return false;
-            }
+// Tests for 2D texture (mipmap) completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
+bool Texture2D::isMipmapComplete() const
+{
+    GLsizei width = image[0]->getWidth();
+    GLsizei height = image[0]->getHeight();
 
-            if(image[level]->getWidth() != std::max(1, width >> level))
-            {
-                return false;
-            }
+    int q = log2(std::max(width, height));
 
-            if(image[level]->getHeight() != std::max(1, height >> level))
-            {
-                return false;
-            }
+    for(int level = 1; level <= q; level++)
+    {
+		if(!image[level])
+		{
+			return false;
+		}
+
+        if(image[level]->getFormat() != image[0]->getFormat())
+        {
+            return false;
+        }
+
+        if(image[level]->getType() != image[0]->getType())
+        {
+            return false;
+        }
+
+        if(image[level]->getWidth() != std::max(1, width >> level))
+        {
+            return false;
+        }
+
+        if(image[level]->getHeight() != std::max(1, height >> level))
+        {
+            return false;
         }
     }
 
@@ -1196,7 +1173,7 @@
 			image[i]->unbind();
 		}
 
-		image[i] = new Image(getResource(), std::max(image[0]->getWidth() >> i, 1), std::max(image[0]->getHeight() >> i, 1), image[0]->getFormat(), image[0]->getType());
+		image[i] = new Image(resource, std::max(image[0]->getWidth() >> i, 1), std::max(image[0]->getHeight() >> i, 1), image[0]->getFormat(), image[0]->getType());
 
 		if(!image[i])
 		{
@@ -1286,14 +1263,14 @@
     return GL_TEXTURE_CUBE_MAP;
 }
 
-GLsizei TextureCubeMap::getWidth() const
+GLsizei TextureCubeMap::getWidth(GLint level) const
 {
-    return image[0][0] ? image[0][0]->getWidth() : 0;
+    return image[0][level] ? image[0][level]->getWidth() : 0;
 }
 
-GLsizei TextureCubeMap::getHeight() const
+GLsizei TextureCubeMap::getHeight(GLint level) const
 {
-    return image[0][0] ? image[0][0]->getHeight() : 0;
+    return image[0][level] ? image[0][level]->getHeight() : 0;
 }
 
 GLenum TextureCubeMap::getFormat() const
@@ -1354,8 +1331,8 @@
     Texture::subImageCompressed(xoffset, yoffset, width, height, format, imageSize, pixels, image[ConvertCubeFace(target)][level]);
 }
 
-// Tests for GL texture object completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
-bool TextureCubeMap::isComplete() const
+// Tests for cube map sampling completeness. [OpenGL ES 2.0.24] section 3.8.2 page 86.
+bool TextureCubeMap::isSamplerComplete() const
 {
 	for(int face = 0; face < 6; face++)
     {
@@ -1374,7 +1351,7 @@
 
     bool mipmapping;
 
-    switch (mMinFilter)
+    switch(mMinFilter)
     {
     case GL_NEAREST:
     case GL_LINEAR:
@@ -1389,43 +1366,78 @@
     default: UNREACHABLE();
     }
 
-    for(int face = 0; face < 6; face++)
+    if(!mipmapping)
     {
-        if(image[face][0]->getWidth() != size || image[face][0]->getHeight() != size)
+        if(!isCubeComplete())
+        {
+            return false;
+        }
+    }
+    else
+    {
+        if(!isMipmapCubeComplete())   // Also tests for isCubeComplete()
         {
             return false;
         }
     }
 
-    if(mipmapping)
+    return true;
+}
+
+// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
+bool TextureCubeMap::isCubeComplete() const
+{
+    if(image[0][0]->getWidth() <= 0 || image[0][0]->getHeight() != image[0][0]->getWidth())
     {
-        int q = log2(size);
+        return false;
+    }
 
-        for(int face = 0; face < 6; face++)
+    for(unsigned int face = 1; face < 6; face++)
+    {
+        if(image[face][0]->getWidth()  != image[0][0]->getWidth() ||
+           image[face][0]->getWidth()  != image[0][0]->getHeight() ||
+           image[face][0]->getFormat() != image[0][0]->getFormat() ||
+           image[face][0]->getType()   != image[0][0]->getType())
         {
-            for(int level = 1; level <= q; level++)
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool TextureCubeMap::isMipmapCubeComplete() const
+{
+    if(!isCubeComplete())
+    {
+        return false;
+    }
+
+    GLsizei size = image[0][0]->getWidth();
+    int q = log2(size);
+
+    for(int face = 0; face < 6; face++)
+    {
+        for(int level = 1; level <= q; level++)
+        {
+			if(!image[face][level])
+			{
+				return false;
+			}
+
+            if(image[face][level]->getFormat() != image[0][0]->getFormat())
             {
-				if(!image[face][level])
-				{
-					return false;
-				}
+                return false;
+            }
 
-                if(image[face][level]->getFormat() != image[0][0]->getFormat())
-                {
-                    return false;
-                }
+            if(image[face][level]->getType() != image[0][0]->getType())
+            {
+                return false;
+            }
 
-                if(image[face][level]->getType() != image[0][0]->getType())
-                {
-                    return false;
-                }
-
-                if(image[face][level]->getWidth() != std::max(1, size >> level))
-                {
-                    return false;
-                }
-
-                ASSERT(image[face][level]->getHeight() == image[face][level]->getWidth());
+            if(image[face][level]->getWidth() != std::max(1, size >> level))
+            {
+                return false;
             }
         }
     }
@@ -1487,16 +1499,13 @@
 
     if(width != 0 && height != 0)
     {
-        sw::Rect sourceRect = transformPixelRect(x, y, width, height, source->getColorbuffer()->getHeight());
-        sourceRect.left = clamp(sourceRect.left, 0, source->getColorbuffer()->getWidth());
-        sourceRect.top = clamp(sourceRect.top, 0, source->getColorbuffer()->getHeight());
-        sourceRect.right = clamp(sourceRect.right, 0, source->getColorbuffer()->getWidth());
-        sourceRect.bottom = clamp(sourceRect.bottom, 0, source->getColorbuffer()->getHeight());
-
-        GLint destYOffset = transformPixelYOffset(0, height, image[face][level]->getHeight());
+		sw::Rect sourceRect = {x, y, x + width, y + height};
+		sourceRect.clip(0, 0, source->getColorbuffer()->getWidth(), source->getColorbuffer()->getHeight());
         
-        copy(source->getRenderTarget(), sourceRect, format, 0, destYOffset, image[face][level]);
+        copy(renderTarget, sourceRect, format, 0, 0, image[face][level]);
     }
+
+	renderTarget->release();
 }
 
 Image *TextureCubeMap::getImage(CubeFace face, unsigned int level)
@@ -1525,7 +1534,7 @@
         return error(GL_INVALID_VALUE);
     }
 
-     Image *renderTarget = source->getRenderTarget();
+    Image *renderTarget = source->getRenderTarget();
 
     if(!renderTarget)
     {
@@ -1533,41 +1542,12 @@
         return error(GL_OUT_OF_MEMORY);
     }
 
-    sw::Rect sourceRect = transformPixelRect(x, y, width, height, source->getColorbuffer()->getHeight());
-    sourceRect.left = clamp(sourceRect.left, 0, source->getColorbuffer()->getWidth());
-    sourceRect.top = clamp(sourceRect.top, 0, source->getColorbuffer()->getHeight());
-    sourceRect.right = clamp(sourceRect.right, 0, source->getColorbuffer()->getWidth());
-    sourceRect.bottom = clamp(sourceRect.bottom, 0, source->getColorbuffer()->getHeight());
+	sw::Rect sourceRect = {x, y, x + width, y + height};
+	sourceRect.clip(0, 0, source->getColorbuffer()->getWidth(), source->getColorbuffer()->getHeight());
 
-    GLint destYOffset = transformPixelYOffset(yoffset, height, image[face][level]->getHeight());
+	copy(renderTarget, sourceRect, image[face][level]->getFormat(), xoffset, yoffset, image[face][level]);
 
-	copy(source->getRenderTarget(), sourceRect, image[face][level]->getFormat(), xoffset, destYOffset, image[face][level]);
-}
-
-bool TextureCubeMap::isCubeComplete() const
-{
-	for(unsigned int f = 1; f < 6; f++)
-    {
-		if(!image[f][0])
-		{
-			return false;
-		}
-	}
-
-    if(image[0][0]->getWidth() == 0)
-    {
-        return false;
-    }
-
-    for(unsigned int f = 1; f < 6; f++)
-    {
-        if(image[f][0]->getWidth() != image[0][0]->getWidth() || image[f][0]->getFormat() != image[0][0]->getFormat())
-        {
-            return false;
-        }
-    }
-
-    return true;
+	renderTarget->release();
 }
 
 void TextureCubeMap::generateMipmaps()
diff --git a/src/OpenGL ES 2.0/libGLESv2/Texture.h b/src/OpenGL ES 2.0/libGLESv2/Texture.h
index 6ccb1d4..f5c46b0 100644
--- a/src/OpenGL ES 2.0/libGLESv2/Texture.h
+++ b/src/OpenGL ES 2.0/libGLESv2/Texture.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // Texture.h: Defines the abstract Texture class and its concrete derived
@@ -64,14 +69,14 @@
     GLenum getWrapS() const;
     GLenum getWrapT() const;
 
-    virtual GLsizei getWidth() const = 0;
-    virtual GLsizei getHeight() const = 0;
+    virtual GLsizei getWidth(GLint level = 0) const = 0;
+    virtual GLsizei getHeight(GLint level = 0) const = 0;
     virtual GLenum getFormat() const = 0;
     virtual GLenum getType() const = 0;
     virtual sw::Format getInternalFormat() const = 0;
 	virtual int getLevelCount() const = 0;
 
-    virtual bool isComplete() const = 0;
+    virtual bool isSamplerComplete() const = 0;
     virtual bool isCompressed() const = 0;
 
     virtual Renderbuffer *getRenderbuffer(GLenum target) = 0;
@@ -143,8 +148,6 @@
                                     int inputPitch, const void *input, size_t outputPitch, void *output) const;
     void loadBGRAImageData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
                            int inputPitch, const void *input, size_t outputPitch, void *output) const;
-    void loadCompressedImageData(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
-                                 int inputPitch, const void *input, size_t outputPitch, void *output) const;
 };
 
 class Texture2D : public Texture
@@ -158,8 +161,8 @@
 
     virtual GLenum getTarget() const;
 
-    virtual GLsizei getWidth() const;
-    virtual GLsizei getHeight() const;
+    virtual GLsizei getWidth(GLint level = 0) const;
+    virtual GLsizei getHeight(GLint level = 0) const;
     virtual GLenum getFormat() const;
     virtual GLenum getType() const;
     virtual sw::Format getInternalFormat() const;
@@ -172,7 +175,7 @@
     void copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
     void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
 
-    virtual bool isComplete() const;
+    virtual bool isSamplerComplete() const;
     virtual bool isCompressed() const;
     virtual void bindTexImage(egl::Surface *surface);
     virtual void releaseTexImage();
@@ -184,7 +187,9 @@
 	Image *getRenderTarget(GLenum target);
 
   private:
-	Image *image[MIPMAP_LEVELS];
+	bool isMipmapComplete() const;
+
+	Image *image[IMPLEMENTATION_MAX_TEXTURE_LEVELS];
     
     egl::Surface *mSurface;
     BindingPointer<Renderbuffer> mColorbufferProxy;
@@ -201,8 +206,8 @@
 
     virtual GLenum getTarget() const;
     
-    virtual GLsizei getWidth() const;
-    virtual GLsizei getHeight() const;
+    virtual GLsizei getWidth(GLint level = 0) const;
+    virtual GLsizei getHeight(GLint level = 0) const;
     virtual GLenum getFormat() const;
     virtual GLenum getType() const;
     virtual sw::Format getInternalFormat() const;
@@ -216,7 +221,7 @@
     void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
     virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
 
-    virtual bool isComplete() const;
+    virtual bool isSamplerComplete() const;
     virtual bool isCompressed() const;
 
     virtual void generateMipmaps();
@@ -227,6 +232,7 @@
 
   private:
 	bool isCubeComplete() const;
+	bool isMipmapCubeComplete() const;
 
     virtual Image *getRenderTarget(GLenum target);
 
diff --git a/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.cpp b/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.cpp
index 44abf4e..52e0e42 100644
--- a/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // VertexDataManager.h: Defines the VertexDataManager, a class that
@@ -11,7 +16,6 @@
 
 #include "Buffer.h"
 #include "Program.h"
-#include "main.h"
 #include "IndexDataManager.h"
 #include "common/debug.h"
 
@@ -23,7 +27,7 @@
 namespace gl
 {
 
-VertexDataManager::VertexDataManager(Context *context, Device *device) : mContext(context), mDevice(device)
+VertexDataManager::VertexDataManager(Context *context) : mContext(context)
 {
     for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
     {
@@ -31,7 +35,7 @@
         mCurrentValueBuffer[i] = NULL;
     }
 
-    mStreamingBuffer = new StreamingVertexBuffer(mDevice, INITIAL_STREAM_BUFFER_SIZE);
+    mStreamingBuffer = new StreamingVertexBuffer(INITIAL_STREAM_BUFFER_SIZE);
 
     if(!mStreamingBuffer)
     {
@@ -49,7 +53,7 @@
     }
 }
 
-UINT VertexDataManager::writeAttributeData(ArrayVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute)
+UINT VertexDataManager::writeAttributeData(StreamingVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute)
 {
     Buffer *buffer = attribute.mBoundBuffer.get();
 
@@ -61,7 +65,7 @@
     
     if(vertexBuffer)
     {
-        output = (char*)vertexBuffer->map(attribute, spaceRequired(attribute, count), &streamOffset);
+        output = (char*)vertexBuffer->map(attribute, attribute.typeSize() * count, &streamOffset);
     }
 
     if(output == NULL)
@@ -114,19 +118,14 @@
     const VertexAttributeArray &attribs = mContext->getVertexAttributes();
     Program *program = mContext->getCurrentProgram();
 
-    for(int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
-    {
-        translated[attributeIndex].active = (program->getSemanticIndex(attributeIndex) != -1);
-    }
-
-    // Determine the required storage size per used buffer, and invalidate static buffers that don't contain matching attributes
+    // Determine the required storage size per used buffer
     for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
     {
-        if(translated[i].active && attribs[i].mArrayEnabled)
+        if(program->getAttributeStream(i) != -1 && attribs[i].mArrayEnabled)
         {
             if(!attribs[i].mBoundBuffer)
             {
-                mStreamingBuffer->addRequiredSpace(spaceRequired(attribs[i], count));
+                mStreamingBuffer->addRequiredSpace(attribs[i].typeSize() * count);
             }
         }
     }
@@ -136,7 +135,7 @@
     // Perform the vertex data translations
     for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
     {
-        if(translated[i].active)
+        if(program->getAttributeStream(i) != -1)
         {
             if(attribs[i].mArrayEnabled)
             {
@@ -190,7 +189,7 @@
                 if(mDirtyCurrentValue[i])
                 {
                     delete mCurrentValueBuffer[i];
-                    mCurrentValueBuffer[i] = new ConstantVertexBuffer(mDevice, attribs[i].mCurrentValue[0], attribs[i].mCurrentValue[1], attribs[i].mCurrentValue[2], attribs[i].mCurrentValue[3]);
+                    mCurrentValueBuffer[i] = new ConstantVertexBuffer(attribs[i].mCurrentValue[0], attribs[i].mCurrentValue[1], attribs[i].mCurrentValue[2], attribs[i].mCurrentValue[3]);
                     mDirtyCurrentValue[i] = false;
                 }
 
@@ -207,12 +206,7 @@
     return GL_NO_ERROR;
 }
 
-std::size_t VertexDataManager::spaceRequired(const VertexAttribute &attrib, std::size_t count) const
-{
-	return attrib.typeSize() * count;
-}
-
-VertexBuffer::VertexBuffer(Device *device, std::size_t size) : mDevice(device), mVertexBuffer(NULL)
+VertexBuffer::VertexBuffer(std::size_t size) : mVertexBuffer(NULL)
 {
     if(size > 0)
     {
@@ -246,24 +240,12 @@
     return mVertexBuffer;
 }
 
-ConstantVertexBuffer::ConstantVertexBuffer(Device *device, float x, float y, float z, float w) : VertexBuffer(device, 4 * sizeof(float))
+ConstantVertexBuffer::ConstantVertexBuffer(float x, float y, float z, float w) : VertexBuffer(4 * sizeof(float))
 {
-    void *buffer = NULL;
-
     if(mVertexBuffer)
     {
-		buffer = mVertexBuffer->lock(sw::PUBLIC);
+		float *vector = (float*)mVertexBuffer->lock(sw::PUBLIC);
      
-        if(!buffer)
-        {
-            ERR("Lock failed");
-        }
-    }
-
-    if(buffer)
-    {
-        float *vector = (float*)buffer;
-
         vector[0] = x;
         vector[1] = y;
         vector[2] = z;
@@ -277,30 +259,22 @@
 {
 }
 
-ArrayVertexBuffer::ArrayVertexBuffer(Device *device, std::size_t size) : VertexBuffer(device, size)
+StreamingVertexBuffer::StreamingVertexBuffer(std::size_t size) : VertexBuffer(size)
 {
     mBufferSize = size;
     mWritePosition = 0;
     mRequiredSpace = 0;
 }
 
-ArrayVertexBuffer::~ArrayVertexBuffer()
-{
-}
-
-void ArrayVertexBuffer::addRequiredSpace(UINT requiredSpace)
-{
-    mRequiredSpace += requiredSpace;
-}
-
-StreamingVertexBuffer::StreamingVertexBuffer(Device *device, std::size_t initialSize) : ArrayVertexBuffer(device, initialSize)
-{
-}
-
 StreamingVertexBuffer::~StreamingVertexBuffer()
 {
 }
 
+void StreamingVertexBuffer::addRequiredSpace(UINT requiredSpace)
+{
+    mRequiredSpace += requiredSpace;
+}
+
 void *StreamingVertexBuffer::map(const VertexAttribute &attribute, std::size_t requiredSpace, std::size_t *offset)
 {
     void *mapPtr = NULL;
diff --git a/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.h b/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.h
index 2febc37..09f0e48 100644
--- a/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.h
+++ b/src/OpenGL ES 2.0/libGLESv2/VertexDataManager.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // VertexDataManager.h: Defines the VertexDataManager, a class that
@@ -16,16 +21,11 @@
 #define GL_APICALL
 #include <GLES2/gl2.h>
 
-#include <vector>
-#include <cstddef>
-
 namespace gl
 {
 
 struct TranslatedAttribute
 {
-    bool active;
-
     sw::StreamType type;
 	int count;
 	bool normalized;
@@ -39,7 +39,7 @@
 class VertexBuffer
 {
   public:
-    VertexBuffer(Device *device, UINT size);
+    VertexBuffer(UINT size);
     virtual ~VertexBuffer();
 
     void unmap();
@@ -47,29 +47,24 @@
     sw::Resource *getResource() const;
 
   protected:
-    Device *const mDevice;
     sw::Resource *mVertexBuffer;
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(VertexBuffer);
 };
 
 class ConstantVertexBuffer : public VertexBuffer
 {
   public:
-    ConstantVertexBuffer(Device *device, float x, float y, float z, float w);
+    ConstantVertexBuffer(float x, float y, float z, float w);
     ~ConstantVertexBuffer();
 };
 
-class ArrayVertexBuffer : public VertexBuffer
+class StreamingVertexBuffer : public VertexBuffer
 {
   public:
-    ArrayVertexBuffer(Device *device, UINT size);
-    ~ArrayVertexBuffer();
+    StreamingVertexBuffer(UINT size);
+    ~StreamingVertexBuffer();
 
-    UINT size() const { return mBufferSize; }
-    virtual void *map(const VertexAttribute &attribute, UINT requiredSpace, UINT *streamOffset) = 0;
-    virtual void reserveRequiredSpace() = 0;
+    void *map(const VertexAttribute &attribute, UINT requiredSpace, UINT *streamOffset);
+    void reserveRequiredSpace();
     void addRequiredSpace(UINT requiredSpace);
 
   protected:
@@ -78,20 +73,10 @@
     UINT mRequiredSpace;
 };
 
-class StreamingVertexBuffer : public ArrayVertexBuffer
-{
-  public:
-    StreamingVertexBuffer(Device *device, UINT initialSize);
-    ~StreamingVertexBuffer();
-
-    void *map(const VertexAttribute &attribute, UINT requiredSpace, UINT *streamOffset);
-    void reserveRequiredSpace();
-};
-
 class VertexDataManager
 {
   public:
-    VertexDataManager(Context *context, Device *backend);
+    VertexDataManager(Context *context);
     virtual ~VertexDataManager();
 
     void dirtyCurrentValue(int index) { mDirtyCurrentValue[index] = true; }
@@ -99,13 +84,9 @@
     GLenum prepareVertexData(GLint start, GLsizei count, TranslatedAttribute *outAttribs);
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(VertexDataManager);
-
-    UINT spaceRequired(const VertexAttribute &attrib, std::size_t count) const;
-    UINT writeAttributeData(ArrayVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute);
+    UINT writeAttributeData(StreamingVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute);
 
     Context *const mContext;
-    Device *const mDevice;
 
     StreamingVertexBuffer *mStreamingBuffer;
 
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.cpp b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.cpp
index ce9fb0a..ed23496 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.cpp
@@ -1,9 +1,13 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
 //
-
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
 // libGLESv2.cpp: Implements the exported OpenGL ES 2.0 functions.
 
 #include "main.h"
@@ -17,6 +21,7 @@
 #include "Renderbuffer.h"
 #include "Shader.h"
 #include "Texture.h"
+#include "Query.h"
 #include "common/debug.h"
 #include "common/version.h"
 
@@ -29,7 +34,7 @@
 
 bool validImageSize(GLint level, GLsizei width, GLsizei height)
 {
-    if(level < 0 || width < 0 || height < 0)
+    if(level < 0 || level >= gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS || width < 0 || height < 0)
     {
         return false;
     }
@@ -37,6 +42,82 @@
     return true;
 }
 
+bool validateSubImageParams(bool compressed, GLsizei width, GLsizei height, GLint xoffset, GLint yoffset, GLint level, GLenum format, gl::Texture *texture)
+{
+    if(!texture)
+    {
+        return error(GL_INVALID_OPERATION, false);
+    }
+
+    if(compressed != texture->isCompressed())
+    {
+        return error(GL_INVALID_OPERATION, false);
+    }
+
+    if(format != GL_NONE && format != texture->getFormat())
+    {
+        return error(GL_INVALID_OPERATION, false);
+    }
+
+    if(compressed)
+    {
+        if((width % 4 != 0 && width != texture->getWidth(0)) || 
+           (height % 4 != 0 && height != texture->getHeight(0)))
+        {
+            return error(GL_INVALID_OPERATION, false);
+        }
+    }
+
+    if(xoffset + width > texture->getWidth(level) ||
+       yoffset + height > texture->getHeight(level))
+    {
+        return error(GL_INVALID_VALUE, false);
+    }
+
+    return true;
+}
+
+// Check for combinations of format and type that are valid for ReadPixels
+bool validReadFormatType(GLenum format, GLenum type)
+{
+    switch(format)
+    {
+    case GL_RGBA:
+        switch (type)
+        {
+        case GL_UNSIGNED_BYTE:
+            break;
+        default:
+            return false;
+        }
+        break;
+    case GL_BGRA_EXT:
+        switch (type)
+        {
+        case GL_UNSIGNED_BYTE:
+        case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
+        case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
+            break;
+        default:
+            return false;
+        }
+        break;
+    case gl::IMPLEMENTATION_COLOR_READ_FORMAT:
+        switch (type)
+        {
+        case gl::IMPLEMENTATION_COLOR_READ_TYPE:
+            break;
+        default:
+            return false;
+        }
+        break;
+    default:
+        return false;
+    }
+
+    return true;
+}
+
 extern "C"
 {
 
@@ -113,6 +194,39 @@
     }
 }
 
+void __stdcall glBeginQueryEXT(GLenum target, GLuint id)
+{
+    TRACE("(GLenum target = 0x%X, GLuint %d)", target, id);
+
+    try
+    {
+        switch(target)
+        {
+        case GL_ANY_SAMPLES_PASSED_EXT: 
+        case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+            break;
+        default: 
+            return error(GL_INVALID_ENUM);
+        }
+
+        if(id == 0)
+        {
+            return error(GL_INVALID_OPERATION);
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            context->beginQuery(target, id);
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY);
+    }
+}
+
 void __stdcall glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
 {
     TRACE("(GLuint program = %d, GLuint index = %d, const GLchar* name = 0x%0.8p)", program, index, name);
@@ -166,7 +280,7 @@
 
         if(context)
         {
-            switch (target)
+            switch(target)
             {
               case GL_ARRAY_BUFFER:
                 context->bindArrayBuffer(buffer);
@@ -258,7 +372,7 @@
                 return error(GL_INVALID_OPERATION);
             }
 
-            switch (target)
+            switch(target)
             {
               case GL_TEXTURE_2D:
                 context->bindTexture2D(texture);
@@ -308,7 +422,7 @@
 
     try
     {
-        switch (modeRGB)
+        switch(modeRGB)
         {
           case GL_FUNC_ADD:
           case GL_FUNC_SUBTRACT:
@@ -318,7 +432,7 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (modeAlpha)
+        switch(modeAlpha)
         {
           case GL_FUNC_ADD:
           case GL_FUNC_SUBTRACT:
@@ -353,7 +467,7 @@
 
     try
     {
-        switch (srcRGB)
+        switch(srcRGB)
         {
           case GL_ZERO:
           case GL_ONE:
@@ -375,7 +489,7 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (dstRGB)
+        switch(dstRGB)
         {
           case GL_ZERO:
           case GL_ONE:
@@ -396,7 +510,7 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (srcAlpha)
+        switch(srcAlpha)
         {
           case GL_ZERO:
           case GL_ONE:
@@ -418,7 +532,7 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (dstAlpha)
+        switch(dstAlpha)
         {
           case GL_ZERO:
           case GL_ONE:
@@ -464,7 +578,7 @@
             return error(GL_INVALID_VALUE);
         }
 
-        switch (usage)
+        switch(usage)
         {
           case GL_STREAM_DRAW:
           case GL_STATIC_DRAW:
@@ -480,7 +594,7 @@
         {
             gl::Buffer *buffer;
 
-            switch (target)
+            switch(target)
             {
               case GL_ARRAY_BUFFER:
                 buffer = context->getArrayBuffer();
@@ -529,7 +643,7 @@
         {
             gl::Buffer *buffer;
 
-            switch (target)
+            switch(target)
             {
               case GL_ARRAY_BUFFER:
                 buffer = context->getArrayBuffer();
@@ -745,12 +859,18 @@
             return error(GL_INVALID_VALUE);
         }
 
-        switch (internalformat)
+        switch(internalformat)
         {
-          case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-          case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+		case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+		case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
+			if(!S3TC_SUPPORT)
+            {
+                return error(GL_INVALID_ENUM);
+            }
             break;
-          default:
+        default:
             return error(GL_INVALID_ENUM);
         }
 
@@ -768,7 +888,7 @@
                 return error(GL_INVALID_VALUE);
             }
 
-            switch (target)
+            switch(target)
             {
               case GL_TEXTURE_2D:
                 if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
@@ -789,7 +909,7 @@
                 }
 
                 if(width > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||
-                    height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
+                   height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
                 {
                     return error(GL_INVALID_VALUE);
                 }
@@ -798,11 +918,6 @@
                 return error(GL_INVALID_ENUM);
             }
 
-            if(!S3TC_SUPPORT)
-            {
-                return error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
-            }
-
             if(imageSize != gl::ComputeCompressedSize(width, height, internalformat))
             {
                 return error(GL_INVALID_VALUE);
@@ -828,7 +943,7 @@
                     return error(GL_INVALID_OPERATION);
                 }
 
-                switch (target)
+                switch(target)
                 {
                   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
                   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
@@ -870,12 +985,18 @@
             return error(GL_INVALID_VALUE);
         }
 
-        switch (format)
+        switch(format)
         {
-          case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-          case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+		case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+		case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
+			if(!S3TC_SUPPORT)
+            {
+                return error(GL_INVALID_ENUM);
+            }
             break;
-          default:
+        default:
             return error(GL_INVALID_ENUM);
         }
 
@@ -893,11 +1014,6 @@
                 return error(GL_INVALID_VALUE);
             }
 
-            if(!S3TC_SUPPORT)
-            {
-                return error(GL_INVALID_ENUM); // in this case, it's as though the format switch has failed.
-            }
-
             if(imageSize != gl::ComputeCompressedSize(width, height, format))
             {
                 return error(GL_INVALID_VALUE);
@@ -905,53 +1021,27 @@
 
             if(xoffset % 4 != 0 || yoffset % 4 != 0)
             {
-                return error(GL_INVALID_OPERATION); // we wait to check the offsets until this point, because the multiple-of-four restriction
-                                                    // does not exist unless DXT1 textures are supported.
+				// We wait to check the offsets until this point, because the multiple-of-four restriction does not exist unless DXT1 textures are supported
+                return error(GL_INVALID_OPERATION);
             }
 
             if(target == GL_TEXTURE_2D)
             {
                 gl::Texture2D *texture = context->getTexture2D();
 
-                if(!texture)
-                {
-                    return error(GL_INVALID_OPERATION);
-                }
-
-                if(!texture->isCompressed())
-                {
-                    return error(GL_INVALID_OPERATION);
-                }
-
-                if((width % 4 != 0 && width != texture->getWidth()) || 
-                    (height % 4 != 0 && height != texture->getHeight()))
-                {
-                    return error(GL_INVALID_OPERATION);
-                }
-
-                texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);
+                if(validateSubImageParams(true, width, height, xoffset, yoffset, level, format, texture))
+				{
+					texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);
+				}
             }
             else if(gl::IsCubemapTextureTarget(target))
             {
                 gl::TextureCubeMap *texture = context->getTextureCubeMap();
 
-                if(!texture)
-                {
-                    return error(GL_INVALID_OPERATION);
-                }
-
-                if(!texture->isCompressed())
-                {
-                    return error(GL_INVALID_OPERATION);
-                }
-
-                if((width % 4 != 0 && width != texture->getWidth()) || 
-                    (height % 4 != 0 && height != texture->getHeight()))
-                {
-                    return error(GL_INVALID_OPERATION);
-                }
-
-                texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+                if(validateSubImageParams(true, width, height, xoffset, yoffset, level, format, texture))
+				{
+					texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+				}
             }
             else
             {
@@ -987,7 +1077,7 @@
 
         if(context)
         {
-            switch (target)
+            switch(target)
             {
               case GL_TEXTURE_2D:
                 if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
@@ -1070,6 +1160,8 @@
                  break;
             case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
             case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+			case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+			case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
                 if(S3TC_SUPPORT)
                 {
                     return error(GL_INVALID_OPERATION);
@@ -1177,53 +1269,55 @@
             }
             else UNREACHABLE();
 
-            if(!texture)
-            {
-                return error(GL_INVALID_OPERATION);
-            }
+            if(!validateSubImageParams(false, width, height, xoffset, yoffset, level, GL_NONE, texture))
+			{
+				return;
+			}
 
             GLenum textureFormat = texture->getFormat();
 
             // [OpenGL ES 2.0.24] table 3.9
-            switch (textureFormat)
+            switch(textureFormat)
             {
-              case GL_ALPHA:
+            case GL_ALPHA:
                 if(colorbufferFormat != GL_ALPHA &&
-                    colorbufferFormat != GL_RGBA &&
-                    colorbufferFormat != GL_RGBA4 &&
-                    colorbufferFormat != GL_RGB5_A1 &&
-                    colorbufferFormat != GL_RGBA8_OES)
+                   colorbufferFormat != GL_RGBA &&
+                   colorbufferFormat != GL_RGBA4 &&
+                   colorbufferFormat != GL_RGB5_A1 &&
+                   colorbufferFormat != GL_RGBA8_OES)
                 {
                     return error(GL_INVALID_OPERATION);
                 }
                 break;
-              case GL_LUMINANCE:
-              case GL_RGB:
+            case GL_LUMINANCE:
+            case GL_RGB:
                 if(colorbufferFormat != GL_RGB &&
-                    colorbufferFormat != GL_RGB565 &&
-                    colorbufferFormat != GL_RGB8_OES &&
-                    colorbufferFormat != GL_RGBA &&
-                    colorbufferFormat != GL_RGBA4 &&
-                    colorbufferFormat != GL_RGB5_A1 &&
-                    colorbufferFormat != GL_RGBA8_OES)
+                   colorbufferFormat != GL_RGB565 &&
+                   colorbufferFormat != GL_RGB8_OES &&
+                   colorbufferFormat != GL_RGBA &&
+                   colorbufferFormat != GL_RGBA4 &&
+                   colorbufferFormat != GL_RGB5_A1 &&
+                   colorbufferFormat != GL_RGBA8_OES)
                 {
                     return error(GL_INVALID_OPERATION);
                 }
                 break;
-              case GL_LUMINANCE_ALPHA:
-              case GL_RGBA:
+            case GL_LUMINANCE_ALPHA:
+            case GL_RGBA:
                 if(colorbufferFormat != GL_RGBA &&
-                    colorbufferFormat != GL_RGBA4 &&
-                    colorbufferFormat != GL_RGB5_A1 &&
-                    colorbufferFormat != GL_RGBA8_OES)
+                   colorbufferFormat != GL_RGBA4 &&
+                   colorbufferFormat != GL_RGB5_A1 &&
+                   colorbufferFormat != GL_RGBA8_OES)
                 {
                     return error(GL_INVALID_OPERATION);
                 }
                 break;
-              case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-              case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+            case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+            case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+			case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+			case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
                 return error(GL_INVALID_OPERATION);
-              default:
+            default:
                 return error(GL_INVALID_OPERATION);
             }
 
@@ -1268,7 +1362,7 @@
 
         if(context)
         {
-            switch (type)
+            switch(type)
             {
               case GL_FRAGMENT_SHADER:
               case GL_VERTEX_SHADER:
@@ -1292,7 +1386,7 @@
 
     try
     {
-        switch (mode)
+        switch(mode)
         {
           case GL_FRONT:
           case GL_BACK:
@@ -1436,6 +1530,33 @@
     }
 }
 
+void __stdcall glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
+{
+    TRACE("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids);
+
+    try
+    {
+        if(n < 0)
+        {
+            return error(GL_INVALID_VALUE);
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            for(int i = 0; i < n; i++)
+            {
+                context->deleteQuery(ids[i]);
+            }
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY);
+    }
+}
+
 void __stdcall glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 {
     TRACE("(GLsizei n = %d, const GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);
@@ -1535,7 +1656,7 @@
 
     try
     {
-        switch (func)
+        switch(func)
         {
           case GL_NEVER:
           case GL_ALWAYS:
@@ -1664,7 +1785,7 @@
 
         if(context)
         {
-            switch (cap)
+            switch(cap)
             {
               case GL_CULL_FACE:                context->setCullFace(false);              break;
               case GL_POLYGON_OFFSET_FILL:      context->setPolygonOffsetFill(false);     break;
@@ -1750,7 +1871,7 @@
 
         if(context)
         {
-            switch (type)
+            switch(type)
             {
               case GL_UNSIGNED_BYTE:
               case GL_UNSIGNED_SHORT:
@@ -1779,7 +1900,7 @@
 
         if(context)
         {
-            switch (cap)
+            switch(cap)
             {
               case GL_CULL_FACE:                context->setCullFace(true);              break;
               case GL_POLYGON_OFFSET_FILL:      context->setPolygonOffsetFill(true);     break;
@@ -1825,6 +1946,34 @@
     }
 }
 
+void __stdcall glEndQueryEXT(GLenum target)
+{
+    TRACE("GLenum target = 0x%X)", target);
+
+    try
+    {
+        switch(target)
+        {
+        case GL_ANY_SAMPLES_PASSED_EXT: 
+        case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+            break;
+        default: 
+            return error(GL_INVALID_ENUM);
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            context->endQuery(target);
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY);
+    }
+}
+
 void __stdcall glFinishFenceNV(GLuint fence)
 {
     TRACE("(GLuint fence = %d)", fence);
@@ -1924,7 +2073,7 @@
                 return error(GL_INVALID_OPERATION);
             }
 
-            switch (attachment)
+            switch(attachment)
             {
               case GL_COLOR_ATTACHMENT0:
                 framebuffer->setColorbuffer(GL_RENDERBUFFER, renderbuffer);
@@ -1958,7 +2107,7 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (attachment)
+        switch(attachment)
         {
           case GL_COLOR_ATTACHMENT0:
           case GL_DEPTH_ATTACHMENT:
@@ -1990,7 +2139,7 @@
                     return error(GL_INVALID_OPERATION);
                 }
 
-                switch (textarget)
+                switch(textarget)
                 {
                   case GL_TEXTURE_2D:
                     if(tex->getTarget() != GL_TEXTURE_2D)
@@ -2039,7 +2188,7 @@
                 return error(GL_INVALID_OPERATION);
             }
 
-            switch (attachment)
+            switch(attachment)
             {
               case GL_COLOR_ATTACHMENT0:  framebuffer->setColorbuffer(textarget, texture);   break;
               case GL_DEPTH_ATTACHMENT:   framebuffer->setDepthbuffer(textarget, texture);   break;
@@ -2059,7 +2208,7 @@
 
     try
     {
-        switch (mode)
+        switch(mode)
         {
           case GL_CW:
           case GL_CCW:
@@ -2121,7 +2270,7 @@
         {
             gl::Texture *texture;
 
-            switch (target)
+            switch(target)
             {
               case GL_TEXTURE_2D:
                 texture = context->getTexture2D();
@@ -2203,6 +2352,33 @@
     }
 }
 
+void __stdcall glGenQueriesEXT(GLsizei n, GLuint* ids)
+{
+    TRACE("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids);
+
+    try
+    {
+        if(n < 0)
+        {
+            return error(GL_INVALID_VALUE);
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            for(int i = 0; i < n; i++)
+            {
+                ids[i] = context->createQuery();
+            }
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY);
+    }
+}
+
 void __stdcall glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 {
     TRACE("(GLsizei n = %d, GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);
@@ -2502,7 +2678,7 @@
         {
             gl::Buffer *buffer;
 
-            switch (target)
+            switch(target)
             {
               case GL_ARRAY_BUFFER:
                 buffer = context->getArrayBuffer();
@@ -2519,7 +2695,7 @@
                 return error(GL_INVALID_OPERATION);
             }
 
-            switch (pname)
+            switch(pname)
             {
               case GL_BUFFER_USAGE:
                 *params = buffer->usage();
@@ -2676,7 +2852,7 @@
 
             GLenum attachmentType;
             GLuint attachmentHandle;
-            switch (attachment)
+            switch(attachment)
             {
               case GL_COLOR_ATTACHMENT0:    
                 attachmentType = framebuffer->getColorbufferType();
@@ -2704,7 +2880,7 @@
             }
             else UNREACHABLE();
 
-            switch (pname)
+            switch(pname)
             {
               case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
                 *params = attachmentObjectType;
@@ -2757,6 +2933,13 @@
     }
 }
 
+GLenum __stdcall glGetGraphicsResetStatusEXT(void)
+{
+    TRACE("()");
+
+    return GL_NO_ERROR;
+}
+
 void __stdcall glGetIntegerv(GLenum pname, GLint* params)
 {
     TRACE("(GLenum pname = 0x%X, GLint* params = 0x%0.8p)", pname, params);
@@ -2839,7 +3022,7 @@
                 return error(GL_INVALID_VALUE);
             }
 
-            switch (pname)
+            switch(pname)
             {
               case GL_DELETE_STATUS:
                 *params = programObject->isFlaggedForDeletion();
@@ -2911,6 +3094,83 @@
     }
 }
 
+void __stdcall glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
+{
+    TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname, params);
+
+    try
+    {
+        switch(pname)
+        {
+        case GL_CURRENT_QUERY_EXT:
+            break;
+        default:
+            return error(GL_INVALID_ENUM);
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            params[0] = context->getActiveQuery(target);
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY);
+    }
+}
+
+void __stdcall glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
+{
+    TRACE("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params);
+
+    try
+    {
+        switch(pname)
+        {
+        case GL_QUERY_RESULT_EXT:
+        case GL_QUERY_RESULT_AVAILABLE_EXT:
+            break;
+        default:
+            return error(GL_INVALID_ENUM);
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            gl::Query *queryObject = context->getQuery(id, false, GL_NONE);
+
+            if(!queryObject)
+            {
+                return error(GL_INVALID_OPERATION);
+            }
+
+            if(context->getActiveQuery(queryObject->getType()) == id)
+            {
+                return error(GL_INVALID_OPERATION);
+            }
+
+            switch(pname)
+            {
+            case GL_QUERY_RESULT_EXT:
+                params[0] = queryObject->getResult();
+                break;
+            case GL_QUERY_RESULT_AVAILABLE_EXT:
+                params[0] = queryObject->isResultAvailable();
+                break;
+            default:
+                ASSERT(false);
+            }
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY);
+    }
+}
+
 void __stdcall glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
     TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);
@@ -2982,7 +3242,7 @@
                 return error(GL_INVALID_VALUE);
             }
 
-            switch (pname)
+            switch(pname)
             {
               case GL_SHADER_TYPE:
                 *params = shaderObject->getType();
@@ -3049,7 +3309,7 @@
 
     try
     {
-        switch (shadertype)
+        switch(shadertype)
         {
           case GL_VERTEX_SHADER:
           case GL_FRAGMENT_SHADER:
@@ -3058,12 +3318,12 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (precisiontype)
+        switch(precisiontype)
         {
           case GL_LOW_FLOAT:
           case GL_MEDIUM_FLOAT:
           case GL_HIGH_FLOAT:
-            // Assume IEEE 754 precision
+            // IEEE 754 single-precision
             range[0] = 127;
             range[1] = 127;
             *precision = 23;
@@ -3071,8 +3331,7 @@
           case GL_LOW_INT:
           case GL_MEDIUM_INT:
           case GL_HIGH_INT:
-            // Some (most) hardware only supports single-precision floating-point numbers,
-            // which can accurately represent integers up to +/-16777216
+            // Single-precision floating-point numbers can accurately represent integers up to +/-16777216
             range[0] = 24;
             range[1] = 24;
             *precision = 0;
@@ -3127,7 +3386,7 @@
     {
         gl::Context *context = gl::getContext();
 
-        switch (name)
+        switch(name)
         {
           case GL_VENDOR:
             return (GLubyte*)"TransGaming Inc.";
@@ -3163,7 +3422,7 @@
         {
             gl::Texture *texture;
 
-            switch (target)
+            switch(target)
             {
               case GL_TEXTURE_2D:
                 texture = context->getTexture2D();
@@ -3175,7 +3434,7 @@
                 return error(GL_INVALID_ENUM);
             }
 
-            switch (pname)
+            switch(pname)
             {
               case GL_TEXTURE_MAG_FILTER:
                 *params = (GLfloat)texture->getMagFilter();
@@ -3212,7 +3471,7 @@
         {
             gl::Texture *texture;
 
-            switch (target)
+            switch(target)
             {
               case GL_TEXTURE_2D:
                 texture = context->getTexture2D();
@@ -3224,7 +3483,7 @@
                 return error(GL_INVALID_ENUM);
             }
 
-            switch (pname)
+            switch(pname)
             {
               case GL_TEXTURE_MAG_FILTER:
                 *params = texture->getMagFilter();
@@ -3249,6 +3508,46 @@
     }
 }
 
+void __stdcall glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat* params)
+{
+    TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLfloat* params = 0x%0.8p)",
+          program, location, bufSize, params);
+
+    try
+    {
+        if(bufSize < 0)
+        {
+            return error(GL_INVALID_VALUE);
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            if(program == 0)
+            {
+                return error(GL_INVALID_VALUE);
+            }
+
+            gl::Program *programObject = context->getProgram(program);
+
+            if(!programObject || !programObject->isLinked())
+            {
+                return error(GL_INVALID_OPERATION);
+            }
+
+            if(!programObject->getUniformfv(location, &bufSize, params))
+            {
+                return error(GL_INVALID_OPERATION);
+            }
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY);
+    }
+}
+
 void __stdcall glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 {
     TRACE("(GLuint program = %d, GLint location = %d, GLfloat* params = 0x%0.8p)", program, location, params);
@@ -3271,7 +3570,52 @@
                 return error(GL_INVALID_OPERATION);
             }
 
-            if(!programObject->getUniformfv(location, params))
+            if(!programObject->getUniformfv(location, NULL, params))
+            {
+                return error(GL_INVALID_OPERATION);
+            }
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY);
+    }
+}
+
+void __stdcall glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint* params)
+{
+    TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLint* params = 0x%0.8p)", 
+          program, location, bufSize, params);
+
+    try
+    {
+        if(bufSize < 0)
+        {
+            return error(GL_INVALID_VALUE);
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            if(program == 0)
+            {
+                return error(GL_INVALID_VALUE);
+            }
+
+            gl::Program *programObject = context->getProgram(program);
+
+            if(!programObject || !programObject->isLinked())
+            {
+                return error(GL_INVALID_OPERATION);
+            }
+
+            if(!programObject)
+            {
+                return error(GL_INVALID_OPERATION);
+            }
+
+            if(!programObject->getUniformiv(location, &bufSize, params))
             {
                 return error(GL_INVALID_OPERATION);
             }
@@ -3310,7 +3654,7 @@
                 return error(GL_INVALID_OPERATION);
             }
 
-            if(!programObject->getUniformiv(location, params))
+            if(!programObject->getUniformiv(location, NULL, params))
             {
                 return error(GL_INVALID_OPERATION);
             }
@@ -3384,7 +3728,7 @@
 
             const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
 
-            switch (pname)
+            switch(pname)
             {
               case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
                 *params = (GLfloat)(attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
@@ -3437,7 +3781,7 @@
 
             const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
 
-            switch (pname)
+            switch(pname)
             {
               case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
                 *params = (attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
@@ -3509,7 +3853,7 @@
 
     try
     {
-        switch (mode)
+        switch(mode)
         {
           case GL_FASTEST:
           case GL_NICEST:
@@ -3520,7 +3864,7 @@
         }
 
         gl::Context *context = gl::getContext();
-        switch (target)
+        switch(target)
         {
           case GL_GENERATE_MIPMAP_HINT:
             if(context) context->setGenerateMipmapHint(mode);
@@ -3574,7 +3918,7 @@
 
         if(context)
         {
-            switch (cap)
+            switch(cap)
             {
               case GL_CULL_FACE:                return context->isCullFaceEnabled();
               case GL_POLYGON_OFFSET_FILL:      return context->isPolygonOffsetFillEnabled();
@@ -3678,6 +4022,37 @@
     return GL_FALSE;
 }
 
+GLboolean __stdcall glIsQueryEXT(GLuint id)
+{
+    TRACE("(GLuint id = %d)", id);
+
+    try
+    {
+        if(id == 0)
+        {
+            return GL_FALSE;
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            gl::Query *queryObject = context->getQuery(id, false, GL_NONE);
+
+            if(queryObject)
+            {
+                return GL_TRUE;
+            }
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY, GL_FALSE);
+    }
+
+    return GL_FALSE;
+}
+
 GLboolean __stdcall glIsRenderbuffer(GLuint renderbuffer)
 {
     TRACE("(GLuint renderbuffer = %d)", renderbuffer);
@@ -3823,7 +4198,7 @@
 
         if(context)
         {
-            switch (pname)
+            switch(pname)
             {
               case GL_UNPACK_ALIGNMENT:
                 if(param != 1 && param != 2 && param != 4 && param != 8)
@@ -3873,6 +4248,39 @@
     }
 }
 
+void __stdcall glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height,
+                                GLenum format, GLenum type, GLsizei bufSize,
+                                GLvoid *data)
+{
+    TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
+          "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufSize = 0x%d, GLvoid *data = 0x%0.8p)",
+          x, y, width, height, format, type, bufSize, data);
+
+    try
+    {
+        if(width < 0 || height < 0 || bufSize < 0)
+        {
+            return error(GL_INVALID_VALUE);
+        }
+
+        if(!validReadFormatType(format, type))
+        {
+            return error(GL_INVALID_OPERATION);
+        }
+
+        gl::Context *context = gl::getContext();
+
+        if(context)
+        {
+            context->readPixels(x, y, width, height, format, type, &bufSize, data);
+        }
+    }
+    catch(std::bad_alloc&)
+    {
+        return error(GL_OUT_OF_MEMORY);
+    }
+}
+
 void __stdcall glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
 {
     TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
@@ -3886,38 +4294,8 @@
             return error(GL_INVALID_VALUE);
         }
 
-        switch (format)
+        if(!validReadFormatType(format, type))
         {
-          case GL_RGBA:
-            switch (type)
-            {
-              case GL_UNSIGNED_BYTE:
-                break;
-              default:
-                return error(GL_INVALID_OPERATION);
-            }
-            break;
-          case GL_BGRA_EXT:
-            switch (type)
-            {
-              case GL_UNSIGNED_BYTE:
-              case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
-              case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
-                break;
-              default:
-                return error(GL_INVALID_OPERATION);
-            }
-            break;
-          case gl::IMPLEMENTATION_COLOR_READ_FORMAT:
-            switch (type)
-            {
-              case gl::IMPLEMENTATION_COLOR_READ_TYPE:
-                break;
-              default:
-                return error(GL_INVALID_OPERATION);
-            }
-            break;
-          default:
             return error(GL_INVALID_OPERATION);
         }
 
@@ -3925,7 +4303,7 @@
 
         if(context)
         {
-            context->readPixels(x, y, width, height, format, type, pixels);
+            context->readPixels(x, y, width, height, format, type, NULL, pixels);
         }
     }
     catch(std::bad_alloc&)
@@ -3955,7 +4333,7 @@
 
     try
     {
-        switch (target)
+        switch(target)
         {
           case GL_RENDERBUFFER:
             break;
@@ -3978,8 +4356,8 @@
         if(context)
         {
             if(width > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE || 
-                height > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||
-                samples > gl::IMPLEMENTATION_MAX_SAMPLES)
+               height > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||
+               samples > gl::IMPLEMENTATION_MAX_SAMPLES)
             {
                 return error(GL_INVALID_VALUE);
             }
@@ -3990,7 +4368,7 @@
                 return error(GL_INVALID_OPERATION);
             }
 
-            switch (internalformat)
+            switch(internalformat)
             {
               case GL_DEPTH_COMPONENT16:
                 context->setRenderbufferStorage(new gl::Depthbuffer(width, height, samples));
@@ -4165,7 +4543,7 @@
 
     try
     {
-        switch (face)
+        switch(face)
         {
           case GL_FRONT:
           case GL_BACK:
@@ -4175,7 +4553,7 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (func)
+        switch(func)
         {
           case GL_NEVER:
           case GL_ALWAYS:
@@ -4222,7 +4600,7 @@
 
     try
     {
-        switch (face)
+        switch(face)
         {
           case GL_FRONT:
           case GL_BACK:
@@ -4265,7 +4643,7 @@
 
     try
     {
-        switch (face)
+        switch(face)
         {
           case GL_FRONT:
           case GL_BACK:
@@ -4275,7 +4653,7 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (fail)
+        switch(fail)
         {
           case GL_ZERO:
           case GL_KEEP:
@@ -4290,7 +4668,7 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (zfail)
+        switch(zfail)
         {
           case GL_ZERO:
           case GL_KEEP:
@@ -4305,7 +4683,7 @@
             return error(GL_INVALID_ENUM);
         }
 
-        switch (zpass)
+        switch(zpass)
         {
           case GL_ZERO:
           case GL_KEEP:
@@ -4388,59 +4766,61 @@
             return error(GL_INVALID_OPERATION);
         }
 
-        switch (format)
+        switch(format)
         {
-          case GL_ALPHA:
-          case GL_LUMINANCE:
-          case GL_LUMINANCE_ALPHA:
-            switch (type)
+        case GL_ALPHA:
+        case GL_LUMINANCE:
+        case GL_LUMINANCE_ALPHA:
+            switch(type)
             {
-              case GL_UNSIGNED_BYTE:
-              case GL_FLOAT:
-              case GL_HALF_FLOAT_OES:
+            case GL_UNSIGNED_BYTE:
+            case GL_FLOAT:
+            case GL_HALF_FLOAT_OES:
                 break;
-              default:
+            default:
                 return error(GL_INVALID_ENUM);
             }
             break;
-          case GL_RGB:
-            switch (type)
+        case GL_RGB:
+            switch(type)
             {
-              case GL_UNSIGNED_BYTE:
-              case GL_UNSIGNED_SHORT_5_6_5:
-              case GL_FLOAT:
-              case GL_HALF_FLOAT_OES:
+            case GL_UNSIGNED_BYTE:
+            case GL_UNSIGNED_SHORT_5_6_5:
+            case GL_FLOAT:
+            case GL_HALF_FLOAT_OES:
                 break;
-              default:
+            default:
                 return error(GL_INVALID_ENUM);
             }
             break;
-          case GL_RGBA:
-            switch (type)
+        case GL_RGBA:
+            switch(type)
             {
-              case GL_UNSIGNED_BYTE:
-              case GL_UNSIGNED_SHORT_4_4_4_4:
-              case GL_UNSIGNED_SHORT_5_5_5_1:
-              case GL_FLOAT:
-              case GL_HALF_FLOAT_OES:
+            case GL_UNSIGNED_BYTE:
+            case GL_UNSIGNED_SHORT_4_4_4_4:
+            case GL_UNSIGNED_SHORT_5_5_5_1:
+            case GL_FLOAT:
+            case GL_HALF_FLOAT_OES:
                 break;
-              default:
+            default:
                 return error(GL_INVALID_ENUM);
             }
             break;
-          case GL_BGRA_EXT:
-            switch (type)
+        case GL_BGRA_EXT:
+            switch(type)
             {
-              case GL_UNSIGNED_BYTE:
+            case GL_UNSIGNED_BYTE:
                 break;
-              default:
+            default:
                 return error(GL_INVALID_ENUM);
             }
             break;
-          case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:  // error cases for compressed textures are handled below
-          case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:  // error cases for compressed textures are handled below
+        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+		case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+		case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
             break; 
-          default:
+        default:
             return error(GL_INVALID_VALUE);
         }
 
@@ -4453,7 +4833,7 @@
 
         if(context)
         {
-            switch (target)
+            switch(target)
             {
               case GL_TEXTURE_2D:
                 if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
@@ -4484,7 +4864,9 @@
             }
 
             if(format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
-               format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT)
+               format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
+			   format == GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE ||
+			   format == GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE)
             {
                 if(S3TC_SUPPORT)
                 {
@@ -4548,7 +4930,7 @@
         {
             gl::Texture *texture;
 
-            switch (target)
+            switch(target)
             {
               case GL_TEXTURE_2D:
                 texture = context->getTexture2D();
@@ -4560,7 +4942,7 @@
                 return error(GL_INVALID_ENUM);
             }
 
-            switch (pname)
+            switch(pname)
             {
               case GL_TEXTURE_WRAP_S:
                 if(!texture->setWrapS((GLenum)param))
@@ -4650,23 +5032,19 @@
             {
                 gl::Texture2D *texture = context->getTexture2D();
 
-                if(!texture)
-                {
-                    return error(GL_INVALID_OPERATION);
-                }
-
-                texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
+                if(validateSubImageParams(false, width, height, xoffset, yoffset, level, format, texture))
+				{
+					texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
+				}
             }
             else if(gl::IsCubemapTextureTarget(target))
             {
                 gl::TextureCubeMap *texture = context->getTextureCubeMap();
-
-                if(!texture)
-                {
-                    return error(GL_INVALID_OPERATION);
-                }
-
-                texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
+				
+				if(validateSubImageParams(false, width, height, xoffset, yoffset, level, format, texture))
+				{
+					texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
+				}
             }
             else
             {
@@ -5452,7 +5830,7 @@
             return error(GL_INVALID_VALUE);
         }
 
-        switch (type)
+        switch(type)
         {
           case GL_BYTE:
           case GL_UNSIGNED_BYTE:
@@ -5517,7 +5895,7 @@
 
     try
     {
-        switch (filter)
+        switch(filter)
         {
           case GL_NEAREST:
             break;
@@ -5593,6 +5971,17 @@
         {"glGetFenceivNV", (__eglMustCastToProperFunctionPointerType)glGetFenceivNV},
         {"glFinishFenceNV", (__eglMustCastToProperFunctionPointerType)glFinishFenceNV},
         {"glSetFenceNV", (__eglMustCastToProperFunctionPointerType)glSetFenceNV},
+		{"glGetGraphicsResetStatusEXT", (__eglMustCastToProperFunctionPointerType)glGetGraphicsResetStatusEXT},
+        {"glReadnPixelsEXT", (__eglMustCastToProperFunctionPointerType)glReadnPixelsEXT},
+        {"glGetnUniformfvEXT", (__eglMustCastToProperFunctionPointerType)glGetnUniformfvEXT},
+        {"glGetnUniformivEXT", (__eglMustCastToProperFunctionPointerType)glGetnUniformivEXT},
+		{"glGenQueriesEXT", (__eglMustCastToProperFunctionPointerType)glGenQueriesEXT},
+        {"glDeleteQueriesEXT", (__eglMustCastToProperFunctionPointerType)glDeleteQueriesEXT},
+        {"glIsQueryEXT", (__eglMustCastToProperFunctionPointerType)glIsQueryEXT},
+        {"glBeginQueryEXT", (__eglMustCastToProperFunctionPointerType)glBeginQueryEXT},
+        {"glEndQueryEXT", (__eglMustCastToProperFunctionPointerType)glEndQueryEXT},
+        {"glGetQueryivEXT", (__eglMustCastToProperFunctionPointerType)glGetQueryivEXT},
+        {"glGetQueryObjectuivEXT", (__eglMustCastToProperFunctionPointerType)glGetQueryObjectuivEXT},
     };
 
     for(int ext = 0; ext < sizeof(glExtensions) / sizeof(Extension); ext++)
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.def b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.def
index b78672f..fb7d171 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.def
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.def
@@ -154,6 +154,19 @@
     glIsFenceNV                     @155
     glSetFenceNV                    @156
     glTestFenceNV                   @157
+    ;glGetTranslatedShaderSourceANGLE @159
+    ;glTexStorage2DEXT               @160
+    glGetGraphicsResetStatusEXT     @161
+    glReadnPixelsEXT                @162
+    glGetnUniformfvEXT              @163
+    glGetnUniformivEXT              @164
+	glGenQueriesEXT                 @165
+    glDeleteQueriesEXT              @166
+    glIsQueryEXT                    @167
+    glBeginQueryEXT                 @168
+    glEndQueryEXT                   @169
+    glGetQueryivEXT                 @170
+    glGetQueryObjectuivEXT          @171
 
     ; EGL dependencies
     glCreateContext                 @144 NONAME
@@ -163,8 +176,8 @@
     glGetProcAddress                @148 NONAME
     glBindTexImage                  @158 NONAME
 
-	createFrameBuffer               @159 NONAME
-	createBackBuffer                @160 NONAME
-	createDevice                    @161 NONAME
+	createFrameBuffer               @172 NONAME
+	createBackBuffer                @173 NONAME
+	createDevice                    @174 NONAME
 
 	Register
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.rc b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.rc
index 5284f2e..919c7ed 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.rc
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.rc
@@ -73,7 +73,7 @@
             VALUE "FileDescription", "SwiftShader libGLESv2 Dynamic Link Library"
             VALUE "FileVersion", VERSION_STRING
             VALUE "InternalName", "libGLESv2"
-            VALUE "LegalCopyright", "Copyright (C) 2011 TransGaming Inc."
+            VALUE "LegalCopyright", "Copyright (C) 2012 TransGaming Inc."
             VALUE "OriginalFilename", "libGLESv2.dll"
             VALUE "PrivateBuild", VERSION_STRING
             VALUE "ProductName", "SwiftShader libGLESv2 Dynamic Link Library"
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcproj b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcproj
deleted file mode 100644
index a71bc26..0000000
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcproj
+++ /dev/null
@@ -1,387 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="libGLESv2"
-	ProjectGUID="{B5871A7A-968C-42E3-A33B-981E6F448E78}"
-	RootNamespace="libGLESv2"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="131072"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="2"
-			CharacterSet="0"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="$(ProjectDir)/..;$(ProjectDir)/../..; $(ProjectDir)/../include"
-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBGLESV2_EXPORTS;_CRT_SECURE_NO_DEPRECATE;NOMINMAX"
-				MinimalRebuild="true"
-				ExceptionHandling="1"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="false"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="dxguid.lib d3d9.lib D3dx9.lib d3dcompiler.lib"
-				LinkIncremental="2"
-				ModuleDefinitionFile="libGLESv2.def"
-				GenerateDebugInformation="true"
-				SubSystem="2"
-				RandomizedBaseAddress="1"
-				DataExecutionPrevention="0"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-				CommandLine="@echo on&#x0D;&#x0A;mkdir &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;copy &quot;$(OutDir)\libGLESv2.dll&quot; &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;copy &quot;$(OutDir)\libGLESv2.lib&quot; &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;@echo off&#x0D;&#x0A;"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="2"
-			CharacterSet="0"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				InlineFunctionExpansion="2"
-				AdditionalIncludeDirectories="$(ProjectDir)/..;$(ProjectDir)/../..; $(ProjectDir)/../include"
-				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBGLESV2_EXPORTS;_CRT_SECURE_NO_DEPRECATE;NOMINMAX;_SECURE_SCL=0"
-				ExceptionHandling="1"
-				RuntimeLibrary="0"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="false"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="dxguid.lib d3d9.lib D3dx9.lib d3dcompiler.lib"
-				LinkIncremental="1"
-				IgnoreAllDefaultLibraries="false"
-				ModuleDefinitionFile="libGLESv2.def"
-				GenerateDebugInformation="true"
-				SubSystem="2"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				RandomizedBaseAddress="1"
-				DataExecutionPrevention="0"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-				CommandLine="@echo on&#x0D;&#x0A;mkdir &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;copy &quot;$(OutDir)\libGLESv2.dll&quot; &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;copy &quot;$(OutDir)\libGLESv2.lib&quot; &quot;$(ProjectDir)..\..\lib\$(ConfigurationName)\&quot;&#x0D;&#x0A;@echo off&#x0D;&#x0A;"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath=".\Buffer.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Context.cpp"
-				>
-			</File>
-			<File
-				RelativePath="..\common\debug.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Device.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Fence.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Framebuffer.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\HandleAllocator.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Image.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\IndexDataManager.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\libGLESv2.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\main.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Program.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\RefCountObject.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Renderbuffer.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\ResourceManager.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Shader.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Texture.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Unknown.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\utilities.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\VertexDataManager.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-			<File
-				RelativePath=".\Buffer.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Context.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Device.hpp"
-				>
-			</File>
-			<File
-				RelativePath=".\Fence.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Framebuffer.h"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\GLES2\gl2.h"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\GLES2\gl2ext.h"
-				>
-			</File>
-			<File
-				RelativePath="..\..\include\GLES2\gl2platform.h"
-				>
-			</File>
-			<File
-				RelativePath=".\HandleAllocator.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Image.hpp"
-				>
-			</File>
-			<File
-				RelativePath=".\IndexDataManager.h"
-				>
-			</File>
-			<File
-				RelativePath=".\main.h"
-				>
-			</File>
-			<File
-				RelativePath=".\mathutil.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Program.h"
-				>
-			</File>
-			<File
-				RelativePath=".\RefCountObject.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Renderbuffer.h"
-				>
-			</File>
-			<File
-				RelativePath=".\resource.h"
-				>
-			</File>
-			<File
-				RelativePath=".\ResourceManager.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Shader.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Texture.h"
-				>
-			</File>
-			<File
-				RelativePath=".\Unknown.hpp"
-				>
-			</File>
-			<File
-				RelativePath=".\utilities.h"
-				>
-			</File>
-			<File
-				RelativePath="..\common\version.h"
-				>
-			</File>
-			<File
-				RelativePath=".\vertexconversion.h"
-				>
-			</File>
-			<File
-				RelativePath=".\VertexDataManager.h"
-				>
-			</File>
-		</Filter>
-		<File
-			RelativePath=".\libGLESv2.def"
-			>
-		</File>
-		<File
-			RelativePath=".\libGLESv2.rc"
-			>
-		</File>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj
index e49c518..5391f71 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj
@@ -78,10 +78,9 @@
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <BrowseInformation>true</BrowseInformation>
-      <ExceptionHandling>Sync</ExceptionHandling>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>dwmapi.lib;dxguid.lib;WS2_32.lib;D3dx9.lib;d3dcompiler.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>dxguid.lib;dwmapi.lib;WS2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>libGLESv2.def</ModuleDefinitionFile>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
@@ -114,10 +113,9 @@
       <EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
       <WholeProgramOptimization>true</WholeProgramOptimization>
       <IntrinsicFunctions>false</IntrinsicFunctions>
-      <ExceptionHandling>Sync</ExceptionHandling>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>dwmapi.lib;dxguid.lib;WS2_32.lib;D3dx9.lib;d3dcompiler.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>dxguid.lib;dwmapi.lib;WS2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
       <ModuleDefinitionFile>libGLESv2.def</ModuleDefinitionFile>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -146,16 +144,15 @@
       <PrecompiledHeader>
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
+      <OmitFramePointers>false</OmitFramePointers>
       <EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
       <WholeProgramOptimization>true</WholeProgramOptimization>
       <IntrinsicFunctions>false</IntrinsicFunctions>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>dwmapi.lib;dxguid.lib;WS2_32.lib;D3dx9.lib;d3dcompiler.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>dxguid.lib;dwmapi.lib;WS2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
       <ModuleDefinitionFile>libGLESv2.def</ModuleDefinitionFile>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -187,6 +184,7 @@
     <ClCompile Include="libGLESv2.cpp" />
     <ClCompile Include="main.cpp" />
     <ClCompile Include="Program.cpp" />
+    <ClCompile Include="Query.cpp" />
     <ClCompile Include="RefCountObject.cpp" />
     <ClCompile Include="Renderbuffer.cpp" />
     <ClCompile Include="ResourceManager.cpp" />
@@ -197,20 +195,21 @@
     <ClCompile Include="VertexDataManager.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="..\include\GLES2\gl2.h" />
+    <ClInclude Include="..\include\GLES2\gl2ext.h" />
+    <ClInclude Include="..\include\GLES2\gl2platform.h" />
     <ClInclude Include="Buffer.h" />
     <ClInclude Include="Context.h" />
     <ClInclude Include="Device.hpp" />
     <ClInclude Include="Fence.h" />
     <ClInclude Include="Framebuffer.h" />
-    <ClInclude Include="..\..\include\GLES2\gl2.h" />
-    <ClInclude Include="..\..\include\GLES2\gl2ext.h" />
-    <ClInclude Include="..\..\include\GLES2\gl2platform.h" />
     <ClInclude Include="HandleAllocator.h" />
     <ClInclude Include="Image.hpp" />
     <ClInclude Include="IndexDataManager.h" />
     <ClInclude Include="main.h" />
     <ClInclude Include="mathutil.h" />
     <ClInclude Include="Program.h" />
+    <ClInclude Include="Query.h" />
     <ClInclude Include="RefCountObject.h" />
     <ClInclude Include="Renderbuffer.h" />
     <ClInclude Include="resource.h" />
@@ -219,7 +218,6 @@
     <ClInclude Include="Texture.h" />
     <ClInclude Include="Unknown.hpp" />
     <ClInclude Include="utilities.h" />
-    <ClInclude Include="..\common\version.h" />
     <ClInclude Include="VertexDataManager.h" />
   </ItemGroup>
   <ItemGroup>
@@ -229,56 +227,17 @@
     <ResourceCompile Include="libGLESv2.rc" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\LLVM\win32\Analysis\Analysis.vcxproj">
-      <Project>{0622e827-8464-489d-8b1c-b0b496f35c08}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\CodeGen\CodeGen.vcxproj">
-      <Project>{08ceb1bb-c2a4-4587-b9a9-aedb8fb44897}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\ExecutionEngine\ExecutionEngine.vcxproj">
-      <Project>{76295ae8-a083-460e-9f80-6f2b8923264a}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\MC\MC.vcxproj">
-      <Project>{12d00cfa-e393-4857-a436-c7324849de51}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\Support\Support.vcxproj">
-      <Project>{28aa9146-3482-4f41-9cc6-407b1d258508}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\System\System.vcxproj">
-      <Project>{0f8407f3-fa23-4cf1-83a9-dcbe0b361489}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\TableGen\TableGen.vcxproj">
-      <Project>{339c2249-26b6-4172-b484-85653029af57}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\Target\Target.vcxproj">
-      <Project>{059fbab8-c76d-48a0-aa75-3c57bd3eafe4}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\Transforms\Transforms.vcxproj">
-      <Project>{c59374c1-9fc0-4147-b836-327dfdc52d99}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\VMCore\VMCore.vcxproj">
-      <Project>{45cd78d7-c5d9-47fe-ad12-f3251eedaffb}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\LLVM\win32\x86\x86.vcxproj">
-      <Project>{144eebf6-8c9b-4473-b715-2c821666af6c}</Project>
-    </ProjectReference>
-    <ProjectReference Include="..\..\Reactor\Reactor.vcxproj">
-      <Project>{28fd076d-10b5-4bd8-a4cf-f44c7002a803}</Project>
-    </ProjectReference>
     <ProjectReference Include="..\..\SwiftShader\SwiftShader.vcxproj">
       <Project>{7b02cb19-4cdf-4f79-bc9b-7f3f6164a003}</Project>
       <Private>true</Private>
       <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
       <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
       <LinkLibraryDependencies>true</LinkLibraryDependencies>
-      <UseLibraryDependencyInputs>false</UseLibraryDependencyInputs>
+      <UseLibraryDependencyInputs>true</UseLibraryDependencyInputs>
     </ProjectReference>
-    <ProjectReference Include="..\compiler\translator_common.vcxproj">
+    <ProjectReference Include="..\compiler\Compiler.vcxproj">
       <Project>{5b3a6db8-1e7e-40d7-92b9-da8aae619fad}</Project>
     </ProjectReference>
-    <ProjectReference Include="..\compiler\translator_hlsl.vcxproj">
-      <Project>{5620f0e4-6c43-49bc-a178-b804e1a0c3a7}</Project>
-    </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.filters b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.filters
index 84bc665..89355a8 100644
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.filters
+++ b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.filters
@@ -71,6 +71,9 @@
     <ClCompile Include="Unknown.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Query.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Buffer.h">
@@ -85,15 +88,6 @@
     <ClInclude Include="Framebuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\GLES2\gl2.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\GLES2\gl2ext.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\GLES2\gl2platform.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="HandleAllocator.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -130,9 +124,6 @@
     <ClInclude Include="utilities.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\common\version.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="VertexDataManager.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -145,6 +136,18 @@
     <ClInclude Include="Unknown.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\GLES2\gl2.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\GLES2\gl2ext.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\GLES2\gl2platform.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Query.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="libGLESv2.rc" />
diff --git a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.user b/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.user
deleted file mode 100644
index 695b5c7..0000000
--- a/src/OpenGL ES 2.0/libGLESv2/libGLESv2.vcxproj.user
+++ /dev/null
@@ -1,3 +0,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-</Project>
\ No newline at end of file
diff --git a/src/OpenGL ES 2.0/libGLESv2/main.cpp b/src/OpenGL ES 2.0/libGLESv2/main.cpp
index f698a63..ab5be46 100644
--- a/src/OpenGL ES 2.0/libGLESv2/main.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/main.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // main.cpp: DLL entry point and management of thread-local data.
diff --git a/src/OpenGL ES 2.0/libGLESv2/main.h b/src/OpenGL ES 2.0/libGLESv2/main.h
index 248381d..fdb0dc0 100644
--- a/src/OpenGL ES 2.0/libGLESv2/main.h
+++ b/src/OpenGL ES 2.0/libGLESv2/main.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // main.h: Management of thread-local data.
diff --git a/src/OpenGL ES 2.0/libGLESv2/mathutil.h b/src/OpenGL ES 2.0/libGLESv2/mathutil.h
index 5cc08d7..c44cd6a 100644
--- a/src/OpenGL ES 2.0/libGLESv2/mathutil.h
+++ b/src/OpenGL ES 2.0/libGLESv2/mathutil.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // mathutil.h: Math and bit manipulation functions.
@@ -72,27 +77,6 @@
     }
 }
 
-inline sw::Rect transformPixelRect(GLint x, GLint y, GLint w, GLint h, GLint surfaceHeight)
-{
-	sw::Rect rect = {x,
-	                 surfaceHeight - y - h,
-	                 x + w,
-	                 surfaceHeight - y};
-
-    return rect;
-}
-
-inline int transformPixelYOffset(GLint yoffset, GLint h, GLint surfaceHeight)
-{
-    return surfaceHeight - yoffset - h;
-}
-
-inline GLenum adjustWinding(GLenum winding)
-{
-    ASSERT(winding == GL_CW || winding == GL_CCW);
-    return winding == GL_CW ? GL_CCW : GL_CW;
-}
-
 inline bool supportsSSE2()
 {
     static bool checked = false;
diff --git a/src/OpenGL ES 2.0/libGLESv2/utilities.cpp b/src/OpenGL ES 2.0/libGLESv2/utilities.cpp
index fde83d1..8c795f6 100644
--- a/src/OpenGL ES 2.0/libGLESv2/utilities.cpp
+++ b/src/OpenGL ES 2.0/libGLESv2/utilities.cpp
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // utilities.cpp: Conversion functions and other utility routines.
@@ -198,18 +203,21 @@
 		{
 		case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 		case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-			break;
+			return 8 * (GLsizei)ceil((float)width / 4.0f) * (GLsizei)ceil((float)height / 4.0f);
+		case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+		case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
+			return 16 * (GLsizei)ceil((float)width / 4.0f) * (GLsizei)ceil((float)height / 4.0f);
 		default:
 			return 0;
 		}
-
-		return 8 * (GLsizei)ceil((float)width / 4.0f) * (GLsizei)ceil((float)height / 4.0f);
 	}
 
 	bool IsCompressed(GLenum format)
 	{
 		if(format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
-		   format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT)
+		   format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
+		   format == GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE ||
+		   format == GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE)
 		{
 			return true;
 		}
@@ -275,35 +283,16 @@
 
 	CubeFace ConvertCubeFace(GLenum cubeFace)
 	{
-		CubeFace face = CUBEMAP_FACE_POSITIVE_X;
-
-		// Map a cube map texture target to the corresponding Device surface index. Note that the
-		// Y faces are swapped because the Y coordinate to the texture lookup intrinsic functions
-		// are negated in the pixel shader.
 		switch(cubeFace)
 		{
-		case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-			face = CUBEMAP_FACE_POSITIVE_X;
-			break;
-		case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-			face = CUBEMAP_FACE_NEGATIVE_X;
-			break;
-		case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-			face = CUBEMAP_FACE_NEGATIVE_Y;
-			break;
-		case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-			face = CUBEMAP_FACE_POSITIVE_Y;
-			break;
-		case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-			face = CUBEMAP_FACE_POSITIVE_Z;
-			break;
-		case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-			face = CUBEMAP_FACE_NEGATIVE_Z;
-			break;
-		default: UNREACHABLE();
+		case GL_TEXTURE_CUBE_MAP_POSITIVE_X: return CUBEMAP_FACE_POSITIVE_X;
+		case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: return CUBEMAP_FACE_NEGATIVE_X;
+		case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: return CUBEMAP_FACE_POSITIVE_Y;
+		case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: return CUBEMAP_FACE_NEGATIVE_Y;
+		case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: return CUBEMAP_FACE_POSITIVE_Z;
+		case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: return CUBEMAP_FACE_NEGATIVE_Z;
+		default: UNREACHABLE(); return CUBEMAP_FACE_POSITIVE_X;
 		}
-
-		return face;
 	}
 
 	bool IsTextureTarget(GLenum target)
@@ -674,8 +663,8 @@
 		case sw::FORMAT_D32F_LOCKABLE:
 		case sw::FORMAT_D16:
 			return 0;
-	//	case sw::FORMAT_D32_LOCKABLE:  return 0;   // DirectX 9Ex only
-	//	case sw::FORMAT_S8_LOCKABLE:   return 8;   // DirectX 9Ex only
+	//	case sw::FORMAT_D32_LOCKABLE:  return 0;
+	//	case sw::FORMAT_S8_LOCKABLE:   return 8;
 		default:
 			return 0;
 		}
diff --git a/src/OpenGL ES 2.0/libGLESv2/utilities.h b/src/OpenGL ES 2.0/libGLESv2/utilities.h
index 08fd676..ae258c5 100644
--- a/src/OpenGL ES 2.0/libGLESv2/utilities.h
+++ b/src/OpenGL ES 2.0/libGLESv2/utilities.h
@@ -1,7 +1,12 @@
+// SwiftShader Software Renderer
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+// Copyright(c) 2005-2012 TransGaming Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
 //
 
 // utilities.h: Conversion functions and other utility routines.