initial commit

.gitignore

@@ -0,0 +1,14 @@
+.*.swp
+
+build/*
+
+3rdparty/glfw/docs/**
+3rdparty/glfw/examples/**
+3rdparty/glfw/tests/**
+
+3rdparty/bgfx/examples/*-*/**
+3rdparty/bgfx/examples/assets/**
+3rdparty/bgfx/examples/runtime/**
+3rdparty/bgfx/3rdparty/dxsdk/**
+3rdparty/bgfx/3rdparty/scintilla/**
+

3rdparty/bgfx/.appveyor.yml

@@ -0,0 +1,22 @@
+shallow_clone: true
+
+os:
+  - Visual Studio 2015
+
+environment:
+  matrix:
+  - TOOLSET: vs2010
+  - TOOLSET: vs2012
+  - TOOLSET: vs2013
+  - TOOLSET: vs2015
+
+configuration:
+  - Debug
+  - Release
+
+install:
+  - git clone https://github.com/bkaradzic/bx ..\bx
+  - ..\bx\tools\bin\windows\genie --with-tools %TOOLSET%
+
+build:
+  project: .build/projects/$(TOOLSET)/bgfx.sln

3rdparty/bgfx/.editorconfig

@@ -0,0 +1,19 @@
+root = true
+
+[*]
+indent_style    = tab
+indent_size     = 4
+end_of_line     = lf
+max_line_length = 100
+insert_final_newline     = true
+trim_trailing_whitespace = true
+
+[include/bgfx/c99/*.h]
+indent_style = space
+
+[*.ninja]
+indent_style = space
+
+[*.md]
+trim_trailing_whitespace = false
+max_line_length = 80

3rdparty/bgfx/.gitattributes

@@ -0,0 +1,11 @@
+*.c   eol=lf
+*.cpp eol=lf
+*.h   eol=lf
+*.sc  eol=lf
+*.sh  eol=lf
+*.m   eol=lf
+*.mm  eol=lf
+*.md  eol=lf
+*.lua eol=lf
+*.mk  eol=lf
+makefile eol=lf

3rdparty/bgfx/.gitignore

@@ -0,0 +1,7 @@
+.build
+.debug
+.DS_Store
+.git
+.svn
+tags
+.gdb_history

3rdparty/bgfx/.travis.yml

@@ -0,0 +1,22 @@
+language: cpp
+matrix:
+  include:
+    - compiler: gcc
+      os: linux
+    - compiler: clang
+      os: osx
+
+before_script:
+  git clone https://github.com/bkaradzic/bx ../bx
+
+script:
+  make build
+
+branches:
+  only:
+    - master
+
+notifications:
+  email: false
+
+osx_image: xcode7.3

3rdparty/bgfx/3rdparty/.editorconfig

@@ -0,0 +1,33 @@
+root = true
+
+[etc1/*]
+indent_style = space
+indent_size  = 4
+
+[fcpp/*]
+indent_style = space
+indent_size  = 2
+
+[iqa/*]
+indent_style = tab
+indent_size  = 4
+
+[libsquish/*]
+indent_style = tab
+indent_size  = 4
+
+[ocornut-imgui/*]
+indent_style = space
+indent_size  = 4
+
+[ocornut-imgui/*.inl]
+indent_style = space
+indent_size  = 4
+
+[pvrtc/*]
+indent_style = space
+indent_size  = 4
+
+[remotery/*]
+indent_style = space
+indent_size  = 4

3rdparty/bgfx/3rdparty/edtaa3/LICENSE.md

@@ -0,0 +1,34 @@
+https://github.com/OpenGLInsights/OpenGLInsightsCode/blob/master/Chapter%2012%202D%20Shape%20Rendering%20by%20Distance%20Fields/LICENSE.txt
+
+The C code and the GLSL code for the OpenGL demo is public
+domain code. The distance transform code in the console
+application to create distance field textures, located in
+the file "edtaa3func.c", is MIT licensed, and free to use
+under the following conditions.
+
+https://github.com/OpenGLInsights/OpenGLInsightsCode/issues/6#issuecomment-67829157
+
+----
+
+Copyright (C) 2011 by Stefan Gustavson
+(stefan.gustavson@liu.se)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+----

3rdparty/bgfx/3rdparty/edtaa3/edtaa3func.cpp

@@ -0,0 +1,580 @@
+/*
+ * edtaa3()
+ *
+ * Sweep-and-update Euclidean distance transform of an
+ * image. Positive pixels are treated as object pixels,
+ * zero or negative pixels are treated as background.
+ * An attempt is made to treat antialiased edges correctly.
+ * The input image must have pixels in the range [0,1],
+ * and the antialiased image should be a box-filter
+ * sampling of the ideal, crisp edge.
+ * If the antialias region is more than 1 pixel wide,
+ * the result from this transform will be inaccurate.
+ *
+ * By Stefan Gustavson (stefan.gustavson@gmail.com).
+ *
+ * Originally written in 1994, based on a verbal
+ * description of Per-Erik Danielsson's SSED8 algorithm
+ * as presented in the PhD dissertation of Ingemar
+ * Ragnemalm. This is Per-Erik Danielsson's scanline
+ * scheme from 1979 - I only implemented it in C.
+ *
+ * Updated in 2004 to treat border pixels correctly,
+ * and cleaned up the code to improve readability.
+ *
+ * Updated in 2009 to handle anti-aliased edges,
+ * as published in the article "Anti-aliased Euclidean
+ * distance transform" by Stefan Gustavson and Robin Strand,
+ * Pattern Recognition Letters 32 (2011) 252–257.
+ *
+ * Updated in 2011 to avoid a corner case causing an
+ * infinite loop for some input data.
+ *
+*/
+
+/*
+
+Copyright (C) 2011 by Stefan Gustavson
+
+(stefan.gustavson@liu.se)
+
+This code is distributed under the permissive "MIT license":
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+#include <math.h>
+
+/*
+ * Compute the local gradient at edge pixels using convolution filters.
+ * The gradient is computed only at edge pixels. At other places in the
+ * image, it is never used, and it's mostly zero anyway.
+ */
+void computegradient(double *img, int w, int h, double *gx, double *gy)
+{
+    int i,j,k;
+    double glength;
+#define SQRT2 1.4142136
+    for(i = 1; i < h-1; i++) { // Avoid edges where the kernels would spill over
+        for(j = 1; j < w-1; j++) {
+            k = i*w + j;
+            if((img[k]>0.0) && (img[k]<1.0)) { // Compute gradient for edge pixels only
+                gx[k] = -img[k-w-1] - SQRT2*img[k-1] - img[k+w-1] + img[k-w+1] + SQRT2*img[k+1] + img[k+w+1];
+                gy[k] = -img[k-w-1] - SQRT2*img[k-w] - img[k-w+1] + img[k+w-1] + SQRT2*img[k+w] + img[k+w+1];
+                glength = gx[k]*gx[k] + gy[k]*gy[k];
+                if(glength > 0.0) { // Avoid division by zero
+                    glength = sqrt(glength);
+                    gx[k]=gx[k]/glength;
+                    gy[k]=gy[k]/glength;
+                }
+            }
+        }
+    }
+    // TODO: Compute reasonable values for gx, gy also around the image edges.
+    // (These are zero now, which reduces the accuracy for a 1-pixel wide region
+	// around the image edge.) 2x2 kernels would be suitable for this.
+}
+
+/*
+ * A somewhat tricky function to approximate the distance to an edge in a
+ * certain pixel, with consideration to either the local gradient (gx,gy)
+ * or the direction to the pixel (dx,dy) and the pixel greyscale value a.
+ * The latter alternative, using (dx,dy), is the metric used by edtaa2().
+ * Using a local estimate of the edge gradient (gx,gy) yields much better
+ * accuracy at and near edges, and reduces the error even at distant pixels
+ * provided that the gradient direction is accurately estimated.
+ */
+double edgedf(double gx, double gy, double a)
+{
+    double df, glength, temp, a1;
+
+    if ((gx == 0) || (gy == 0)) { // Either A) gu or gv are zero, or B) both
+        df = 0.5-a;  // Linear approximation is A) correct or B) a fair guess
+    } else {
+        glength = sqrt(gx*gx + gy*gy);
+        if(glength>0) {
+            gx = gx/glength;
+            gy = gy/glength;
+        }
+        /* Everything is symmetric wrt sign and transposition,
+         * so move to first octant (gx>=0, gy>=0, gx>=gy) to
+         * avoid handling all possible edge directions.
+         */
+        gx = fabs(gx);
+        gy = fabs(gy);
+        if(gx<gy) {
+            temp = gx;
+            gx = gy;
+            gy = temp;
+        }
+        a1 = 0.5*gy/gx;
+        if (a < a1) { // 0 <= a < a1
+            df = 0.5*(gx + gy) - sqrt(2.0*gx*gy*a);
+        } else if (a < (1.0-a1)) { // a1 <= a <= 1-a1
+            df = (0.5-a)*gx;
+        } else { // 1-a1 < a <= 1
+            df = -0.5*(gx + gy) + sqrt(2.0*gx*gy*(1.0-a));
+        }
+    }    
+    return df;
+}
+
+double distaa3(double *img, double *gximg, double *gyimg, int w, int c, int xc, int yc, int xi, int yi)
+{
+  double di, df, dx, dy, gx, gy, a;
+  int closest;
+  
+  closest = c-xc-yc*w; // Index to the edge pixel pointed to from c
+  a = img[closest];    // Grayscale value at the edge pixel
+  gx = gximg[closest]; // X gradient component at the edge pixel
+  gy = gyimg[closest]; // Y gradient component at the edge pixel
+  
+  if(a > 1.0) a = 1.0;
+  if(a < 0.0) a = 0.0; // Clip grayscale values outside the range [0,1]
+  if(a == 0.0) return 1000000.0; // Not an object pixel, return "very far" ("don't know yet")
+
+  dx = (double)xi;
+  dy = (double)yi;
+  di = sqrt(dx*dx + dy*dy); // Length of integer vector, like a traditional EDT
+  if(di==0) { // Use local gradient only at edges
+      // Estimate based on local gradient only
+      df = edgedf(gx, gy, a);
+  } else {
+      // Estimate gradient based on direction to edge (accurate for large di)
+      df = edgedf(dx, dy, a);
+  }
+  return di + df; // Same metric as edtaa2, except at edges (where di=0)
+}
+
+// Shorthand macro: add ubiquitous parameters img, gx, gy and w and call distaa3()
+#define DISTAA(c,xc,yc,xi,yi) (distaa3(img, gx, gy, w, c, xc, yc, xi, yi))
+
+void edtaa3(double *img, double *gx, double *gy, int w, int h, short *distx, short *disty, double *dist)
+{
+  int x, y, i, c;
+  int offset_u, offset_ur, offset_r, offset_rd,
+  offset_d, offset_dl, offset_l, offset_lu;
+  double olddist, newdist;
+  int cdistx, cdisty, newdistx, newdisty;
+  int changed;
+  double epsilon = 1e-3; // Safeguard against errors due to limited precision
+
+  /* Initialize index offsets for the current image width */
+  offset_u = -w;
+  offset_ur = -w+1;
+  offset_r = 1;
+  offset_rd = w+1;
+  offset_d = w;
+  offset_dl = w-1;
+  offset_l = -1;
+  offset_lu = -w-1;
+
+  /* Initialize the distance images */
+  for(i=0; i<w*h; i++) {
+    distx[i] = 0; // At first, all pixels point to
+    disty[i] = 0; // themselves as the closest known.
+    if(img[i] <= 0.0)
+      {
+	dist[i]= 1000000.0; // Big value, means "not set yet"
+      }
+    else if (img[i]<1.0) {
+      dist[i] = edgedf(gx[i], gy[i], img[i]); // Gradient-assisted estimate
+    }
+    else {
+      dist[i]= 0.0; // Inside the object
+    }
+  }
+
+  /* Perform the transformation */
+  do
+    {
+      changed = 0;
+
+      /* Scan rows, except first row */
+      for(y=1; y<h; y++)
+        {
+
+          /* move index to leftmost pixel of current row */
+          i = y*w;
+
+          /* scan right, propagate distances from above & left */
+
+          /* Leftmost pixel is special, has no left neighbors */
+          olddist = dist[i];
+          if(olddist > 0) // If non-zero distance or not set yet
+            {
+	      c = i + offset_u; // Index of candidate for testing
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx;
+              newdisty = cdisty+1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_ur;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx-1;
+              newdisty = cdisty+1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  changed = 1;
+                }
+            }
+          i++;
+
+          /* Middle pixels have all neighbors */
+          for(x=1; x<w-1; x++, i++)
+            {
+              olddist = dist[i];
+              if(olddist <= 0) continue; // No need to update further
+
+	      c = i+offset_l;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx+1;
+              newdisty = cdisty;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_lu;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx+1;
+              newdisty = cdisty+1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_u;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx;
+              newdisty = cdisty+1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_ur;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx-1;
+              newdisty = cdisty+1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  changed = 1;
+                }
+            }
+
+          /* Rightmost pixel of row is special, has no right neighbors */
+          olddist = dist[i];
+          if(olddist > 0) // If not already zero distance
+            {
+	      c = i+offset_l;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx+1;
+              newdisty = cdisty;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_lu;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx+1;
+              newdisty = cdisty+1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_u;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx;
+              newdisty = cdisty+1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  changed = 1;
+                }
+            }
+
+          /* Move index to second rightmost pixel of current row. */
+          /* Rightmost pixel is skipped, it has no right neighbor. */
+          i = y*w + w-2;
+
+          /* scan left, propagate distance from right */
+          for(x=w-2; x>=0; x--, i--)
+            {
+              olddist = dist[i];
+              if(olddist <= 0) continue; // Already zero distance
+
+	      c = i+offset_r;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx-1;
+              newdisty = cdisty;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  changed = 1;
+                }
+            }
+        }
+      
+      /* Scan rows in reverse order, except last row */
+      for(y=h-2; y>=0; y--)
+        {
+          /* move index to rightmost pixel of current row */
+          i = y*w + w-1;
+
+          /* Scan left, propagate distances from below & right */
+
+          /* Rightmost pixel is special, has no right neighbors */
+          olddist = dist[i];
+          if(olddist > 0) // If not already zero distance
+            {
+	      c = i+offset_d;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx;
+              newdisty = cdisty-1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_dl;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx+1;
+              newdisty = cdisty-1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  changed = 1;
+                }
+            }
+          i--;
+
+          /* Middle pixels have all neighbors */
+          for(x=w-2; x>0; x--, i--)
+            {
+              olddist = dist[i];
+              if(olddist <= 0) continue; // Already zero distance
+
+	      c = i+offset_r;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx-1;
+              newdisty = cdisty;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_rd;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx-1;
+              newdisty = cdisty-1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_d;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx;
+              newdisty = cdisty-1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_dl;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx+1;
+              newdisty = cdisty-1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  changed = 1;
+                }
+            }
+          /* Leftmost pixel is special, has no left neighbors */
+          olddist = dist[i];
+          if(olddist > 0) // If not already zero distance
+            {
+	      c = i+offset_r;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx-1;
+              newdisty = cdisty;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_rd;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx-1;
+              newdisty = cdisty-1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  olddist=newdist;
+                  changed = 1;
+                }
+
+	      c = i+offset_d;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx;
+              newdisty = cdisty-1;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  changed = 1;
+                }
+            }
+
+          /* Move index to second leftmost pixel of current row. */
+          /* Leftmost pixel is skipped, it has no left neighbor. */
+          i = y*w + 1;
+          for(x=1; x<w; x++, i++)
+            {
+              /* scan right, propagate distance from left */
+              olddist = dist[i];
+              if(olddist <= 0) continue; // Already zero distance
+
+	      c = i+offset_l;
+	      cdistx = distx[c];
+	      cdisty = disty[c];
+              newdistx = cdistx+1;
+              newdisty = cdisty;
+              newdist = DISTAA(c, cdistx, cdisty, newdistx, newdisty);
+              if(newdist < olddist-epsilon)
+                {
+                  distx[i]=newdistx;
+                  disty[i]=newdisty;
+                  dist[i]=newdist;
+                  changed = 1;
+                }
+            }
+        }
+    }
+  while(changed); // Sweep until no more updates are made
+
+  /* The transformation is completed. */
+
+}

3rdparty/bgfx/3rdparty/edtaa3/edtaa3func.h

@@ -0,0 +1,7 @@
+#ifndef EDTAA3_H_HEADER_GUARD
+#define EDTAA3_H_HEADER_GUARD
+
+extern void computegradient(double *img, int w, int h, double *gx, double *gy);
+extern void edtaa3(double *img, double *gx, double *gy, int w, int h, short *distx, short *disty, double *dist);
+
+#endif // EDTAA3_H_HEADER_GUARD

3rdparty/bgfx/3rdparty/etc1/LICENSE

@@ -0,0 +1,161 @@
+Apache License
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the
+copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other
+entities that control, are controlled by, or are under common control with
+that entity. For the purposes of this definition, "control" means (i) the
+power, direct or indirect, to cause the direction or management of such 
+entity, whether by contract or otherwise, or (ii) ownership of fifty 
+percent (50%) or more of the outstanding shares, or (iii) beneficial 
+ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising 
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, 
+including but not limited to software source code, documentation 
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation 
+or translation of a Source form, including but not limited to compiled 
+object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object 
+form, made available under the License, as indicated by a copyright 
+notice that is included in or attached to the work (an example is 
+provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object 
+form, that is based on (or derived from) the Work and for which the 
+editorial revisions, annotations, elaborations, or other modifications 
+represent, as a whole, an original work of authorship. For the purposes 
+of this License, Derivative Works shall not include works that remain 
+separable from, or merely link (or bind by name) to the interfaces of, 
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original 
+version of the Work and any modifications or additions to that Work or 
+Derivative Works thereof, that is intentionally submitted to Licensor 
+for inclusion in the Work by the copyright owner or by an individual or 
+Legal Entity authorized to submit on behalf of the copyright owner. For 
+the purposes of this definition, "submitted" means any form of electronic, 
+verbal, or written communication sent to the Licensor or its 
+representatives, including but not limited to communication on electronic 
+mailing lists, source code control systems, and issue tracking systems that 
+are managed by, or on behalf of, the Licensor for the purpose of discussing 
+and improving the Work, but excluding communication that is conspicuously 
+marked or otherwise designated in writing by the copyright owner as "Not 
+a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on 
+behalf of whom a Contribution has been received by Licensor and subsequently 
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this 
+License, each Contributor hereby grants to You a perpetual, worldwide, 
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to 
+reproduce, prepare Derivative Works of, publicly display, publicly perform, 
+sublicense, and distribute the Work and such Derivative Works in Source or 
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this 
+License, each Contributor hereby grants to You a perpetual, worldwide, 
+non-exclusive, no-charge, royalty-free, irrevocable (except as stated in 
+this section) patent license to make, have made, use, offer to sell, sell, 
+import, and otherwise transfer the Work, where such license applies only to 
+those patent claims licensable by such Contributor that are necessarily 
+infringed by their Contribution(s) alone or by combination of their 
+Contribution(s) with the Work to which such Contribution(s) was submitted. 
+If You institute patent litigation against any entity (including a cross-claim
+or counterclaim in a lawsuit) alleging that the Work or a Contribution 
+incorporated within the Work constitutes direct or contributory patent 
+infringement, then any patent licenses granted to You under this License 
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or 
+Derivative Works thereof in any medium, with or without modifications, and 
+in Source or Object form, provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of 
+this License; and
+You must cause any modified files to carry prominent notices stating that 
+You changed the files; and
+You must retain, in the Source form of any Derivative Works that You 
+distribute, all copyright, patent, trademark, and attribution notices 
+from the Source form of the Work, excluding those notices that do not 
+pertain to any part of the Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, 
+then any Derivative Works that You distribute must include a readable 
+copy of the attribution notices contained within such NOTICE file, excluding
+those notices that do not pertain to any part of the Derivative Works, in
+at least one of the following places: within a NOTICE text file distributed 
+as part of the Derivative Works; within the Source form or documentation, if 
+provided along with the Derivative Works; or, within a display generated by 
+the Derivative Works, if and wherever such third-party notices normally 
+appear. The contents of the NOTICE file are for informational purposes 
+only and do not modify the License. You may add Your own attribution 
+notices within Derivative Works that You distribute, alongside or as 
+an addendum to the NOTICE text from the Work, provided that such additional 
+attribution notices cannot be construed as modifying the License. 
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a 
+whole, provided Your use, reproduction, and distribution of the Work otherwise 
+complies with the conditions stated in this License.
+5. Submission of Contributions. Unless You explicitly state otherwise, any 
+Contribution intentionally submitted for inclusion in the Work by You to the 
+Licensor shall be under the terms and conditions of this License, without any 
+additional terms or conditions. Notwithstanding the above, nothing herein 
+shall supersede or modify the terms of any separate license agreement you 
+may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, 
+trademarks, service marks, or product names of the Licensor, except as 
+required for reasonable and customary use in describing the origin of the 
+Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to 
+in writing, Licensor provides the Work (and each Contributor provides its 
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF 
+ANY KIND, either express or implied, including, without limitation, any 
+warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or 
+FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining 
+the appropriateness of using or redistributing the Work and assume any risks 
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by 
+applicable law (such as deliberate and grossly negligent acts) or agreed to 
+in writing, shall any Contributor be liable to You for damages, including 
+any direct, indirect, special, incidental, or consequential damages of any 
+character arising as a result of this License or out of the use or inability 
+to use the Work (including but not limited to damages for loss of goodwill, 
+work stoppage, computer failure or malfunction, or any and all other 
+commercial damages or losses), even if such Contributor has been advised 
+of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the 
+Work or Derivative Works thereof, You may choose to offer, and charge a 
+fee for, acceptance of support, warranty, indemnity, or other liability 
+obligations and/or rights consistent with this License. However, in accepting
+such obligations, You may act only on Your own behalf and on Your sole 
+responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any 
+liability incurred by, or claims asserted against, such Contributor by 
+reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

3rdparty/bgfx/3rdparty/etc1/etc1.cpp

@@ -0,0 +1,686 @@
+// Copyright 2009 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// This is a fork of the AOSP project ETC1 codec. The original code can be found
+// at the following web site:
+// https://android.googlesource.com/platform/frameworks/native/+/master/opengl/include/ETC1/
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+#include "etc1.h"
+
+#include <cstring>
+
+/* From http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt
+
+ The number of bits that represent a 4x4 texel block is 64 bits if
+ <internalformat> is given by ETC1_RGB8_OES.
+
+ The data for a block is a number of bytes,
+
+ {q0, q1, q2, q3, q4, q5, q6, q7}
+
+ where byte q0 is located at the lowest memory address and q7 at
+ the highest. The 64 bits specifying the block is then represented
+ by the following 64 bit integer:
+
+ int64bit = 256*(256*(256*(256*(256*(256*(256*q0+q1)+q2)+q3)+q4)+q5)+q6)+q7;
+
+ ETC1_RGB8_OES:
+
+ a) bit layout in bits 63 through 32 if diffbit = 0
+
+ 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48
+ -----------------------------------------------
+ | base col1 | base col2 | base col1 | base col2 |
+ | R1 (4bits)| R2 (4bits)| G1 (4bits)| G2 (4bits)|
+ -----------------------------------------------
+
+ 47 46 45 44 43 42 41 40 39 38 37 36 35 34  33  32
+ ---------------------------------------------------
+ | base col1 | base col2 | table  | table  |diff|flip|
+ | B1 (4bits)| B2 (4bits)| cw 1   | cw 2   |bit |bit |
+ ---------------------------------------------------
+
+
+ b) bit layout in bits 63 through 32 if diffbit = 1
+
+ 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48
+ -----------------------------------------------
+ | base col1    | dcol 2 | base col1    | dcol 2 |
+ | R1' (5 bits) | dR2    | G1' (5 bits) | dG2    |
+ -----------------------------------------------
+
+ 47 46 45 44 43 42 41 40 39 38 37 36 35 34  33  32
+ ---------------------------------------------------
+ | base col 1   | dcol 2 | table  | table  |diff|flip|
+ | B1' (5 bits) | dB2    | cw 1   | cw 2   |bit |bit |
+ ---------------------------------------------------
+
+
+ c) bit layout in bits 31 through 0 (in both cases)
+
+ 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16
+ -----------------------------------------------
+ |       most significant pixel index bits       |
+ | p| o| n| m| l| k| j| i| h| g| f| e| d| c| b| a|
+ -----------------------------------------------
+
+ 15 14 13 12 11 10  9  8  7  6  5  4  3   2   1  0
+ --------------------------------------------------
+ |         least significant pixel index bits       |
+ | p| o| n| m| l| k| j| i| h| g| f| e| d| c | b | a |
+ --------------------------------------------------
+
+
+ Add table 3.17.2: Intensity modifier sets for ETC1 compressed textures:
+
+ table codeword                modifier table
+ ------------------        ----------------------
+ 0                     -8  -2  2   8
+ 1                    -17  -5  5  17
+ 2                    -29  -9  9  29
+ 3                    -42 -13 13  42
+ 4                    -60 -18 18  60
+ 5                    -80 -24 24  80
+ 6                   -106 -33 33 106
+ 7                   -183 -47 47 183
+
+
+ Add table 3.17.3 Mapping from pixel index values to modifier values for
+ ETC1 compressed textures:
+
+ pixel index value
+ ---------------
+ msb     lsb           resulting modifier value
+ -----   -----          -------------------------
+ 1       1            -b (large negative value)
+ 1       0            -a (small negative value)
+ 0       0             a (small positive value)
+ 0       1             b (large positive value)
+
+
+ */
+
+static const int kModifierTable[] = {
+/* 0 */2, 8, -2, -8,
+/* 1 */5, 17, -5, -17,
+/* 2 */9, 29, -9, -29,
+/* 3 */13, 42, -13, -42,
+/* 4 */18, 60, -18, -60,
+/* 5 */24, 80, -24, -80,
+/* 6 */33, 106, -33, -106,
+/* 7 */47, 183, -47, -183 };
+
+static const int kLookup[8] = { 0, 1, 2, 3, -4, -3, -2, -1 };
+
+static inline etc1_byte clamp(int x) {
+    return (etc1_byte) (x >= 0 ? (x < 255 ? x : 255) : 0);
+}
+
+static
+inline int convert4To8(int b) {
+    int c = b & 0xf;
+    return (c << 4) | c;
+}
+
+static
+inline int convert5To8(int b) {
+    int c = b & 0x1f;
+    return (c << 3) | (c >> 2);
+}
+
+static
+inline int convert6To8(int b) {
+    int c = b & 0x3f;
+    return (c << 2) | (c >> 4);
+}
+
+static
+inline int divideBy255(int d) {
+    return (d + 128 + (d >> 8)) >> 8;
+}
+
+static
+inline int convert8To4(int b) {
+    int c = b & 0xff;
+    return divideBy255(c * 15);
+}
+
+static
+inline int convert8To5(int b) {
+    int c = b & 0xff;
+    return divideBy255(c * 31);
+}
+
+static
+inline int convertDiff(int base, int diff) {
+    return convert5To8((0x1f & base) + kLookup[0x7 & diff]);
+}
+
+static
+void decode_subblock(etc1_byte* pOut, int r, int g, int b, const int* table,
+        etc1_uint32 low, bool second, bool flipped) {
+    int baseX = 0;
+    int baseY = 0;
+    if (second) {
+        if (flipped) {
+            baseY = 2;
+        } else {
+            baseX = 2;
+        }
+    }
+    for (int i = 0; i < 8; i++) {
+        int x, y;
+        if (flipped) {
+            x = baseX + (i >> 1);
+            y = baseY + (i & 1);
+        } else {
+            x = baseX + (i >> 2);
+            y = baseY + (i & 3);
+        }
+        int k = y + (x * 4);
+        int offset = ((low >> k) & 1) | ((low >> (k + 15)) & 2);
+        int delta = table[offset];
+        etc1_byte* q = pOut + 3 * (x + 4 * y);
+        *q++ = clamp(r + delta);
+        *q++ = clamp(g + delta);
+        *q++ = clamp(b + delta);
+    }
+}
+
+// Input is an ETC1 compressed version of the data.
+// Output is a 4 x 4 square of 3-byte pixels in form R, G, B
+
+void etc1_decode_block(const etc1_byte* pIn, etc1_byte* pOut) {
+    etc1_uint32 high = (pIn[0] << 24) | (pIn[1] << 16) | (pIn[2] << 8) | pIn[3];
+    etc1_uint32 low = (pIn[4] << 24) | (pIn[5] << 16) | (pIn[6] << 8) | pIn[7];
+    int r1, r2, g1, g2, b1, b2;
+    if (high & 2) {
+        // differential
+        int rBase = high >> 27;
+        int gBase = high >> 19;
+        int bBase = high >> 11;
+        r1 = convert5To8(rBase);
+        r2 = convertDiff(rBase, high >> 24);
+        g1 = convert5To8(gBase);
+        g2 = convertDiff(gBase, high >> 16);
+        b1 = convert5To8(bBase);
+        b2 = convertDiff(bBase, high >> 8);
+    } else {
+        // not differential
+        r1 = convert4To8(high >> 28);
+        r2 = convert4To8(high >> 24);
+        g1 = convert4To8(high >> 20);
+        g2 = convert4To8(high >> 16);
+        b1 = convert4To8(high >> 12);
+        b2 = convert4To8(high >> 8);
+    }
+    int tableIndexA = 7 & (high >> 5);
+    int tableIndexB = 7 & (high >> 2);
+    const int* tableA = kModifierTable + tableIndexA * 4;
+    const int* tableB = kModifierTable + tableIndexB * 4;
+    bool flipped = (high & 1) != 0;
+    decode_subblock(pOut, r1, g1, b1, tableA, low, false, flipped);
+    decode_subblock(pOut, r2, g2, b2, tableB, low, true, flipped);
+}
+
+typedef struct {
+    etc1_uint32 high;
+    etc1_uint32 low;
+    etc1_uint32 score; // Lower is more accurate
+} etc_compressed;
+
+static
+inline void take_best(etc_compressed* a, const etc_compressed* b) {
+    if (a->score > b->score) {
+        *a = *b;
+    }
+}
+
+static
+void etc_average_colors_subblock(const etc1_byte* pIn, etc1_uint32 inMask,
+        etc1_byte* pColors, bool flipped, bool second) {
+    int r = 0;
+    int g = 0;
+    int b = 0;
+
+    if (flipped) {
+        int by = 0;
+        if (second) {
+            by = 2;
+        }
+        for (int y = 0; y < 2; y++) {
+            int yy = by + y;
+            for (int x = 0; x < 4; x++) {
+                int i = x + 4 * yy;
+                if (inMask & (1 << i)) {
+                    const etc1_byte* p = pIn + i * 3;
+                    r += *(p++);
+                    g += *(p++);
+                    b += *(p++);
+                }
+            }
+        }
+    } else {
+        int bx = 0;
+        if (second) {
+            bx = 2;
+        }
+        for (int y = 0; y < 4; y++) {
+            for (int x = 0; x < 2; x++) {
+                int xx = bx + x;
+                int i = xx + 4 * y;
+                if (inMask & (1 << i)) {
+                    const etc1_byte* p = pIn + i * 3;
+                    r += *(p++);
+                    g += *(p++);
+                    b += *(p++);
+                }
+            }
+        }
+    }
+    pColors[0] = (etc1_byte)((r + 4) >> 3);
+    pColors[1] = (etc1_byte)((g + 4) >> 3);
+    pColors[2] = (etc1_byte)((b + 4) >> 3);
+}
+
+static
+inline int square(int x) {
+    return x * x;
+}
+
+static etc1_uint32 chooseModifier(const etc1_byte* pBaseColors,
+        const etc1_byte* pIn, etc1_uint32 *pLow, int bitIndex,
+        const int* pModifierTable) {
+    etc1_uint32 bestScore = ~0;
+    int bestIndex = 0;
+    int pixelR = pIn[0];
+    int pixelG = pIn[1];
+    int pixelB = pIn[2];
+    int r = pBaseColors[0];
+    int g = pBaseColors[1];
+    int b = pBaseColors[2];
+    for (int i = 0; i < 4; i++) {
+        int modifier = pModifierTable[i];
+        int decodedG = clamp(g + modifier);
+        etc1_uint32 score = (etc1_uint32) (6 * square(decodedG - pixelG));
+        if (score >= bestScore) {
+            continue;
+        }
+        int decodedR = clamp(r + modifier);
+        score += (etc1_uint32) (3 * square(decodedR - pixelR));
+        if (score >= bestScore) {
+            continue;
+        }
+        int decodedB = clamp(b + modifier);
+        score += (etc1_uint32) square(decodedB - pixelB);
+        if (score < bestScore) {
+            bestScore = score;
+            bestIndex = i;
+        }
+    }
+    etc1_uint32 lowMask = (((bestIndex >> 1) << 16) | (bestIndex & 1))
+            << bitIndex;
+    *pLow |= lowMask;
+    return bestScore;
+}
+
+static
+void etc_encode_subblock_helper(const etc1_byte* pIn, etc1_uint32 inMask,
+        etc_compressed* pCompressed, bool flipped, bool second,
+        const etc1_byte* pBaseColors, const int* pModifierTable) {
+    int score = pCompressed->score;
+    if (flipped) {
+        int by = 0;
+        if (second) {
+            by = 2;
+        }
+        for (int y = 0; y < 2; y++) {
+            int yy = by + y;
+            for (int x = 0; x < 4; x++) {
+                int i = x + 4 * yy;
+                if (inMask & (1 << i)) {
+                    score += chooseModifier(pBaseColors, pIn + i * 3,
+                            &pCompressed->low, yy + x * 4, pModifierTable);
+                }
+            }
+        }
+    } else {
+        int bx = 0;
+        if (second) {
+            bx = 2;
+        }
+        for (int y = 0; y < 4; y++) {
+            for (int x = 0; x < 2; x++) {
+                int xx = bx + x;
+                int i = xx + 4 * y;
+                if (inMask & (1 << i)) {
+                    score += chooseModifier(pBaseColors, pIn + i * 3,
+                            &pCompressed->low, y + xx * 4, pModifierTable);
+                }
+            }
+        }
+    }
+    pCompressed->score = score;
+}
+
+static bool inRange4bitSigned(int color) {
+    return color >= -4 && color <= 3;
+}
+
+static void etc_encodeBaseColors(etc1_byte* pBaseColors,
+        const etc1_byte* pColors, etc_compressed* pCompressed) {
+    int r1, g1, b1, r2, g2, b2; // 8 bit base colors for sub-blocks
+    bool differential;
+    {
+        int r51 = convert8To5(pColors[0]);
+        int g51 = convert8To5(pColors[1]);
+        int b51 = convert8To5(pColors[2]);
+        int r52 = convert8To5(pColors[3]);
+        int g52 = convert8To5(pColors[4]);
+        int b52 = convert8To5(pColors[5]);
+
+        r1 = convert5To8(r51);
+        g1 = convert5To8(g51);
+        b1 = convert5To8(b51);
+
+        int dr = r52 - r51;
+        int dg = g52 - g51;
+        int db = b52 - b51;
+
+        differential = inRange4bitSigned(dr) && inRange4bitSigned(dg)
+                && inRange4bitSigned(db);
+        if (differential) {
+            r2 = convert5To8(r51 + dr);
+            g2 = convert5To8(g51 + dg);
+            b2 = convert5To8(b51 + db);
+            pCompressed->high |= (r51 << 27) | ((7 & dr) << 24) | (g51 << 19)
+                    | ((7 & dg) << 16) | (b51 << 11) | ((7 & db) << 8) | 2;
+        }
+    }
+
+    if (!differential) {
+        int r41 = convert8To4(pColors[0]);
+        int g41 = convert8To4(pColors[1]);
+        int b41 = convert8To4(pColors[2]);
+        int r42 = convert8To4(pColors[3]);
+        int g42 = convert8To4(pColors[4]);
+        int b42 = convert8To4(pColors[5]);
+        r1 = convert4To8(r41);
+        g1 = convert4To8(g41);
+        b1 = convert4To8(b41);
+        r2 = convert4To8(r42);
+        g2 = convert4To8(g42);
+        b2 = convert4To8(b42);
+        pCompressed->high |= (r41 << 28) | (r42 << 24) | (g41 << 20) | (g42
+                << 16) | (b41 << 12) | (b42 << 8);
+    }
+    pBaseColors[0] = r1;
+    pBaseColors[1] = g1;
+    pBaseColors[2] = b1;
+    pBaseColors[3] = r2;
+    pBaseColors[4] = g2;
+    pBaseColors[5] = b2;
+}
+
+static
+void etc_encode_block_helper(const etc1_byte* pIn, etc1_uint32 inMask,
+        const etc1_byte* pColors, etc_compressed* pCompressed, bool flipped) {
+    pCompressed->score = ~0;
+    pCompressed->high = (flipped ? 1 : 0);
+    pCompressed->low = 0;
+
+    etc1_byte pBaseColors[6];
+
+    etc_encodeBaseColors(pBaseColors, pColors, pCompressed);
+
+    int originalHigh = pCompressed->high;
+
+    const int* pModifierTable = kModifierTable;
+    for (int i = 0; i < 8; i++, pModifierTable += 4) {
+        etc_compressed temp;
+        temp.score = 0;
+        temp.high = originalHigh | (i << 5);
+        temp.low = 0;
+        etc_encode_subblock_helper(pIn, inMask, &temp, flipped, false,
+                pBaseColors, pModifierTable);
+        take_best(pCompressed, &temp);
+    }
+    pModifierTable = kModifierTable;
+    etc_compressed firstHalf = *pCompressed;
+    for (int i = 0; i < 8; i++, pModifierTable += 4) {
+        etc_compressed temp;
+        temp.score = firstHalf.score;
+        temp.high = firstHalf.high | (i << 2);
+        temp.low = firstHalf.low;
+        etc_encode_subblock_helper(pIn, inMask, &temp, flipped, true,
+                pBaseColors + 3, pModifierTable);
+        if (i == 0) {
+            *pCompressed = temp;
+        } else {
+            take_best(pCompressed, &temp);
+        }
+    }
+}
+
+static void writeBigEndian(etc1_byte* pOut, etc1_uint32 d) {
+    pOut[0] = (etc1_byte)(d >> 24);
+    pOut[1] = (etc1_byte)(d >> 16);
+    pOut[2] = (etc1_byte)(d >> 8);
+    pOut[3] = (etc1_byte) d;
+}
+
+// Input is a 4 x 4 square of 3-byte pixels in form R, G, B
+// inmask is a 16-bit mask where bit (1 << (x + y * 4)) tells whether the corresponding (x,y)
+// pixel is valid or not. Invalid pixel color values are ignored when compressing.
+// Output is an ETC1 compressed version of the data.
+
+void etc1_encode_block(const etc1_byte* pIn, etc1_uint32 inMask,
+        etc1_byte* pOut) {
+    etc1_byte colors[6];
+    etc1_byte flippedColors[6];
+    etc_average_colors_subblock(pIn, inMask, colors, false, false);
+    etc_average_colors_subblock(pIn, inMask, colors + 3, false, true);
+    etc_average_colors_subblock(pIn, inMask, flippedColors, true, false);
+    etc_average_colors_subblock(pIn, inMask, flippedColors + 3, true, true);
+
+    etc_compressed a, b;
+    etc_encode_block_helper(pIn, inMask, colors, &a, false);
+    etc_encode_block_helper(pIn, inMask, flippedColors, &b, true);
+    take_best(&a, &b);
+    writeBigEndian(pOut, a.high);
+    writeBigEndian(pOut + 4, a.low);
+}
+
+// Return the size of the encoded image data (does not include size of PKM header).
+
+etc1_uint32 etc1_get_encoded_data_size(etc1_uint32 width, etc1_uint32 height) {
+    return (((width + 3) & ~3) * ((height + 3) & ~3)) >> 1;
+}
+
+// Encode an entire image.
+// pIn - pointer to the image data. Formatted such that the Red component of
+//       pixel (x,y) is at pIn + pixelSize * x + stride * y + redOffset;
+// pOut - pointer to encoded data. Must be large enough to store entire encoded image.
+
+int etc1_encode_image(const etc1_byte* pIn, etc1_uint32 width, etc1_uint32 height,
+        etc1_uint32 pixelSize, etc1_uint32 stride, etc1_byte* pOut) {
+    if (pixelSize < 2 || pixelSize > 4) {
+        return -1;
+    }
+    static const unsigned short kYMask[] = { 0x0, 0xf, 0xff, 0xfff, 0xffff };
+    static const unsigned short kXMask[] = { 0x0, 0x1111, 0x3333, 0x7777,
+            0xffff };
+    etc1_byte block[ETC1_DECODED_BLOCK_SIZE];
+    etc1_byte encoded[ETC1_ENCODED_BLOCK_SIZE];
+
+    etc1_uint32 encodedWidth = (width + 3) & ~3;
+    etc1_uint32 encodedHeight = (height + 3) & ~3;
+
+    for (etc1_uint32 y = 0; y < encodedHeight; y += 4) {
+        etc1_uint32 yEnd = height - y;
+        if (yEnd > 4) {
+            yEnd = 4;
+        }
+        int ymask = kYMask[yEnd];
+        for (etc1_uint32 x = 0; x < encodedWidth; x += 4) {
+            etc1_uint32 xEnd = width - x;
+            if (xEnd > 4) {
+                xEnd = 4;
+            }
+            int mask = ymask & kXMask[xEnd];
+            for (etc1_uint32 cy = 0; cy < yEnd; cy++) {
+                etc1_byte* q = block + (cy * 4) * 3;
+                const etc1_byte* p = pIn + pixelSize * x + stride * (y + cy);
+                if (pixelSize >= 3) {
+                    for (etc1_uint32 cx = 0; cx < xEnd; cx++) {
+                        memcpy(q, p, 3);
+                        q += 3;
+                        p += pixelSize;
+                    }
+                } else {
+                    for (etc1_uint32 cx = 0; cx < xEnd; cx++) {
+                        int pixel = (p[1] << 8) | p[0];
+                        *q++ = convert5To8(pixel >> 11);
+                        *q++ = convert6To8(pixel >> 5);
+                        *q++ = convert5To8(pixel);
+                        p += pixelSize;
+                    }
+                }
+            }
+            etc1_encode_block(block, mask, encoded);
+            memcpy(pOut, encoded, sizeof(encoded));
+            pOut += sizeof(encoded);
+        }
+    }
+    return 0;
+}
+
+// Decode an entire image.
+// pIn - pointer to encoded data.
+// pOut - pointer to the image data. Will be written such that the Red component of
+//       pixel (x,y) is at pIn + pixelSize * x + stride * y + redOffset. Must be
+//        large enough to store entire image.
+
+
+int etc1_decode_image(const etc1_byte* pIn, etc1_byte* pOut,
+        etc1_uint32 width, etc1_uint32 height,
+        etc1_uint32 pixelSize, etc1_uint32 stride) {
+    if (pixelSize < 2 || pixelSize > 4) {
+        return -1;
+    }
+    etc1_byte block[ETC1_DECODED_BLOCK_SIZE];
+
+    etc1_uint32 encodedWidth = (width + 3) & ~3;
+    etc1_uint32 encodedHeight = (height + 3) & ~3;
+
+    for (etc1_uint32 y = 0; y < encodedHeight; y += 4) {
+        etc1_uint32 yEnd = height - y;
+        if (yEnd > 4) {
+            yEnd = 4;
+        }
+        for (etc1_uint32 x = 0; x < encodedWidth; x += 4) {
+            etc1_uint32 xEnd = width - x;
+            if (xEnd > 4) {
+                xEnd = 4;
+            }
+            etc1_decode_block(pIn, block);
+            pIn += ETC1_ENCODED_BLOCK_SIZE;
+            for (etc1_uint32 cy = 0; cy < yEnd; cy++) {
+                const etc1_byte* q = block + (cy * 4) * 3;
+                etc1_byte* p = pOut + pixelSize * x + stride * (y + cy);
+                if (pixelSize >= 3) {
+                    for (etc1_uint32 cx = 0; cx < xEnd; cx++) {
+                        memcpy(p, q, 3);
+                        q += 3;
+                        p += pixelSize;
+                    }
+                } else {
+                    for (etc1_uint32 cx = 0; cx < xEnd; cx++) {
+                        etc1_byte r = *q++;
+                        etc1_byte g = *q++;
+                        etc1_byte b = *q++;
+                        etc1_uint32 pixel = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
+                        *p++ = (etc1_byte) pixel;
+                        *p++ = (etc1_byte) (pixel >> 8);
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+static const char kMagic[] = { 'P', 'K', 'M', ' ', '1', '0' };
+
+static const etc1_uint32 ETC1_PKM_FORMAT_OFFSET = 6;
+static const etc1_uint32 ETC1_PKM_ENCODED_WIDTH_OFFSET = 8;
+static const etc1_uint32 ETC1_PKM_ENCODED_HEIGHT_OFFSET = 10;
+static const etc1_uint32 ETC1_PKM_WIDTH_OFFSET = 12;
+static const etc1_uint32 ETC1_PKM_HEIGHT_OFFSET = 14;
+
+static const etc1_uint32 ETC1_RGB_NO_MIPMAPS = 0;
+
+static void writeBEUint16(etc1_byte* pOut, etc1_uint32 data) {
+    pOut[0] = (etc1_byte) (data >> 8);
+    pOut[1] = (etc1_byte) data;
+}
+
+static etc1_uint32 readBEUint16(const etc1_byte* pIn) {
+    return (pIn[0] << 8) | pIn[1];
+}
+
+// Format a PKM header
+
+void etc1_pkm_format_header(etc1_byte* pHeader, etc1_uint32 width, etc1_uint32 height) {
+    memcpy(pHeader, kMagic, sizeof(kMagic));
+    etc1_uint32 encodedWidth = (width + 3) & ~3;
+    etc1_uint32 encodedHeight = (height + 3) & ~3;
+    writeBEUint16(pHeader + ETC1_PKM_FORMAT_OFFSET, ETC1_RGB_NO_MIPMAPS);
+    writeBEUint16(pHeader + ETC1_PKM_ENCODED_WIDTH_OFFSET, encodedWidth);
+    writeBEUint16(pHeader + ETC1_PKM_ENCODED_HEIGHT_OFFSET, encodedHeight);
+    writeBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET, width);
+    writeBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET, height);
+}
+
+// Check if a PKM header is correctly formatted.
+
+etc1_bool etc1_pkm_is_valid(const etc1_byte* pHeader) {
+    if (memcmp(pHeader, kMagic, sizeof(kMagic))) {
+        return false;
+    }
+    etc1_uint32 format = readBEUint16(pHeader + ETC1_PKM_FORMAT_OFFSET);
+    etc1_uint32 encodedWidth = readBEUint16(pHeader + ETC1_PKM_ENCODED_WIDTH_OFFSET);
+    etc1_uint32 encodedHeight = readBEUint16(pHeader + ETC1_PKM_ENCODED_HEIGHT_OFFSET);
+    etc1_uint32 width = readBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET);
+    etc1_uint32 height = readBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET);
+    return format == ETC1_RGB_NO_MIPMAPS &&
+            encodedWidth >= width && encodedWidth - width < 4 &&
+            encodedHeight >= height && encodedHeight - height < 4;
+}
+
+// Read the image width from a PKM header
+
+etc1_uint32 etc1_pkm_get_width(const etc1_byte* pHeader) {
+    return readBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET);
+}
+
+// Read the image height from a PKM header
+
+etc1_uint32 etc1_pkm_get_height(const etc1_byte* pHeader){
+    return readBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET);
+}

3rdparty/bgfx/3rdparty/etc1/etc1.h

@@ -0,0 +1,114 @@
+// Copyright 2009 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// This is a fork of the AOSP project ETC1 codec. The original code can be found
+// at the following web site:
+// https://android.googlesource.com/platform/frameworks/native/+/master/opengl/libs/ETC1/
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __etc1_h__
+#define __etc1_h__
+
+#define ETC1_ENCODED_BLOCK_SIZE 8
+#define ETC1_DECODED_BLOCK_SIZE 48
+
+#ifndef ETC1_RGB8_OES
+#define ETC1_RGB8_OES 0x8D64
+#endif
+
+typedef unsigned char etc1_byte;
+typedef int etc1_bool;
+typedef unsigned int etc1_uint32;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Encode a block of pixels.
+//
+// pIn is a pointer to a ETC_DECODED_BLOCK_SIZE array of bytes that represent a
+// 4 x 4 square of 3-byte pixels in form R, G, B. Byte (3 * (x + 4 * y) is the R
+// value of pixel (x, y).
+//
+// validPixelMask is a 16-bit mask where bit (1 << (x + y * 4)) indicates whether
+// the corresponding (x,y) pixel is valid. Invalid pixel color values are ignored when compressing.
+//
+// pOut is an ETC1 compressed version of the data.
+
+void etc1_encode_block(const etc1_byte* pIn, etc1_uint32 validPixelMask, etc1_byte* pOut);
+
+// Decode a block of pixels.
+//
+// pIn is an ETC1 compressed version of the data.
+//
+// pOut is a pointer to a ETC_DECODED_BLOCK_SIZE array of bytes that represent a
+// 4 x 4 square of 3-byte pixels in form R, G, B. Byte (3 * (x + 4 * y) is the R
+// value of pixel (x, y).
+
+void etc1_decode_block(const etc1_byte* pIn, etc1_byte* pOut);
+
+// Return the size of the encoded image data (does not include size of PKM header).
+
+etc1_uint32 etc1_get_encoded_data_size(etc1_uint32 width, etc1_uint32 height);
+
+// Encode an entire image.
+// pIn - pointer to the image data. Formatted such that
+//       pixel (x,y) is at pIn + pixelSize * x + stride * y;
+// pOut - pointer to encoded data. Must be large enough to store entire encoded image.
+// pixelSize can be 2 or 3. 2 is an GL_UNSIGNED_SHORT_5_6_5 image, 3 is a GL_BYTE RGB image.
+// returns non-zero if there is an error.
+
+int etc1_encode_image(const etc1_byte* pIn, etc1_uint32 width, etc1_uint32 height,
+        etc1_uint32 pixelSize, etc1_uint32 stride, etc1_byte* pOut);
+
+// Decode an entire image.
+// pIn - pointer to encoded data.
+// pOut - pointer to the image data. Will be written such that
+//        pixel (x,y) is at pIn + pixelSize * x + stride * y. Must be
+//        large enough to store entire image.
+// pixelSize can be 2 or 3. 2 is an GL_UNSIGNED_SHORT_5_6_5 image, 3 is a GL_BYTE RGB image.
+// returns non-zero if there is an error.
+
+int etc1_decode_image(const etc1_byte* pIn, etc1_byte* pOut,
+        etc1_uint32 width, etc1_uint32 height,
+        etc1_uint32 pixelSize, etc1_uint32 stride);
+
+// Size of a PKM header, in bytes.
+
+#define ETC_PKM_HEADER_SIZE 16
+
+// Format a PKM header
+
+void etc1_pkm_format_header(etc1_byte* pHeader, etc1_uint32 width, etc1_uint32 height);
+
+// Check if a PKM header is correctly formatted.
+
+etc1_bool etc1_pkm_is_valid(const etc1_byte* pHeader);
+
+// Read the image width from a PKM header
+
+etc1_uint32 etc1_pkm_get_width(const etc1_byte* pHeader);
+
+// Read the image height from a PKM header
+
+etc1_uint32 etc1_pkm_get_height(const etc1_byte* pHeader);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/bgfx/3rdparty/etc2/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright (c) 2013, Bartosz Taudul <wolf.pld@gmail.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3rdparty/bgfx/3rdparty/etc2/Math.hpp

@@ -0,0 +1,90 @@
+#ifndef __DARKRL__MATH_HPP__
+#define __DARKRL__MATH_HPP__
+
+#include <algorithm>
+#include <math.h>
+
+#include "Types.hpp"
+
+template<typename T>
+inline T AlignPOT( T val )
+{
+    if( val == 0 ) return 1;
+    val--;
+    for( unsigned int i=1; i<sizeof( T ) * 8; i <<= 1 )
+    {
+        val |= val >> i;
+    }
+    return val + 1;
+}
+
+inline int CountSetBits( uint32 val )
+{
+    val -= ( val >> 1 ) & 0x55555555;
+    val = ( ( val >> 2 ) & 0x33333333 ) + ( val & 0x33333333 );
+    val = ( ( val >> 4 ) + val ) & 0x0f0f0f0f;
+    val += val >> 8;
+    val += val >> 16;
+    return val & 0x0000003f;
+}
+
+inline int CountLeadingZeros( uint32 val )
+{
+    val |= val >> 1;
+    val |= val >> 2;
+    val |= val >> 4;
+    val |= val >> 8;
+    val |= val >> 16;
+    return 32 - CountSetBits( val );
+}
+
+inline float sRGB2linear( float v )
+{
+    const float a = 0.055f;
+    if( v <= 0.04045f )
+    {
+        return v / 12.92f;
+    }
+    else
+    {
+        return powf( ( v + a ) / ( 1 + a ), 2.4f );
+    }
+}
+
+inline float linear2sRGB( float v )
+{
+    const float a = 0.055f;
+    if( v <= 0.0031308f )
+    {
+        return 12.92f * v;
+    }
+    else
+    {
+        return ( 1 + a ) * pow( v, 1/2.4f ) - a;
+    }
+}
+
+template<class T>
+inline T SmoothStep( T x )
+{
+    return x*x*(3-2*x);
+}
+
+inline uint8 clampu8( int32 val )
+{
+    return std::min( std::max( 0, val ), 255 );
+}
+
+template<class T>
+inline T sq( T val )
+{
+    return val * val;
+}
+
+static inline int mul8bit( int a, int b )
+{
+    int t = a*b + 128;
+    return ( t + ( t >> 8 ) ) >> 8;
+}
+
+#endif

3rdparty/bgfx/3rdparty/etc2/ProcessCommon.hpp

@@ -0,0 +1,51 @@
+#ifndef __PROCESSCOMMON_HPP__
+#define __PROCESSCOMMON_HPP__
+
+#include <assert.h>
+#include <stddef.h>
+
+#include "Types.hpp"
+
+template<class T>
+static size_t GetLeastError( const T* err, size_t num )
+{
+    size_t idx = 0;
+    for( size_t i=1; i<num; i++ )
+    {
+        if( err[i] < err[idx] )
+        {
+            idx = i;
+        }
+    }
+    return idx;
+}
+
+static uint64 FixByteOrder( uint64 d )
+{
+    return ( ( d & 0x00000000FFFFFFFF ) ) |
+           ( ( d & 0xFF00000000000000 ) >> 24 ) |
+           ( ( d & 0x000000FF00000000 ) << 24 ) |
+           ( ( d & 0x00FF000000000000 ) >> 8 ) |
+           ( ( d & 0x0000FF0000000000 ) << 8 );
+}
+
+template<class T, class S>
+static uint64 EncodeSelectors( uint64 d, const T terr[2][8], const S tsel[16][8], const uint32* id )
+{
+    size_t tidx[2];
+    tidx[0] = GetLeastError( terr[0], 8 );
+    tidx[1] = GetLeastError( terr[1], 8 );
+
+    d |= tidx[0] << 26;
+    d |= tidx[1] << 29;
+    for( int i=0; i<16; i++ )
+    {
+        uint64 t = tsel[i][tidx[id[i]%2]];
+        d |= ( t & 0x1 ) << ( i + 32 );
+        d |= ( t & 0x2 ) << ( i + 47 );
+    }
+
+    return d;
+}
+
+#endif

3rdparty/bgfx/3rdparty/etc2/ProcessRGB.cpp

@@ -0,0 +1,719 @@
+#include <string.h>
+
+#include "Math.hpp"
+#include "ProcessCommon.hpp"
+#include "ProcessRGB.hpp"
+#include "Tables.hpp"
+#include "Types.hpp"
+#include "Vector.hpp"
+
+#include <bx/endian.h>
+
+#ifdef __SSE4_1__
+#  ifdef _MSC_VER
+#    include <intrin.h>
+#    include <Windows.h>
+#  else
+#    include <x86intrin.h>
+#  endif
+#endif
+
+namespace
+{
+
+typedef uint16 v4i[4];
+
+void Average( const uint8* data, v4i* a )
+{
+#ifdef __SSE4_1__
+    __m128i d0 = _mm_loadu_si128(((__m128i*)data) + 0);
+    __m128i d1 = _mm_loadu_si128(((__m128i*)data) + 1);
+    __m128i d2 = _mm_loadu_si128(((__m128i*)data) + 2);
+    __m128i d3 = _mm_loadu_si128(((__m128i*)data) + 3);
+
+    __m128i d0l = _mm_unpacklo_epi8(d0, _mm_setzero_si128());
+    __m128i d0h = _mm_unpackhi_epi8(d0, _mm_setzero_si128());
+    __m128i d1l = _mm_unpacklo_epi8(d1, _mm_setzero_si128());
+    __m128i d1h = _mm_unpackhi_epi8(d1, _mm_setzero_si128());
+    __m128i d2l = _mm_unpacklo_epi8(d2, _mm_setzero_si128());
+    __m128i d2h = _mm_unpackhi_epi8(d2, _mm_setzero_si128());
+    __m128i d3l = _mm_unpacklo_epi8(d3, _mm_setzero_si128());
+    __m128i d3h = _mm_unpackhi_epi8(d3, _mm_setzero_si128());
+
+    __m128i sum0 = _mm_add_epi16(d0l, d1l);
+    __m128i sum1 = _mm_add_epi16(d0h, d1h);
+    __m128i sum2 = _mm_add_epi16(d2l, d3l);
+    __m128i sum3 = _mm_add_epi16(d2h, d3h);
+
+    __m128i sum0l = _mm_unpacklo_epi16(sum0, _mm_setzero_si128());
+    __m128i sum0h = _mm_unpackhi_epi16(sum0, _mm_setzero_si128());
+    __m128i sum1l = _mm_unpacklo_epi16(sum1, _mm_setzero_si128());
+    __m128i sum1h = _mm_unpackhi_epi16(sum1, _mm_setzero_si128());
+    __m128i sum2l = _mm_unpacklo_epi16(sum2, _mm_setzero_si128());
+    __m128i sum2h = _mm_unpackhi_epi16(sum2, _mm_setzero_si128());
+    __m128i sum3l = _mm_unpacklo_epi16(sum3, _mm_setzero_si128());
+    __m128i sum3h = _mm_unpackhi_epi16(sum3, _mm_setzero_si128());
+
+    __m128i b0 = _mm_add_epi32(sum0l, sum0h);
+    __m128i b1 = _mm_add_epi32(sum1l, sum1h);
+    __m128i b2 = _mm_add_epi32(sum2l, sum2h);
+    __m128i b3 = _mm_add_epi32(sum3l, sum3h);
+
+    __m128i a0 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b2, b3), _mm_set1_epi32(4)), 3);
+    __m128i a1 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b0, b1), _mm_set1_epi32(4)), 3);
+    __m128i a2 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b1, b3), _mm_set1_epi32(4)), 3);
+    __m128i a3 = _mm_srli_epi32(_mm_add_epi32(_mm_add_epi32(b0, b2), _mm_set1_epi32(4)), 3);
+
+    _mm_storeu_si128((__m128i*)&a[0], _mm_packus_epi32(_mm_shuffle_epi32(a0, _MM_SHUFFLE(3, 0, 1, 2)), _mm_shuffle_epi32(a1, _MM_SHUFFLE(3, 0, 1, 2))));
+    _mm_storeu_si128((__m128i*)&a[2], _mm_packus_epi32(_mm_shuffle_epi32(a2, _MM_SHUFFLE(3, 0, 1, 2)), _mm_shuffle_epi32(a3, _MM_SHUFFLE(3, 0, 1, 2))));
+#else
+    uint32 r[4];
+    uint32 g[4];
+    uint32 b[4];
+
+    memset(r, 0, sizeof(r));
+    memset(g, 0, sizeof(g));
+    memset(b, 0, sizeof(b));
+
+    for( int j=0; j<4; j++ )
+    {
+        for( int i=0; i<4; i++ )
+        {
+            int index = (j & 2) + (i >> 1);
+            b[index] += *data++;
+            g[index] += *data++;
+            r[index] += *data++;
+            data++;
+        }
+    }
+
+    a[0][0] = uint16( (r[2] + r[3] + 4) / 8 );
+    a[0][1] = uint16( (g[2] + g[3] + 4) / 8 );
+    a[0][2] = uint16( (b[2] + b[3] + 4) / 8 );
+    a[0][3] = 0;
+    a[1][0] = uint16( (r[0] + r[1] + 4) / 8 );
+    a[1][1] = uint16( (g[0] + g[1] + 4) / 8 );
+    a[1][2] = uint16( (b[0] + b[1] + 4) / 8 );
+    a[1][3] = 0;
+    a[2][0] = uint16( (r[1] + r[3] + 4) / 8 );
+    a[2][1] = uint16( (g[1] + g[3] + 4) / 8 );
+    a[2][2] = uint16( (b[1] + b[3] + 4) / 8 );
+    a[2][3] = 0;
+    a[3][0] = uint16( (r[0] + r[2] + 4) / 8 );
+    a[3][1] = uint16( (g[0] + g[2] + 4) / 8 );
+    a[3][2] = uint16( (b[0] + b[2] + 4) / 8 );
+    a[3][3] = 0;
+#endif
+}
+
+void CalcErrorBlock( const uint8* data, uint err[4][4] )
+{
+#ifdef __SSE4_1__
+    __m128i d0 = _mm_loadu_si128(((__m128i*)data) + 0);
+    __m128i d1 = _mm_loadu_si128(((__m128i*)data) + 1);
+    __m128i d2 = _mm_loadu_si128(((__m128i*)data) + 2);
+    __m128i d3 = _mm_loadu_si128(((__m128i*)data) + 3);
+
+    __m128i dm0 = _mm_and_si128(d0, _mm_set1_epi32(0x00FFFFFF));
+    __m128i dm1 = _mm_and_si128(d1, _mm_set1_epi32(0x00FFFFFF));
+    __m128i dm2 = _mm_and_si128(d2, _mm_set1_epi32(0x00FFFFFF));
+    __m128i dm3 = _mm_and_si128(d3, _mm_set1_epi32(0x00FFFFFF));
+
+    __m128i d0l = _mm_unpacklo_epi8(dm0, _mm_setzero_si128());
+    __m128i d0h = _mm_unpackhi_epi8(dm0, _mm_setzero_si128());
+    __m128i d1l = _mm_unpacklo_epi8(dm1, _mm_setzero_si128());
+    __m128i d1h = _mm_unpackhi_epi8(dm1, _mm_setzero_si128());
+    __m128i d2l = _mm_unpacklo_epi8(dm2, _mm_setzero_si128());
+    __m128i d2h = _mm_unpackhi_epi8(dm2, _mm_setzero_si128());
+    __m128i d3l = _mm_unpacklo_epi8(dm3, _mm_setzero_si128());
+    __m128i d3h = _mm_unpackhi_epi8(dm3, _mm_setzero_si128());
+
+    __m128i sum0 = _mm_add_epi16(d0l, d1l);
+    __m128i sum1 = _mm_add_epi16(d0h, d1h);
+    __m128i sum2 = _mm_add_epi16(d2l, d3l);
+    __m128i sum3 = _mm_add_epi16(d2h, d3h);
+
+    __m128i sum0l = _mm_unpacklo_epi16(sum0, _mm_setzero_si128());
+    __m128i sum0h = _mm_unpackhi_epi16(sum0, _mm_setzero_si128());
+    __m128i sum1l = _mm_unpacklo_epi16(sum1, _mm_setzero_si128());
+    __m128i sum1h = _mm_unpackhi_epi16(sum1, _mm_setzero_si128());
+    __m128i sum2l = _mm_unpacklo_epi16(sum2, _mm_setzero_si128());
+    __m128i sum2h = _mm_unpackhi_epi16(sum2, _mm_setzero_si128());
+    __m128i sum3l = _mm_unpacklo_epi16(sum3, _mm_setzero_si128());
+    __m128i sum3h = _mm_unpackhi_epi16(sum3, _mm_setzero_si128());
+
+    __m128i b0 = _mm_add_epi32(sum0l, sum0h);
+    __m128i b1 = _mm_add_epi32(sum1l, sum1h);
+    __m128i b2 = _mm_add_epi32(sum2l, sum2h);
+    __m128i b3 = _mm_add_epi32(sum3l, sum3h);
+
+    __m128i a0 = _mm_add_epi32(b2, b3);
+    __m128i a1 = _mm_add_epi32(b0, b1);
+    __m128i a2 = _mm_add_epi32(b1, b3);
+    __m128i a3 = _mm_add_epi32(b0, b2);
+
+    _mm_storeu_si128((__m128i*)&err[0], a0);
+    _mm_storeu_si128((__m128i*)&err[1], a1);
+    _mm_storeu_si128((__m128i*)&err[2], a2);
+    _mm_storeu_si128((__m128i*)&err[3], a3);
+#else
+    uint terr[4][4];
+
+    memset(terr, 0, 16 * sizeof(uint));
+
+    for( int j=0; j<4; j++ )
+    {
+        for( int i=0; i<4; i++ )
+        {
+            int index = (j & 2) + (i >> 1);
+            uint d = *data++;
+            terr[index][0] += d;
+            d = *data++;
+            terr[index][1] += d;
+            d = *data++;
+            terr[index][2] += d;
+            data++;
+        }
+    }
+
+    for( int i=0; i<3; i++ )
+    {
+        err[0][i] = terr[2][i] + terr[3][i];
+        err[1][i] = terr[0][i] + terr[1][i];
+        err[2][i] = terr[1][i] + terr[3][i];
+        err[3][i] = terr[0][i] + terr[2][i];
+    }
+    for( int i=0; i<4; i++ )
+    {
+        err[i][3] = 0;
+    }
+#endif
+}
+
+uint CalcError( const uint block[4], const v4i& average )
+{
+    uint err = 0x3FFFFFFF; // Big value to prevent negative values, but small enough to prevent overflow
+    err -= block[0] * 2 * average[2];
+    err -= block[1] * 2 * average[1];
+    err -= block[2] * 2 * average[0];
+    err += 8 * ( sq( average[0] ) + sq( average[1] ) + sq( average[2] ) );
+    return err;
+}
+
+void ProcessAverages( v4i* a )
+{
+#ifdef __SSE4_1__
+    for( int i=0; i<2; i++ )
+    {
+        __m128i d = _mm_loadu_si128((__m128i*)a[i*2].data());
+
+        __m128i t = _mm_add_epi16(_mm_mullo_epi16(d, _mm_set1_epi16(31)), _mm_set1_epi16(128));
+
+        __m128i c = _mm_srli_epi16(_mm_add_epi16(t, _mm_srli_epi16(t, 8)), 8);
+
+        __m128i c1 = _mm_shuffle_epi32(c, _MM_SHUFFLE(3, 2, 3, 2));
+        __m128i diff = _mm_sub_epi16(c, c1);
+        diff = _mm_max_epi16(diff, _mm_set1_epi16(-4));
+        diff = _mm_min_epi16(diff, _mm_set1_epi16(3));
+
+        __m128i co = _mm_add_epi16(c1, diff);
+
+        c = _mm_blend_epi16(co, c, 0xF0);
+
+        __m128i a0 = _mm_or_si128(_mm_slli_epi16(c, 3), _mm_srli_epi16(c, 2));
+
+        _mm_storeu_si128((__m128i*)a[4+i*2].data(), a0);
+    }
+
+    for( int i=0; i<2; i++ )
+    {
+        __m128i d = _mm_loadu_si128((__m128i*)a[i*2].data());
+
+        __m128i t0 = _mm_add_epi16(_mm_mullo_epi16(d, _mm_set1_epi16(15)), _mm_set1_epi16(128));
+        __m128i t1 = _mm_srli_epi16(_mm_add_epi16(t0, _mm_srli_epi16(t0, 8)), 8);
+
+        __m128i t2 = _mm_or_si128(t1, _mm_slli_epi16(t1, 4));
+
+        _mm_storeu_si128((__m128i*)a[i*2].data(), t2);
+    }
+#else
+    for( int i=0; i<2; i++ )
+    {
+        for( int j=0; j<3; j++ )
+        {
+            int32 c1 = mul8bit( a[i*2+1][j], 31 );
+            int32 c2 = mul8bit( a[i*2][j], 31 );
+
+            int32 diff = c2 - c1;
+            if( diff > 3 ) diff = 3;
+            else if( diff < -4 ) diff = -4;
+
+            int32 co = c1 + diff;
+
+            a[5+i*2][j] = ( c1 << 3 ) | ( c1 >> 2 );
+            a[4+i*2][j] = ( co << 3 ) | ( co >> 2 );
+        }
+    }
+
+    for( int i=0; i<4; i++ )
+    {
+        a[i][0] = g_avg2[mul8bit( a[i][0], 15 )];
+        a[i][1] = g_avg2[mul8bit( a[i][1], 15 )];
+        a[i][2] = g_avg2[mul8bit( a[i][2], 15 )];
+    }
+#endif
+}
+
+void EncodeAverages( uint64& _d, const v4i* a, size_t idx )
+{
+    uint64 d = _d;
+    d |= ( idx << 24 );
+    size_t base = idx << 1;
+
+    if( ( idx & 0x2 ) == 0 )
+    {
+        for( int i=0; i<3; i++ )
+        {
+            d |= uint64( a[base+0][i] >> 4 ) << ( i*8 );
+            d |= uint64( a[base+1][i] >> 4 ) << ( i*8 + 4 );
+        }
+    }
+    else
+    {
+        for( int i=0; i<3; i++ )
+        {
+            d |= uint64( a[base+1][i] & 0xF8 ) << ( i*8 );
+            int32 c = ( ( a[base+0][i] & 0xF8 ) - ( a[base+1][i] & 0xF8 ) ) >> 3;
+            c &= ~0xFFFFFFF8;
+            d |= ((uint64)c) << ( i*8 );
+        }
+    }
+    _d = d;
+}
+
+uint64 CheckSolid( const uint8* src )
+{
+#ifdef __SSE4_1__
+    __m128i d0 = _mm_loadu_si128(((__m128i*)src) + 0);
+    __m128i d1 = _mm_loadu_si128(((__m128i*)src) + 1);
+    __m128i d2 = _mm_loadu_si128(((__m128i*)src) + 2);
+    __m128i d3 = _mm_loadu_si128(((__m128i*)src) + 3);
+
+    __m128i c = _mm_shuffle_epi32(d0, _MM_SHUFFLE(0, 0, 0, 0));
+
+    __m128i c0 = _mm_cmpeq_epi8(d0, c);
+    __m128i c1 = _mm_cmpeq_epi8(d1, c);
+    __m128i c2 = _mm_cmpeq_epi8(d2, c);
+    __m128i c3 = _mm_cmpeq_epi8(d3, c);
+
+    __m128i m0 = _mm_and_si128(c0, c1);
+    __m128i m1 = _mm_and_si128(c2, c3);
+    __m128i m = _mm_and_si128(m0, m1);
+
+    if (!_mm_testc_si128(m, _mm_set1_epi32(-1)))
+    {
+        return 0;
+    }
+#else
+    const uint8* ptr = src + 4;
+    for( int i=1; i<16; i++ )
+    {
+        if( memcmp( src, ptr, 4 ) != 0 )
+        {
+            return 0;
+        }
+        ptr += 4;
+    }
+#endif
+    return 0x02000000 |
+        ( uint( src[0] & 0xF8 ) << 16 ) |
+        ( uint( src[1] & 0xF8 ) << 8 ) |
+        ( uint( src[2] & 0xF8 ) );
+}
+
+void PrepareAverages( v4i a[8], const uint8* src, uint err[4] )
+{
+    Average( src, a );
+    ProcessAverages( a );
+
+    uint errblock[4][4];
+    CalcErrorBlock( src, errblock );
+
+    for( int i=0; i<4; i++ )
+    {
+        err[i/2] += CalcError( errblock[i], a[i] );
+        err[2+i/2] += CalcError( errblock[i], a[i+4] );
+    }
+}
+
+void FindBestFit( uint64 terr[2][8], uint16 tsel[16][8], v4i a[8], const uint32* id, const uint8* data )
+{
+    for( size_t i=0; i<16; i++ )
+    {
+        uint16* sel = tsel[i];
+        uint bid = id[i];
+        uint64* ter = terr[bid%2];
+
+        uint8 b = *data++;
+        uint8 g = *data++;
+        uint8 r = *data++;
+        data++;
+
+        int dr = a[bid][0] - r;
+        int dg = a[bid][1] - g;
+        int db = a[bid][2] - b;
+
+#ifdef __SSE4_1__
+        // Reference implementation
+
+        __m128i pix = _mm_set1_epi32(dr * 77 + dg * 151 + db * 28);
+        // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
+        __m128i error0 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[0]));
+        __m128i error1 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[1]));
+        __m128i error2 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[0]));
+        __m128i error3 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[1]));
+
+        __m128i index0 = _mm_and_si128(_mm_cmplt_epi32(error1, error0), _mm_set1_epi32(1));
+        __m128i minError0 = _mm_min_epi32(error0, error1);
+
+        __m128i index1 = _mm_sub_epi32(_mm_set1_epi32(2), _mm_cmplt_epi32(error3, error2));
+        __m128i minError1 = _mm_min_epi32(error2, error3);
+
+        __m128i minIndex0 = _mm_blendv_epi8(index0, index1, _mm_cmplt_epi32(minError1, minError0));
+        __m128i minError = _mm_min_epi32(minError0, minError1);
+
+        // Squaring the minimum error to produce correct values when adding
+        __m128i minErrorLow = _mm_shuffle_epi32(minError, _MM_SHUFFLE(1, 1, 0, 0));
+        __m128i squareErrorLow = _mm_mul_epi32(minErrorLow, minErrorLow);
+        squareErrorLow = _mm_add_epi64(squareErrorLow, _mm_loadu_si128(((__m128i*)ter) + 0));
+        _mm_storeu_si128(((__m128i*)ter) + 0, squareErrorLow);
+        __m128i minErrorHigh = _mm_shuffle_epi32(minError, _MM_SHUFFLE(3, 3, 2, 2));
+        __m128i squareErrorHigh = _mm_mul_epi32(minErrorHigh, minErrorHigh);
+        squareErrorHigh = _mm_add_epi64(squareErrorHigh, _mm_loadu_si128(((__m128i*)ter) + 1));
+        _mm_storeu_si128(((__m128i*)ter) + 1, squareErrorHigh);
+
+        // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
+        error0 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[2]));
+        error1 = _mm_abs_epi32(_mm_add_epi32(pix, g_table256_SIMD[3]));
+        error2 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[2]));
+        error3 = _mm_abs_epi32(_mm_sub_epi32(pix, g_table256_SIMD[3]));
+
+        index0 = _mm_and_si128(_mm_cmplt_epi32(error1, error0), _mm_set1_epi32(1));
+        minError0 = _mm_min_epi32(error0, error1);
+
+        index1 = _mm_sub_epi32(_mm_set1_epi32(2), _mm_cmplt_epi32(error3, error2));
+        minError1 = _mm_min_epi32(error2, error3);
+
+        __m128i minIndex1 = _mm_blendv_epi8(index0, index1, _mm_cmplt_epi32(minError1, minError0));
+        minError = _mm_min_epi32(minError0, minError1);
+
+        // Squaring the minimum error to produce correct values when adding
+        minErrorLow = _mm_shuffle_epi32(minError, _MM_SHUFFLE(1, 1, 0, 0));
+        squareErrorLow = _mm_mul_epi32(minErrorLow, minErrorLow);
+        squareErrorLow = _mm_add_epi64(squareErrorLow, _mm_loadu_si128(((__m128i*)ter) + 2));
+        _mm_storeu_si128(((__m128i*)ter) + 2, squareErrorLow);
+        minErrorHigh = _mm_shuffle_epi32(minError, _MM_SHUFFLE(3, 3, 2, 2));
+        squareErrorHigh = _mm_mul_epi32(minErrorHigh, minErrorHigh);
+        squareErrorHigh = _mm_add_epi64(squareErrorHigh, _mm_loadu_si128(((__m128i*)ter) + 3));
+        _mm_storeu_si128(((__m128i*)ter) + 3, squareErrorHigh);
+        __m128i minIndex = _mm_packs_epi32(minIndex0, minIndex1);
+        _mm_storeu_si128((__m128i*)sel, minIndex);
+#else
+        int pix = dr * 77 + dg * 151 + db * 28;
+
+        for( int t=0; t<8; t++ )
+        {
+            const int64* tab = g_table256[t];
+            uint idx = 0;
+            uint64 err = sq( tab[0] + pix );
+            for( int j=1; j<4; j++ )
+            {
+                uint64 local = sq( tab[j] + pix );
+                if( local < err )
+                {
+                    err = local;
+                    idx = j;
+                }
+            }
+            *sel++ = idx;
+            *ter++ += err;
+        }
+#endif
+    }
+}
+
+#ifdef __SSE4_1__
+// Non-reference implementation, but faster. Produces same results as the AVX2 version
+void FindBestFit( uint32 terr[2][8], uint16 tsel[16][8], v4i a[8], const uint32* id, const uint8* data )
+{
+    for( size_t i=0; i<16; i++ )
+    {
+        uint16* sel = tsel[i];
+        uint bid = id[i];
+        uint32* ter = terr[bid%2];
+
+        uint8 b = *data++;
+        uint8 g = *data++;
+        uint8 r = *data++;
+        data++;
+
+        int dr = a[bid][0] - r;
+        int dg = a[bid][1] - g;
+        int db = a[bid][2] - b;
+
+        // The scaling values are divided by two and rounded, to allow the differences to be in the range of signed int16
+        // This produces slightly different results, but is significant faster
+        __m128i pixel = _mm_set1_epi16(dr * 38 + dg * 76 + db * 14);
+        __m128i pix = _mm_abs_epi16(pixel);
+
+        // Taking the absolute value is way faster. The values are only used to sort, so the result will be the same.
+        // Since the selector table is symmetrical, we need to calculate the difference only for half of the entries.
+        __m128i error0 = _mm_abs_epi16(_mm_sub_epi16(pix, g_table128_SIMD[0]));
+        __m128i error1 = _mm_abs_epi16(_mm_sub_epi16(pix, g_table128_SIMD[1]));
+
+        __m128i index = _mm_and_si128(_mm_cmplt_epi16(error1, error0), _mm_set1_epi16(1));
+        __m128i minError = _mm_min_epi16(error0, error1);
+
+        // Exploiting symmetry of the selector table and use the sign bit
+        // This produces slightly different results, but is needed to produce same results as AVX2 implementation
+        __m128i indexBit = _mm_andnot_si128(_mm_srli_epi16(pixel, 15), _mm_set1_epi8(-1));
+        __m128i minIndex = _mm_or_si128(index, _mm_add_epi16(indexBit, indexBit));
+
+        // Squaring the minimum error to produce correct values when adding
+        __m128i squareErrorLo = _mm_mullo_epi16(minError, minError);
+        __m128i squareErrorHi = _mm_mulhi_epi16(minError, minError);
+
+        __m128i squareErrorLow = _mm_unpacklo_epi16(squareErrorLo, squareErrorHi);
+        __m128i squareErrorHigh = _mm_unpackhi_epi16(squareErrorLo, squareErrorHi);
+
+        squareErrorLow = _mm_add_epi32(squareErrorLow, _mm_loadu_si128(((__m128i*)ter) + 0));
+        _mm_storeu_si128(((__m128i*)ter) + 0, squareErrorLow);
+        squareErrorHigh = _mm_add_epi32(squareErrorHigh, _mm_loadu_si128(((__m128i*)ter) + 1));
+        _mm_storeu_si128(((__m128i*)ter) + 1, squareErrorHigh);
+
+        _mm_storeu_si128((__m128i*)sel, minIndex);
+    }
+}
+#endif
+
+uint8_t convert6(float f)
+{
+    int i = (std::min(std::max(static_cast<int>(f), 0), 1023) - 15) >> 1;
+    return (i + 11 - ((i + 11) >> 7) - ((i + 4) >> 7)) >> 3;
+}
+
+uint8_t convert7(float f)
+{
+    int i = (std::min(std::max(static_cast<int>(f), 0), 1023) - 15) >> 1;
+    return (i + 9 - ((i + 9) >> 8) - ((i + 6) >> 8)) >> 2;
+}
+
+std::pair<uint64, uint64> Planar(const uint8* src)
+{
+    int32 r = 0;
+    int32 g = 0;
+    int32 b = 0;
+
+    for (int i = 0; i < 16; ++i)
+    {
+        b += src[i * 4 + 0];
+        g += src[i * 4 + 1];
+        r += src[i * 4 + 2];
+    }
+
+    int32 difRyz = 0;
+    int32 difGyz = 0;
+    int32 difByz = 0;
+    int32 difRxz = 0;
+    int32 difGxz = 0;
+    int32 difBxz = 0;
+
+    const int32 scaling[] = { -255, -85, 85, 255 };
+
+    for (int i = 0; i < 16; ++i)
+    {
+        int32 difB = (static_cast<int>(src[i * 4 + 0]) << 4) - b;
+        int32 difG = (static_cast<int>(src[i * 4 + 1]) << 4) - g;
+        int32 difR = (static_cast<int>(src[i * 4 + 2]) << 4) - r;
+
+        difRyz += difR * scaling[i % 4];
+        difGyz += difG * scaling[i % 4];
+        difByz += difB * scaling[i % 4];
+
+        difRxz += difR * scaling[i / 4];
+        difGxz += difG * scaling[i / 4];
+        difBxz += difB * scaling[i / 4];
+    }
+
+    const float scale = -4.0f / ((255 * 255 * 8.0f + 85 * 85 * 8.0f) * 16.0f);
+
+    float aR = difRxz * scale;
+    float aG = difGxz * scale;
+    float aB = difBxz * scale;
+
+    float bR = difRyz * scale;
+    float bG = difGyz * scale;
+    float bB = difByz * scale;
+
+    float dR = r * (4.0f / 16.0f);
+    float dG = g * (4.0f / 16.0f);
+    float dB = b * (4.0f / 16.0f);
+
+    // calculating the three colors RGBO, RGBH, and RGBV.  RGB = df - af * x - bf * y;
+    float cofR = (aR *  255.0f + (bR *  255.0f + dR));
+    float cofG = (aG *  255.0f + (bG *  255.0f + dG));
+    float cofB = (aB *  255.0f + (bB *  255.0f + dB));
+    float chfR = (aR * -425.0f + (bR *  255.0f + dR));
+    float chfG = (aG * -425.0f + (bG *  255.0f + dG));
+    float chfB = (aB * -425.0f + (bB *  255.0f + dB));
+    float cvfR = (aR *  255.0f + (bR * -425.0f + dR));
+    float cvfG = (aG *  255.0f + (bG * -425.0f + dG));
+    float cvfB = (aB *  255.0f + (bB * -425.0f + dB));
+
+    // convert to r6g7b6
+    int32 coR = convert6(cofR);
+    int32 coG = convert7(cofG);
+    int32 coB = convert6(cofB);
+    int32 chR = convert6(chfR);
+    int32 chG = convert7(chfG);
+    int32 chB = convert6(chfB);
+    int32 cvR = convert6(cvfR);
+    int32 cvG = convert7(cvfG);
+    int32 cvB = convert6(cvfB);
+
+    // Error calculation
+    int32 ro0 = coR;
+    int32 go0 = coG;
+    int32 bo0 = coB;
+    int32 ro1 = (ro0 >> 4) | (ro0 << 2);
+    int32 go1 = (go0 >> 6) | (go0 << 1);
+    int32 bo1 = (bo0 >> 4) | (bo0 << 2);
+    int32 ro2 = (ro1 << 2) + 2;
+    int32 go2 = (go1 << 2) + 2;
+    int32 bo2 = (bo1 << 2) + 2;
+
+    int32 rh0 = chR;
+    int32 gh0 = chG;
+    int32 bh0 = chB;
+    int32 rh1 = (rh0 >> 4) | (rh0 << 2);
+    int32 gh1 = (gh0 >> 6) | (gh0 << 1);
+    int32 bh1 = (bh0 >> 4) | (bh0 << 2);
+
+    int32 rh2 = rh1 - ro1;
+    int32 gh2 = gh1 - go1;
+    int32 bh2 = bh1 - bo1;
+
+    int32 rv0 = cvR;
+    int32 gv0 = cvG;
+    int32 bv0 = cvB;
+    int32 rv1 = (rv0 >> 4) | (rv0 << 2);
+    int32 gv1 = (gv0 >> 6) | (gv0 << 1);
+    int32 bv1 = (bv0 >> 4) | (bv0 << 2);
+
+    int32 rv2 = rv1 - ro1;
+    int32 gv2 = gv1 - go1;
+    int32 bv2 = bv1 - bo1;
+
+    uint64 error = 0;
+
+    for (int i = 0; i < 16; ++i)
+    {
+        int32 cR = clampu8((rh2 * (i / 4) + rv2 * (i % 4) + ro2) >> 2);
+        int32 cG = clampu8((gh2 * (i / 4) + gv2 * (i % 4) + go2) >> 2);
+        int32 cB = clampu8((bh2 * (i / 4) + bv2 * (i % 4) + bo2) >> 2);
+
+        int32 difB = static_cast<int>(src[i * 4 + 0]) - cB;
+        int32 difG = static_cast<int>(src[i * 4 + 1]) - cG;
+        int32 difR = static_cast<int>(src[i * 4 + 2]) - cR;
+
+        int32 dif = difR * 38 + difG * 76 + difB * 14;
+
+        error += dif * dif;
+    }
+
+    /**/
+    uint32 rgbv = cvB | (cvG << 6) | (cvR << 13);
+    uint32 rgbh = chB | (chG << 6) | (chR << 13);
+    uint32 hi = rgbv | ((rgbh & 0x1FFF) << 19);
+    uint32 lo = (chR & 0x1) | 0x2 | ((chR << 1) & 0x7C);
+    lo |= ((coB & 0x07) <<  7) | ((coB & 0x18) <<  8) | ((coB & 0x20) << 11);
+    lo |= ((coG & 0x3F) << 17) | ((coG & 0x40) << 18);
+    lo |= coR << 25;
+
+    const int32 idx = (coR & 0x20) | ((coG & 0x20) >> 1) | ((coB & 0x1E) >> 1);
+
+    lo |= g_flags[idx];
+
+    uint64 result = static_cast<uint32>(bx::endianSwap(lo));
+    result |= static_cast<uint64>(static_cast<uint32>(bx::endianSwap(hi))) << 32;
+
+    return std::make_pair(result, error);
+}
+
+template<class T, class S>
+uint64 EncodeSelectors( uint64 d, const T terr[2][8], const S tsel[16][8], const uint32* id, const uint64 value, const uint64 error)
+{
+    size_t tidx[2];
+    tidx[0] = GetLeastError( terr[0], 8 );
+    tidx[1] = GetLeastError( terr[1], 8 );
+
+    if ((terr[0][tidx[0]] + terr[1][tidx[1]]) >= error)
+    {
+        return value;
+    }
+
+    d |= tidx[0] << 26;
+    d |= tidx[1] << 29;
+    for( int i=0; i<16; i++ )
+    {
+        uint64 t = tsel[i][tidx[id[i]%2]];
+        d |= ( t & 0x1 ) << ( i + 32 );
+        d |= ( t & 0x2 ) << ( i + 47 );
+    }
+
+    return FixByteOrder(d);
+}
+}
+
+uint64 ProcessRGB( const uint8* src )
+{
+    uint64 d = CheckSolid( src );
+    if( d != 0 ) return d;
+
+    v4i a[8];
+    uint err[4] = {};
+    PrepareAverages( a, src, err );
+    size_t idx = GetLeastError( err, 4 );
+    EncodeAverages( d, a, idx );
+
+#if defined __SSE4_1__ && !defined REFERENCE_IMPLEMENTATION
+    uint32 terr[2][8] = {};
+#else
+    uint64 terr[2][8] = {};
+#endif
+    uint16 tsel[16][8];
+    const uint32* id = g_id[idx];
+    FindBestFit( terr, tsel, a, id, src );
+
+    return FixByteOrder( EncodeSelectors( d, terr, tsel, id ) );
+}
+
+uint64 ProcessRGB_ETC2( const uint8* src )
+{
+    std::pair<uint64, uint64> result = Planar( src );
+
+    uint64 d = 0;
+
+    v4i a[8];
+    uint err[4] = {};
+    PrepareAverages( a, src, err );
+    size_t idx = GetLeastError( err, 4 );
+    EncodeAverages( d, a, idx );
+
+    uint64 terr[2][8] = {};
+    uint16 tsel[16][8];
+    const uint32* id = g_id[idx];
+    FindBestFit( terr, tsel, a, id, src );
+
+    return EncodeSelectors( d, terr, tsel, id, result.first, result.second );
+}

3rdparty/bgfx/3rdparty/etc2/ProcessRGB.hpp

@@ -0,0 +1,9 @@
+#ifndef __PROCESSRGB_HPP__
+#define __PROCESSRGB_HPP__
+
+#include "Types.hpp"
+
+uint64 ProcessRGB( const uint8* src );
+uint64 ProcessRGB_ETC2( const uint8* src );
+
+#endif

3rdparty/bgfx/3rdparty/etc2/Tables.cpp

@@ -0,0 +1,109 @@
+#include "Tables.hpp"
+
+const int32 g_table[8][4] = {
+    {  2,  8,   -2,   -8 },
+    {  5, 17,   -5,  -17 },
+    {  9, 29,   -9,  -29 },
+    { 13, 42,  -13,  -42 },
+    { 18, 60,  -18,  -60 },
+    { 24, 80,  -24,  -80 },
+    { 33, 106, -33, -106 },
+    { 47, 183, -47, -183 }
+};
+
+const int64 g_table256[8][4] = {
+    {  2*256,  8*256,   -2*256,   -8*256 },
+    {  5*256, 17*256,   -5*256,  -17*256 },
+    {  9*256, 29*256,   -9*256,  -29*256 },
+    { 13*256, 42*256,  -13*256,  -42*256 },
+    { 18*256, 60*256,  -18*256,  -60*256 },
+    { 24*256, 80*256,  -24*256,  -80*256 },
+    { 33*256, 106*256, -33*256, -106*256 },
+    { 47*256, 183*256, -47*256, -183*256 }
+};
+
+const uint32 g_id[4][16] = {
+    { 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2 },
+    { 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4 },
+    { 7, 7, 6, 6, 7, 7, 6, 6, 7, 7, 6, 6, 7, 7, 6, 6 }
+};
+
+const uint32 g_avg2[16] = {
+    0x00,
+    0x11,
+    0x22,
+    0x33,
+    0x44,
+    0x55,
+    0x66,
+    0x77,
+    0x88,
+    0x99,
+    0xAA,
+    0xBB,
+    0xCC,
+    0xDD,
+    0xEE,
+    0xFF
+};
+
+const uint32 g_flags[64] = {
+    0x80800402, 0x80800402, 0x80800402, 0x80800402,
+    0x80800402, 0x80800402, 0x80800402, 0x8080E002,
+    0x80800402, 0x80800402, 0x8080E002, 0x8080E002,
+    0x80800402, 0x8080E002, 0x8080E002, 0x8080E002,
+    0x80000402, 0x80000402, 0x80000402, 0x80000402,
+    0x80000402, 0x80000402, 0x80000402, 0x8000E002,
+    0x80000402, 0x80000402, 0x8000E002, 0x8000E002,
+    0x80000402, 0x8000E002, 0x8000E002, 0x8000E002,
+    0x00800402, 0x00800402, 0x00800402, 0x00800402,
+    0x00800402, 0x00800402, 0x00800402, 0x0080E002,
+    0x00800402, 0x00800402, 0x0080E002, 0x0080E002,
+    0x00800402, 0x0080E002, 0x0080E002, 0x0080E002,
+    0x00000402, 0x00000402, 0x00000402, 0x00000402,
+    0x00000402, 0x00000402, 0x00000402, 0x0000E002,
+    0x00000402, 0x00000402, 0x0000E002, 0x0000E002,
+    0x00000402, 0x0000E002, 0x0000E002, 0x0000E002
+};
+
+#ifdef __SSE4_1__
+const uint8 g_flags_AVX2[64] =
+{
+    0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x7D,
+    0x63, 0x63, 0x7D, 0x7D,
+    0x63, 0x7D, 0x7D, 0x7D,
+    0x43, 0x43, 0x43, 0x43,
+    0x43, 0x43, 0x43, 0x5D,
+    0x43, 0x43, 0x5D, 0x5D,
+    0x43, 0x5D, 0x5D, 0x5D,
+    0x23, 0x23, 0x23, 0x23,
+    0x23, 0x23, 0x23, 0x3D,
+    0x23, 0x23, 0x3D, 0x3D,
+    0x23, 0x3D, 0x3D, 0x3D,
+    0x03, 0x03, 0x03, 0x03,
+    0x03, 0x03, 0x03, 0x1D,
+    0x03, 0x03, 0x1D, 0x1D,
+    0x03, 0x1D, 0x1D, 0x1D,
+};
+
+const __m128i g_table_SIMD[2] =
+{
+    _mm_setr_epi16(   2,   5,   9,  13,  18,  24,  33,  47),
+    _mm_setr_epi16(   8,  17,  29,  42,  60,  80, 106, 183)
+};
+const __m128i g_table128_SIMD[2] =
+{
+    _mm_setr_epi16(   2*128,   5*128,   9*128,  13*128,  18*128,  24*128,  33*128,  47*128),
+    _mm_setr_epi16(   8*128,  17*128,  29*128,  42*128,  60*128,  80*128, 106*128, 183*128)
+};
+const __m128i g_table256_SIMD[4] =
+{
+    _mm_setr_epi32(  2*256,   5*256,   9*256,  13*256),
+    _mm_setr_epi32(  8*256,  17*256,  29*256,  42*256),
+    _mm_setr_epi32( 18*256,  24*256,  33*256,  47*256),
+    _mm_setr_epi32( 60*256,  80*256, 106*256, 183*256)
+};
+#endif
+

3rdparty/bgfx/3rdparty/etc2/Tables.hpp

@@ -0,0 +1,25 @@
+#ifndef __TABLES_HPP__
+#define __TABLES_HPP__
+
+#include "Types.hpp"
+#ifdef __SSE4_1__
+#include <smmintrin.h>
+#endif
+
+extern const int32 g_table[8][4];
+extern const int64 g_table256[8][4];
+
+extern const uint32 g_id[4][16];
+
+extern const uint32 g_avg2[16];
+
+extern const uint32 g_flags[64];
+
+#ifdef __SSE4_1__
+extern const uint8 g_flags_AVX2[64];
+extern const __m128i g_table_SIMD[2];
+extern const __m128i g_table128_SIMD[2];
+extern const __m128i g_table256_SIMD[4];
+#endif
+
+#endif

3rdparty/bgfx/3rdparty/etc2/Types.hpp

@@ -0,0 +1,17 @@
+#ifndef __DARKRL__TYPES_HPP__
+#define __DARKRL__TYPES_HPP__
+
+#include <stdint.h>
+
+typedef int8_t      int8;
+typedef uint8_t     uint8;
+typedef int16_t     int16;
+typedef uint16_t    uint16;
+typedef int32_t     int32;
+typedef uint32_t    uint32;
+typedef int64_t     int64;
+typedef uint64_t    uint64;
+
+typedef unsigned int uint;
+
+#endif

3rdparty/bgfx/3rdparty/etc2/Vector.hpp

@@ -0,0 +1,222 @@
+#ifndef __DARKRL__VECTOR_HPP__
+#define __DARKRL__VECTOR_HPP__
+
+#include <assert.h>
+#include <algorithm>
+#include <math.h>
+
+#include "Math.hpp"
+#include "Types.hpp"
+
+template<class T>
+struct Vector2
+{
+    Vector2() : x( 0 ), y( 0 ) {}
+    Vector2( T v ) : x( v ), y( v ) {}
+    Vector2( T _x, T _y ) : x( _x ), y( _y ) {}
+
+    bool operator==( const Vector2<T>& rhs ) const { return x == rhs.x && y == rhs.y; }
+    bool operator!=( const Vector2<T>& rhs ) const { return !( *this == rhs ); }
+
+    Vector2<T>& operator+=( const Vector2<T>& rhs )
+    {
+        x += rhs.x;
+        y += rhs.y;
+        return *this;
+    }
+    Vector2<T>& operator-=( const Vector2<T>& rhs )
+    {
+        x -= rhs.x;
+        y -= rhs.y;
+        return *this;
+    }
+    Vector2<T>& operator*=( const Vector2<T>& rhs )
+    {
+        x *= rhs.x;
+        y *= rhs.y;
+        return *this;
+    }
+
+    T x, y;
+};
+
+template<class T>
+Vector2<T> operator+( const Vector2<T>& lhs, const Vector2<T>& rhs )
+{
+    return Vector2<T>( lhs.x + rhs.x, lhs.y + rhs.y );
+}
+
+template<class T>
+Vector2<T> operator-( const Vector2<T>& lhs, const Vector2<T>& rhs )
+{
+    return Vector2<T>( lhs.x - rhs.x, lhs.y - rhs.y );
+}
+
+template<class T>
+Vector2<T> operator*( const Vector2<T>& lhs, const float& rhs )
+{
+    return Vector2<T>( lhs.x * rhs, lhs.y * rhs );
+}
+
+template<class T>
+Vector2<T> operator/( const Vector2<T>& lhs, const T& rhs )
+{
+    return Vector2<T>( lhs.x / rhs, lhs.y / rhs );
+}
+
+
+typedef Vector2<int32> v2i;
+typedef Vector2<float> v2f;
+
+
+template<class T>
+struct Vector3
+{
+    Vector3() : x( 0 ), y( 0 ), z( 0 ) {}
+    Vector3( T v ) : x( v ), y( v ), z( v ) {}
+    Vector3( T _x, T _y, T _z ) : x( _x ), y( _y ), z( _z ) {}
+    template<class Y>
+    Vector3( const Vector3<Y>& v ) : x( T( v.x ) ), y( T( v.y ) ), z( T( v.z ) ) {}
+
+    T Luminance() const { return T( x * 0.3f + y * 0.59f + z * 0.11f ); }
+    void Clamp()
+    {
+        x = std::min( T(1), std::max( T(0), x ) );
+        y = std::min( T(1), std::max( T(0), y ) );
+        z = std::min( T(1), std::max( T(0), z ) );
+    }
+
+    bool operator==( const Vector3<T>& rhs ) const { return x == rhs.x && y == rhs.y && z == rhs.z; }
+    bool operator!=( const Vector2<T>& rhs ) const { return !( *this == rhs ); }
+
+    T& operator[]( uint idx ) { assert( idx < 3 ); return ((T*)this)[idx]; }
+    const T& operator[]( uint idx ) const { assert( idx < 3 ); return ((T*)this)[idx]; }
+
+    Vector3<T> operator+=( const Vector3<T>& rhs )
+    {
+        x += rhs.x;
+        y += rhs.y;
+        z += rhs.z;
+        return *this;
+    }
+
+    Vector3<T> operator*=( const Vector3<T>& rhs )
+    {
+        x *= rhs.x;
+        y *= rhs.y;
+        z *= rhs.z;
+        return *this;
+    }
+
+    Vector3<T> operator*=( const float& rhs )
+    {
+        x *= rhs;
+        y *= rhs;
+        z *= rhs;
+        return *this;
+    }
+
+    T x, y, z;
+    T padding;
+};
+
+template<class T>
+Vector3<T> operator+( const Vector3<T>& lhs, const Vector3<T>& rhs )
+{
+    return Vector3<T>( lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z );
+}
+
+template<class T>
+Vector3<T> operator-( const Vector3<T>& lhs, const Vector3<T>& rhs )
+{
+    return Vector3<T>( lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z );
+}
+
+template<class T>
+Vector3<T> operator*( const Vector3<T>& lhs, const Vector3<T>& rhs )
+{
+    return Vector3<T>( lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z );
+}
+
+template<class T>
+Vector3<T> operator*( const Vector3<T>& lhs, const float& rhs )
+{
+    return Vector3<T>( T( lhs.x * rhs ), T( lhs.y * rhs ), T( lhs.z * rhs ) );
+}
+
+template<class T>
+Vector3<T> operator/( const Vector3<T>& lhs, const T& rhs )
+{
+    return Vector3<T>( lhs.x / rhs, lhs.y / rhs, lhs.z / rhs );
+}
+
+template<class T>
+bool operator<( const Vector3<T>& lhs, const Vector3<T>& rhs )
+{
+    return lhs.Luminance() < rhs.Luminance();
+}
+
+typedef Vector3<int32> v3i;
+typedef Vector3<float> v3f;
+typedef Vector3<uint8> v3b;
+
+
+static inline v3b v3f_to_v3b( const v3f& v )
+{
+    return v3b( uint8( std::min( 1.f, v.x ) * 255 ), uint8( std::min( 1.f, v.y ) * 255 ), uint8( std::min( 1.f, v.z ) * 255 ) );
+}
+
+template<class T>
+Vector3<T> Mix( const Vector3<T>& v1, const Vector3<T>& v2, float amount )
+{
+    return v1 + ( v2 - v1 ) * amount;
+}
+
+template<>
+inline v3b Mix( const v3b& v1, const v3b& v2, float amount )
+{
+    return v3b( v3f( v1 ) + ( v3f( v2 ) - v3f( v1 ) ) * amount );
+}
+
+template<class T>
+Vector3<T> Desaturate( const Vector3<T>& v )
+{
+    T l = v.Luminance();
+    return Vector3<T>( l, l, l );
+}
+
+template<class T>
+Vector3<T> Desaturate( const Vector3<T>& v, float mul )
+{
+    T l = T( v.Luminance() * mul );
+    return Vector3<T>( l, l, l );
+}
+
+template<class T>
+Vector3<T> pow( const Vector3<T>& base, float exponent )
+{
+    return Vector3<T>(
+        pow( base.x, exponent ),
+        pow( base.y, exponent ),
+        pow( base.z, exponent ) );
+}
+
+template<class T>
+Vector3<T> sRGB2linear( const Vector3<T>& v )
+{
+    return Vector3<T>(
+        sRGB2linear( v.x ),
+        sRGB2linear( v.y ),
+        sRGB2linear( v.z ) );
+}
+
+template<class T>
+Vector3<T> linear2sRGB( const Vector3<T>& v )
+{
+    return Vector3<T>(
+        linear2sRGB( v.x ),
+        linear2sRGB( v.y ),
+        linear2sRGB( v.z ) );
+}
+
+#endif

3rdparty/bgfx/3rdparty/fcpp/.gitignore

@@ -0,0 +1,3 @@
+fcpp
+*.o
+*~

3rdparty/bgfx/3rdparty/fcpp/COPYING

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 1993-2011 Daniel Stenberg
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms,
+ * with or without modification, are permitted provided
+ * that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above
+ *   copyright notice, this list of conditions and the
+ *   following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials
+ *   provided with the distribution.
+ *
+ *   Neither the name of the copyright holder nor the names
+ *   of any other contributors may be used to endorse or
+ *   promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ */
+

3rdparty/bgfx/3rdparty/fcpp/FPPBase.h

@@ -0,0 +1,56 @@
+/******************************************************************************
+ *                               FREXXWARE
+ * ----------------------------------------------------------------------------
+ *
+ * Project: Frexx C Preprocessor
+ * $Source: /home/user/start/cpp/RCS/FPPBase.h,v $
+ * $Revision: 1.3 $
+ * $Date: 1993/12/06 13:51:20 $
+ * $Author: start $
+ * $State: Exp $
+ * $Locker: start $
+ *
+ * ----------------------------------------------------------------------------
+ * $Log: FPPBase.h,v $
+ * Revision 1.3  1993/12/06  13:51:20  start
+ * A lot of new stuff (too much to mention)
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.1  1993/11/03  09:15:59  start
+ * Initial revision
+ *
+ *
+ *****************************************************************************/
+#ifndef FPP_BASE_H
+#define FPP_BASE_H
+
+/*
+**   $Filename: libraries/FPPbase.h $
+**   $Release: 1.0 $
+**   $Date: 1993/12/06 13:51:20 $
+**
+**   (C) Copyright 1992, 1993 by FrexxWare
+**       All Rights Reserved
+*/
+
+#include <exec/types.h>
+#include <exec/libraries.h>
+
+struct FPPBase {
+  struct Library LibNode;
+  UBYTE Flags;
+  UBYTE pad;
+  /* long word aligned */
+  ULONG SysLib;
+  ULONG DosLib;
+  ULONG SegList;
+};
+
+#define FPPNAME "fpp.library"
+
+#endif

3rdparty/bgfx/3rdparty/fcpp/FPP_protos.h

@@ -0,0 +1,35 @@
+/******************************************************************************
+ *                               FREXXWARE
+ * ----------------------------------------------------------------------------
+ *
+ * Project: Frexx C Preprocessor
+ * $Source: /home/user/start/cpp/RCS/FPP_protos.h,v $
+ * $Revision: 1.3 $
+ * $Date: 1993/12/06 13:51:20 $
+ * $Author: start $
+ * $State: Exp $
+ * $Locker: start $
+ *
+ * ----------------------------------------------------------------------------
+ * $Log: FPP_protos.h,v $
+ * Revision 1.3  1993/12/06  13:51:20  start
+ * A lot of new stuff (too much to mention)
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.1  1993/11/03  09:15:59  start
+ * Initial revision
+ *
+ *
+ *****************************************************************************/
+/******************************************************
+ *
+ * FPP_protos.h
+ *
+ *******/
+
+int fppPreProcess(struct fppTag *);

3rdparty/bgfx/3rdparty/fcpp/README

@@ -0,0 +1,13 @@
+Frexx CPP (C Preprocessor)
+
+Copyright (c) by Daniel Stenberg 1993 - 2011
+
+This is a C preprocessor. It is a project based on public domain code, then
+forked by Daniel in 1993 and future work has been done under a BSD license.
+
+The C preprocessor is now (mostly?) ANSI C compliant, and some tweaks have
+been applied to also make it fairly usable to process other data files, such
+as HTML for simple web sites.
+
+WWW:   http://daniel.haxx.se/projects/fcpp/
+Code:  https://github.com/bagder/fcpp

3rdparty/bgfx/3rdparty/fcpp/cpp.h

@@ -0,0 +1,249 @@
+/******************************************************************************
+ *                               FREXXWARE
+ * ----------------------------------------------------------------------------
+ *
+ * Project: Frexx C Preprocessor
+ * $Source: /home/user/start/cpp/RCS/cpp.h,v $
+ * $Revision: 1.3 $
+ * $Date: 1993/12/06 13:51:20 $
+ * $Author: start $
+ * $State: Exp $
+ * $Locker: start $
+ *
+ * ----------------------------------------------------------------------------
+ * $Log: cpp.h,v $
+ * Revision 1.3  1993/12/06  13:51:20  start
+ * A lot of new stuff (too much to mention)
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.1  1993/11/03  09:15:59  start
+ * Initial revision
+ *
+ *
+ *****************************************************************************/
+
+/*
+ *	I n t e r n a l   D e f i n i t i o n s    f o r   C P P
+ *
+ * In general, definitions in this file should not be changed.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#ifndef toupper
+#define toupper(c) ((c) + ('A' - 'a'))
+#endif /* no toupper */
+#ifndef tolower
+#define tolower(c) ((c) + ('a' - 'A'))
+#endif /* no tolower */
+
+#ifndef TRUE
+#define TRUE		1
+#define FALSE		0
+#endif
+#ifndef EOS
+/*
+ * This is predefined in Decus C
+ */
+#define EOS		'\0'            /* End of string                */
+#endif
+#define EOF_CHAR	0		/* Returned by get() on eof     */
+#define NULLST		((char *) NULL) /* Pointer to nowhere (linted)  */
+#define DEF_NOARGS	(-1)            /* #define foo vs #define foo() */
+
+/*
+ * The following may need to change if the host system doesn't use ASCII.
+ */
+#define QUOTE_PARM	0x1C		/* Magic quoting operator	*/
+#define DEF_MAGIC	0x1D		/* Magic for #defines		*/
+#define TOK_SEP 	0x1E		/* Token concatenation delim.	*/
+#define COM_SEP 	0x1F		/* Magic comment separator	*/
+
+/*
+ * Note -- in Ascii, the following will map macro formals onto DEL + the
+ * C1 control character region (decimal 128 .. (128 + PAR_MAC)) which will
+ * be ok as long as PAR_MAC is less than 33).  Note that the last PAR_MAC
+ * value is reserved for string substitution.
+ */
+
+#define MAC_PARM	0x7F		/* Macro formals start here	*/
+#ifndef OS9
+#if (PAR_MAC >= 33)
+#error	"assertion fails -- PAR_MAC isn't less than 33"
+
+#endif
+#endif
+#define LASTPARM	(PAR_MAC - 1)
+
+/*
+ * Character type codes.
+ */
+
+#define INV		0		/* Invalid, must be zero	*/
+#define OP_EOE		INV		/* End of expression		*/
+#define DIG		1		/* Digit			*/
+#define LET		2		/* Identifier start		*/
+#define FIRST_BINOP	OP_ADD
+#define OP_ADD		3
+#define OP_SUB		4
+#define OP_MUL		5
+#define OP_DIV		6
+#define OP_MOD		7
+#define OP_ASL		8
+#define OP_ASR		9
+#define OP_AND		10		/* &, not &&			*/
+#define OP_OR		11		/* |, not ||			*/
+#define OP_XOR		12
+#define OP_EQ		13
+#define OP_NE		14
+#define OP_LT		15
+#define OP_LE		16
+#define OP_GE		17
+#define OP_GT		18
+#define OP_ANA		19		/* &&				*/
+#define OP_ORO		20		/* ||				*/
+#define OP_QUE		21		/* ?				*/
+#define OP_COL		22		/* :				*/
+#define OP_CMA		23		/* , (relevant?)                */
+#define LAST_BINOP	OP_CMA		/* Last binary operand		*/
+/*
+ * The following are unary.
+ */
+#define FIRST_UNOP	OP_PLU		/* First Unary operand		*/
+#define OP_PLU		24		/* + (draft ANSI standard)      */
+#define OP_NEG		25		/* -				*/
+#define OP_COM		26		/* ~				*/
+#define OP_NOT		27		/* !				*/
+#define LAST_UNOP	OP_NOT
+#define OP_LPA		28		/* (                            */
+#define OP_RPA		29		/* )				*/
+#define OP_END		30		/* End of expression marker	*/
+#define OP_MAX		(OP_END + 1)    /* Number of operators          */
+#define OP_FAIL 	(OP_END + 1)    /* For error returns            */
+
+/*
+ * The following are for lexical scanning only.
+ */
+
+#define QUO		65		/* Both flavors of quotation	*/
+#define DOT		66		/* . might start a number	*/
+#define SPA		67		/* Space and tab		*/
+#define BSH		68		/* Just a backslash		*/
+#define END		69		/* EOF				*/
+
+/*
+ * These bits are set in ifstack[]
+ */
+#define WAS_COMPILING	1		/* TRUE if compile set at entry */
+#define ELSE_SEEN	2		/* TRUE when #else processed	*/
+#define TRUE_SEEN	4		/* TRUE when #if TRUE processed */
+
+/*
+ * Define bits for the basic types and their adjectives
+ */
+
+#define T_CHAR		  1
+#define T_INT		  2
+#define T_FLOAT 	  4
+#define T_DOUBLE	  8
+#define T_SHORT 	 16
+#define T_LONG		 32
+#define T_SIGNED	 64
+#define T_UNSIGNED	128
+#define T_PTR		256		/* Pointer			*/
+#define T_FPTR		512		/* Pointer to functions 	*/
+
+/*
+ * The DEFBUF structure stores information about #defined
+ * macros.  Note that the defbuf->repl information is always
+ * in malloc storage.
+ */
+
+typedef struct defbuf {
+	struct defbuf	*link;		/* Next define in chain */
+	char		*repl;		/* -> replacement	*/
+	int		hash;		/* Symbol table hash	*/
+	int		nargs;		/* For define(args)     */
+	char		name[1];	/* #define name 	*/
+} DEFBUF;
+
+/*
+ * The FILEINFO structure stores information about open files
+ * and macros being expanded.
+ */
+
+typedef struct fileinfo {
+	char		*bptr;		/* Buffer pointer	*/
+	int		line;		/* for include or macro */
+	FILE		*fp;		/* File if non-null	*/
+	struct fileinfo *parent;	/* Link to includer	*/
+	char		*filename;	/* File/macro name	*/
+	char		*progname;	/* From #line statement */
+	unsigned int	unrecur;	/* For macro recursion	*/
+	char		buffer[1];	/* current input line	*/
+} FILEINFO;
+
+/*
+ * The SIZES structure is used to store the values for #if sizeof
+ */
+
+typedef struct sizes {
+    short	bits;			/* If this bit is set,		*/
+    short	size;			/* this is the datum size value */
+    short	psize;			/* this is the pointer size	*/
+} SIZES;
+/*
+ * nomacarg is a built-in #define on Decus C.
+ */
+
+#ifdef	nomacarg
+#define cput		generate		/* cput concatenates tokens	*/
+#else
+#if COMMENT_INVISIBLE
+#define cput(c)         { if (c != TOK_SEP && c != COM_SEP) putchar(c); }
+#else
+#define cput(c)         { if (c != TOK_SEP) putchar(c); }
+#endif
+#endif
+
+#ifndef nomacarg
+#define streq(s1, s2)   (strcmp(s1, s2) == 0)
+#endif
+
+/*
+ * Note: IO_NORMAL and IO_ERROR are defined in the Decus C stdio.h file
+ */
+#ifndef IO_NORMAL
+#define IO_NORMAL	0
+#endif
+#ifndef IO_ERROR
+#define IO_ERROR	1
+#endif
+
+/*
+ * Externs
+ */
+
+#include "fpp.h"    /* structs and defines */
+#include "cppadd.h" /* Added prototypes for ANSI complience! */
+
+#ifdef AMIGA
+#include <dos.h>
+extern int _OSERR;
+#endif
+
+extern char	type[]; 		/* Character classifier 	*/
+
+#define compiling global->ifstack[0]
+#if	DEBUG
+extern int	debug;			/* Debug level			*/
+#endif
+extern SIZES	size_table[];		/* For #if sizeof sizes 	*/
+
+#define MAX_SPACE_SIZE 512 /* maximum number of whitespaces possible
+                              to remember */

3rdparty/bgfx/3rdparty/fcpp/cpp1.c

@@ -0,0 +1,593 @@
+/******************************************************************************
+Copyright (c) 1993 - 2011 Daniel Stenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#include <stdio.h>
+#include <ctype.h>
+#include "cppdef.h"
+#include "cpp.h"
+
+#if defined(AMIGA)
+#include        <dos.h>
+#if defined(SHARED)
+int _OSERR=0;
+char *_ProgramName="junk";
+void __stdargs _XCEXIT(long a) { return; }
+#endif
+#endif
+
+FILE_LOCAL ReturnCode output(struct Global *, int); /* Output one character */
+FILE_LOCAL void sharp(struct Global *);
+INLINE FILE_LOCAL ReturnCode cppmain(struct Global *);
+
+int fppPreProcess(struct fppTag *tags)
+{
+  size_t i=0;
+  ReturnCode ret;       /* cpp return code */
+  struct Global *global;
+
+  global=(struct Global *)malloc(sizeof(struct Global));
+  if(!global)
+    return(FPP_OUT_OF_MEMORY);
+
+  memset(global, 0, sizeof(struct Global));
+
+  global->infile=NULL;
+  global->line=0;
+  global->wrongline=0;
+  global->errors=0;
+  global->recursion=0;
+  global->rec_recover=TRUE;
+  global->instring=FALSE;
+  global->inmacro=FALSE;
+  global->workp=NULL;
+  global->keepcomments = FALSE;  /* Write out comments flag     */
+  global->cflag = FALSE;          /* -C option (keep comments)    */
+  global->eflag = FALSE;          /* -E option (never fail)       */
+  global->nflag = 0;              /* -N option (no predefines)    */
+  global->wflag = FALSE;          /* -W option (write #defines)   */
+
+  global->ifstack[0]=TRUE;       /* #if information     */
+  global->ifptr = global->ifstack;
+  global->incend = global->incdir;
+
+  /* names defined at cpp start */
+  global->preset[0]="frexxcpp"; /* This is the Frexx cpp program */
+#if defined( amiga )
+  global->preset[1]="amiga";
+  global->preset[2]="m68000";
+  global->preset[3]="amigados";
+  global->preset[4]= NULL;              /* Must be last         */
+#elif defined( unix )
+  global->preset[1]="unix";
+  global->preset[2]= NULL;
+#endif
+
+  /* Note: order is important   */
+  global->magic[0] = "__LINE__";
+  global->magic[1] = "__FILE__";
+  global->magic[2] = "__FUNCTION__";
+  global->magic[3] = "__FUNC_LINE__";
+  global->magic[4] = NULL;                        /* Must be last       */
+
+  global->funcline = 0;
+
+  global->cplusplus=1;
+  global->sharpfilename=NULL;
+
+  global->parmp=NULL;
+  global->nargs=0;
+
+  global->macro=NULL;
+  global->evalue=0;
+
+  global->depends=NULL;
+  global->input=NULL;
+  global->output=NULL;
+  global->error=NULL;
+  global->first_file=NULL;
+  global->userdata=NULL;
+
+  global->linelines=TRUE;
+  global->warnillegalcpp = FALSE;
+  global->outputLINE = TRUE;
+  global->warnnoinclude = TRUE;
+  global->showversion = TRUE;
+  global->showincluded = FALSE;
+  global->showspace = FALSE;
+  global->nestcomments = FALSE;
+  global->warnnestcomments = FALSE;
+  global->outputfile = TRUE;
+  global->included = 0;
+
+  global->comment = FALSE;
+  global->rightconcat = FALSE;
+  global->work[0] = '\0';
+  global->initialfunc = NULL;
+
+  memset(global->symtab, 0, SBSIZE * sizeof(DEFBUF *));
+
+  ret=initdefines(global);  /* O.S. specific def's  */
+  if(ret)
+    return(ret);
+  dooptions(global, tags);  /* Command line -flags  */
+  ret=addfile(global, stdin, global->work); /* "open" main input file       */
+
+  global->out = global->outputfile;
+
+  if(!ret)
+    ret=cppmain(global);             /* Process main file            */
+  if ((i = (global->ifptr - global->ifstack)) != 0) {
+#if OLD_PREPROCESSOR
+    cwarn(global, ERROR_IFDEF_DEPTH, i);
+#else
+    cerror(global, ERROR_IFDEF_DEPTH, i);
+#endif
+  }
+  fflush(stdout);
+// BK -  fclose(stdout);
+
+  if (global->errors > 0 && !global->eflag)
+    return(IO_ERROR);
+  return(IO_NORMAL);       /* No errors or -E option set   */
+}
+
+INLINE FILE_LOCAL
+ReturnCode cppmain(struct Global *global)
+{
+  /*
+   * Main process for cpp -- copies tokens from the current input
+   * stream (main file, include file, or a macro) to the output
+   * file.
+   */
+
+  int c;        /* Current character    */
+  int counter;  /* newlines and spaces  */
+  ReturnCode ret; /* return code variable type */
+
+  long bracelevel = 0;
+  long parenlevel = 0;
+  long bracketlevel = 0;
+  int fake = 0;
+
+#define MAX_FUNC_LENGTH 50
+
+  char tempfunc[MAX_FUNC_LENGTH + 1];
+  char tempfunc2[MAX_FUNC_LENGTH + 1];
+  char define = 0; /* probability of a function define phase in the program */
+  char prev = 0; /* previous type */
+  char go = 0;
+  char include = 0;
+  char initfunc = 0;
+
+  /* Initialize for reading tokens */
+  global->tokenbsize = 50;
+  global->tokenbuf = malloc(global->tokenbsize + 1);
+  if(!global->tokenbuf)
+    return(FPP_OUT_OF_MEMORY);
+
+  global->functionname = malloc(global->tokenbsize + 1);
+  if(!global->functionname)
+    return(FPP_OUT_OF_MEMORY);
+  global->functionname[0] = '\0';
+
+  if(global->showspace) {
+    global->spacebuf = (char *)malloc(MAX_SPACE_SIZE);
+    if(!global->spacebuf)
+      return(FPP_OUT_OF_MEMORY);
+  }
+
+  if(global->showversion)
+      Error(global, VERSION_TEXT);
+
+  /*
+   * Explicitly output a #line at the start of cpp output so
+   * that lint (etc.) knows the name of the original source
+   * file.  If we don't do this explicitly, we may get
+   * the name of the first #include file instead.
+   */
+  if(global->linelines) /* if #line lines are wanted! */
+    sharp(global);
+  /*
+   * This loop is started "from the top" at the beginning of each line
+   * wrongline is set TRUE in many places if it is necessary to write
+   * a #line record.  (But we don't write them when expanding macros.)
+   *
+   * The counter variable has two different uses:  at
+   * the start of a line, it counts the number of blank lines that
+   * have been skipped over. These are then either output via
+   * #line records or by outputting explicit blank lines.
+   * When expanding tokens within a line, the counter remembers
+   * whether a blank/tab has been output.  These are dropped
+   * at the end of the line, and replaced by a single blank
+   * within lines.
+   */
+
+  include = global->included;
+
+  while(include--) {
+    openinclude(global, global->include[(unsigned)include], TRUE);
+  }
+  
+  for (;;) {
+    counter = 0;                        /* Count empty lines    */
+    for (;;) {                          /* For each line, ...   */
+      global->comment = FALSE;          /* No comment yet!      */
+      global->chpos = 0;                /* Count whitespaces    */
+      while (type[(c = get(global))] == SPA)  /* Skip leading blanks */
+	if(global->showspace) {
+	  if(global->chpos<MAX_SPACE_SIZE-1)
+	    /* we still have buffer to store this! */
+	    global->spacebuf[global->chpos++]=(char)c;
+	}
+      if (c == '\n') {                  /* If line's all blank, */
+	if(global->comment) {
+	  /* A comment was output! */
+	  Putchar(global, '\n');
+	}
+	else
+	  ++counter;                    /* Do nothing now       */
+      }
+      else if (c == '#') {              /* Is 1st non-space '#' */
+	global->keepcomments = FALSE;   /* Don't pass comments  */
+	ret = control(global, &counter); /* Yes, do a #command   */
+	if(ret)
+	  return(ret);
+	global->keepcomments = (global->cflag && compiling);
+      }
+      else if (c == EOF_CHAR)           /* At end of file?      */
+	break;
+      else if (!compiling) {            /* #ifdef false?        */
+	skipnl(global);                 /* Skip to newline      */
+	counter++;                      /* Count it, too.       */
+      } else {
+	break;                          /* Actual token         */
+      }
+    }
+    if (c == EOF_CHAR)                  /* Exit process at      */
+      break;                            /* End of file          */
+    /*
+     * If the loop didn't terminate because of end of file, we
+     * know there is a token to compile.  First, clean up after
+     * absorbing newlines.  counter has the number we skipped.
+     */
+    if(global->linelines) { /* if #line lines are wanted! */
+      if ((global->wrongline && global->infile->fp != NULL) || counter > 4)
+        sharp(global);                    /* Output # line number */
+      else {                              /* If just a few, stuff */
+        while (--counter >= 0)            /* them out ourselves   */
+	  Putchar(global, (int)'\n');
+      }
+    }
+    if(global->showspace) {
+      /* Show all whitespaces! */
+      global->spacebuf[global->chpos] = '\0';
+      Putstring(global, global->spacebuf);
+    }
+    
+    /*
+     * Process each token on this line.
+     */
+    unget(global);                      /* Reread the char.     */
+    for (;;) {                          /* For the whole line,  */
+      do {                              /* Token concat. loop   */
+	for (global->chpos = counter = 0; type[(c = get(global))] == SPA;) {
+#if COMMENT_INVISIBLE
+	  if (c != COM_SEP)
+	    counter++;
+#else
+	  if(global->showspace && global->chpos < MAX_SPACE_SIZE-1) {
+	    global->spacebuf[global->chpos++]=(char)c;
+	  }
+	  counter++;            /* Skip over blanks     */
+#endif
+	}
+	if (c == EOF_CHAR || c == '\n')
+	  break;                      /* Exit line loop       */
+	else if (counter > 0) {       /* If we got any spaces */
+	  if(!global->showspace)      /* We don't output all spaces */
+	    Putchar(global, (int)' ');/* Output one space     */
+	  else {
+	    global->spacebuf[global->chpos] = '\0';
+	    Putstring(global, global->spacebuf); /* Output all whitespaces */
+	  }
+	}
+	if((ret=macroid(global, &c)))   /* Grab the token       */
+	  return(ret);
+      } while (type[c] == LET && catenate(global, &ret) && !ret);
+      if(ret)
+	/* If the loop was broken because of a fatal error! */
+	return(ret);
+      if (c == EOF_CHAR || c == '\n') /* From macro exp error */
+	break;                        /* Exit line loop       */
+      go++;
+      switch (type[c]) {
+      case LET:
+	go =0;
+	/* Quite ordinary token */
+	Putstring(global, global->tokenbuf);
+	
+	if(!define) {
+	  /* Copy the name */
+	  strncpy(tempfunc, global->tokenbuf, MAX_FUNC_LENGTH);
+          tempfunc[MAX_FUNC_LENGTH]=0;
+	}
+	/* fputs(global->tokenbuf, stdout); */
+	break;
+      case DIG:                 /* Output a number      */
+      case DOT:                 /* Dot may begin floats */
+	go = 0;
+	ret=scannumber(global, c, (ReturnCode(*)(struct Global *, int))output);
+	if(ret)
+	  return(ret);
+	break;
+      case QUO:                 /* char or string const */
+	go = 0;
+	/* Copy it to output */
+        if(!global->webmode) {
+          ret=scanstring(global, c,
+                         (ReturnCode(*)(struct Global *, int))output);
+          if(ret)
+            return(ret);
+          break;
+        }
+        /* FALLTHROUGH */
+      default:                  /* Some other character */
+	
+	define++;
+	switch(c) {
+	case '{':
+	  if(! bracelevel++ && define > 2) {
+	    /*
+	     * This is a starting brace. If there is a probability of a
+	     * function defining, we copy the `tempfunc' function name to
+	     * `global->functionname'.
+	     */
+	    strcpy(global->functionname, tempfunc2);
+	    global->funcline = global->line;
+
+		if(global->outputfunctions) {
+			/*
+			 * Output the discovered function name to stderr!
+			 */
+			Error(global, "#> Function defined at line %d: %s <#\n",
+				  global->line,
+				  global->functionname);
+		}
+
+	    if(global->initialfunc) {
+		int a;
+		for(a=0; a<global->excluded; a++) {
+		    /* check for excluded functions */
+		    if(!strcmp(global->functionname,
+			       global->excludedinit[a]))
+			break;
+		}
+		if(a==global->excluded) {
+		    expstuff(global, "__brace__", "{");
+		    expstuff(global, "__init_func__", global->initialfunc);
+		    initfunc = TRUE;
+		}
+	    }
+
+	  }
+	  break;
+	case '}':
+	  go = 0;
+	  if( (--bracelevel == initfunc) &&
+	     strcmp(global->infile->filename, "__init_func__") ) {
+	    /* we just stepped out of the function! */
+	    global->functionname[0] = '\0';
+	    global->funcline = 0;
+	    define = 1;
+
+	    if(initfunc) {
+	      Putchar(global, '}');
+	      bracelevel--;
+	      initfunc=0;
+	    }
+	  }
+	  fake = 0;
+	  break;
+	  
+	case ';':
+	case ',':
+	  if(go == 2) {
+	    define = 1;
+	    fake = 0;
+	    go--;
+	    break;
+	  }
+	  break;
+	case '(':
+	  if(! parenlevel++ && !bracelevel) {
+	    if(go == 2) {
+	      /* foobar(text) -> "(" is found. This can't be a
+		 function */
+	      go--;
+	      define = 1;
+	      break;
+	    }
+	    if( define < 2 && prev == LET) {
+	      /* This is the first parenthesis on the ground brace
+		 level, and we did previously not have a probable
+		 function name */
+	      strncpy(tempfunc2, global->tokenbuf, MAX_FUNC_LENGTH);
+              tempfunc2[MAX_FUNC_LENGTH]=0;
+	      define++;
+	    }
+	    else {
+	      /* we have a fake start */
+	      fake++;
+	    }
+	  }
+	  break;
+	case ')':
+	  if(! --parenlevel && !bracelevel && define>1 && !fake) {
+	    /*
+	     * The starting parentheses level and
+	     * the starting brace level.
+	     * This might be the start of a function defining coming
+	     * up!
+	     */
+	    define++; /* increase probability */
+	    fake = 0;
+	    go = 1;
+	  }
+	  break;
+	case '[':
+	  bracketlevel++;
+	  break;
+	case ']':
+	  bracketlevel--;
+	  break;
+	}
+	define--; /* decrease function probability */
+	
+	Putchar(global, c);     /* Just output it       */
+	break;
+      }                         /* Switch ends          */
+      prev = type[c];
+    }                           /* Line for loop        */
+    
+    if (c == '\n') {  /* Compiling at EOL?    */
+      Putchar(global, '\n');              /* Output newline, if   */
+      if (global->infile->fp == NULL)     /* Expanding a macro,   */
+	global->wrongline = TRUE; /* Output # line later        */
+    }
+  }                             /* Continue until EOF   */
+
+  if(global->showbalance) {
+    if(bracketlevel) {
+      cwarn(global, WARN_BRACKET_DEPTH, bracketlevel);
+    }
+    if(parenlevel) {
+      cwarn(global, WARN_PAREN_DEPTH, parenlevel);
+    }
+    if(bracelevel) {
+      cwarn(global, WARN_BRACE_DEPTH, bracelevel);
+    }
+  }
+  if (global->wflag) {
+    global->out = TRUE;         /* enable output */
+    outdefines(global);         /* Write out #defines   */
+  }
+  return(FPP_OK);
+}
+
+FILE_LOCAL
+ReturnCode output(struct Global *global, int c)
+{
+  /*
+   * Output one character to stdout -- output() is passed as an
+   * argument to scanstring()
+   */
+#if COMMENT_INVISIBLE
+  if (c != TOK_SEP && c != COM_SEP)
+#else
+  if (c != TOK_SEP)
+#endif
+    Putchar(global, c);
+  return(FPP_OK);
+}
+
+void Putchar(struct Global *global, int c)
+{
+  /*
+   * Output one character to stdout or to output function!
+   */
+  if(!global->out)
+    return;
+#if defined(UNIX)
+  if(global->output)
+    global->output(c, global->userdata);
+  else
+    putchar(c);
+#else /* amiga */
+  global->output(c, global->userdata);
+#endif
+}
+
+void Putstring(struct Global *global, char *string)
+{
+  /*
+   * Output a string! One letter at a time to the Putchar routine!
+   */
+
+  if(!string)
+    return;
+
+  while(*string)
+    Putchar(global, *string++);
+}
+
+void Putint(struct Global *global, int number)
+{
+  /*
+   * Output the number as a string.
+   */
+
+  char buffer[16]; /* an integer can't be that big! */
+  char *point=buffer;
+
+  sprintf(buffer, "%d", number);
+
+  while(*point)
+    Putchar(global, *point++);
+}
+
+
+FILE_LOCAL
+void sharp(struct Global *global)
+{
+  /*
+   * Output a line number line.
+   */
+
+  char *name;
+  if (global->keepcomments)                     /* Make sure # comes on */
+    Putchar(global, '\n');                      /* a fresh, new line.   */
+  /*  printf("#%s %d", LINE_PREFIX, global->line); */
+
+  Putchar(global, '#');
+  if(global->outputLINE)
+          Putstring(global, LINE_PREFIX);
+  Putchar(global, ' ');
+  Putint(global, global->line);
+
+  if (global->infile->fp != NULL) {
+    name = (global->infile->progname != NULL)
+      ? global->infile->progname : global->infile->filename;
+    if (global->sharpfilename == NULL
+        || (global->sharpfilename != NULL && !streq(name, global->sharpfilename))) {
+      if (global->sharpfilename != NULL)
+        free(global->sharpfilename);
+      global->sharpfilename = savestring(global, name);
+      /* printf(" \"%s\"", name); */
+      Putstring(global, " \"");
+      Putstring(global, name);
+      Putchar(global, '\"');
+    }
+  }
+  Putchar(global, '\n');
+  global->wrongline = FALSE;
+  return;
+}

3rdparty/bgfx/3rdparty/fcpp/cpp2.c

@@ -0,0 +1,773 @@
+/******************************************************************************
+Copyright (c) 1999 Daniel Stenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+#include    <stdio.h>
+#include    <ctype.h>
+#include    "cppdef.h"
+#include    "cpp.h"
+
+#ifdef _AMIGA
+#include <proto/dos.h>
+#endif
+
+FILE_LOCAL void dump_line(struct Global *, int *);
+FILE_LOCAL ReturnCode doif(struct Global *, int);
+INLINE FILE_LOCAL ReturnCode doinclude(struct Global *);
+INLINE FILE_LOCAL int hasdirectory(char *, char *);
+
+
+/*
+ * Generate (by hand-inspection) a set of unique values for each control
+ * operator.  Note that this is not guaranteed to work for non-Ascii
+ * machines.  CPP won't compile if there are hash conflicts.
+ */
+
+#define L_assert    ('a' + ('s' << 1))
+#define L_define    ('d' + ('f' << 1))
+#define L_elif      ('e' + ('i' << 1))
+#define L_else      ('e' + ('s' << 1))
+#define L_endif     ('e' + ('d' << 1))
+#define L_error     ('e' + ('r' << 1))
+#define L_if        ('i' + (EOS << 1))
+#define L_ifdef     ('i' + ('d' << 1))
+#define L_ifndef    ('i' + ('n' << 1))
+#define L_include   ('i' + ('c' << 1))
+#define L_line      ('l' + ('n' << 1))
+#define L_nogood    (EOS + (EOS << 1))      /* To catch #i          */
+#define L_pragma    ('p' + ('a' << 1))
+#define L_undef     ('u' + ('d' << 1))
+
+ReturnCode control( struct Global *global,
+    int *counter )  /* Pending newline counter */
+{
+    /*
+     * Process #control lines.  Simple commands are processed inline,
+     * while complex commands have their own subroutines.
+     *
+     * The counter is used to force out a newline before #line, and
+     * #pragma commands.  This prevents these commands from ending up at
+     * the end of the previous line if cpp is invoked with the -C option.
+     */
+
+    int c;
+    char *tp;
+    int hash;
+    char *ep;
+    ReturnCode ret;
+
+    c = skipws( global );
+
+    if( c == '\n' || c == EOF_CHAR )
+        {
+        (*counter)++;
+
+        return(FPP_OK);
+        }
+
+    if( !isdigit(c) )
+        scanid( global, c );                  /* Get #word to tokenbuf        */
+    else
+        {
+        unget( global );                    /* Hack -- allow #123 as a      */
+
+        strcpy( global->tokenbuf, "line" );   /* synonym for #line 123        */
+        }
+
+    hash = (global->tokenbuf[1] == EOS) ? L_nogood : (global->tokenbuf[0] + (global->tokenbuf[2] << 1));
+
+    switch( hash )
+        {
+        case L_assert:
+            tp = "assert";
+            break;
+        case L_define:
+            tp = "define";
+            break;
+        case L_elif:
+            tp = "elif";
+            break;
+        case L_else:
+            tp = "else";
+            break;
+        case L_endif:
+            tp = "endif";
+            break;
+        case L_error:
+            tp = "error";
+            break;
+        case L_if:
+            tp = "if";
+            break;
+        case L_ifdef:
+            tp = "ifdef";
+            break;
+        case L_ifndef:
+            tp = "ifndef";
+            break;
+        case L_include:
+            tp = "include";
+            break;
+        case L_line:
+            tp = "line";
+            break;
+        case L_pragma:
+            tp = "pragma";
+            break;
+        case L_undef:
+            tp = "undef";
+            break;
+        default:
+            hash = L_nogood;
+        case L_nogood:
+            tp = "";
+            break;
+        }
+
+    if( !streq( tp, global->tokenbuf ) )
+        hash = L_nogood;
+
+    /*
+     * hash is set to a unique value corresponding to the
+     * control keyword (or L_nogood if we think it's nonsense).
+     */
+    if( global->infile->fp == NULL )
+        cwarn( global, WARN_CONTROL_LINE_IN_MACRO, global->tokenbuf );
+
+    if( !compiling )
+        {                       /* Not compiling now    */
+        switch( hash )
+            {
+            case L_if:              /* These can't turn     */
+            case L_ifdef:           /*  compilation on, but */
+            case L_ifndef:          /*   we must nest #if's */
+                if( ++global->ifptr >= &global->ifstack[BLK_NEST] )
+                    {
+                    cfatal( global, FATAL_TOO_MANY_NESTINGS, global->tokenbuf );
+
+                    return( FPP_TOO_MANY_NESTED_STATEMENTS );
+                    }
+
+                *global->ifptr = 0;       /* !WAS_COMPILING   */
+
+            case L_line:            /* Many         */
+                /*
+                 * Are pragma's always processed?
+                 */
+            case L_pragma:          /*  options     */
+            case L_include:         /*   are uninteresting  */
+            case L_define:          /*    if we     */
+            case L_undef:           /*     aren't           */
+            case L_assert:          /*  compiling.  */
+            case L_error:
+                dump_line( global, counter );       /* Ignore rest of line  */
+                return(FPP_OK);
+            }
+        }
+    /*
+     * Make sure that #line and #pragma are output on a fresh line.
+     */
+    if( *counter > 0 && (hash == L_line || hash == L_pragma) )
+        {
+        Putchar( global, '\n' );
+
+        (*counter)--;
+        }
+
+    switch( hash )
+        {
+        case L_line:
+            /*
+             * Parse the line to update the line number and "progname"
+             * field and line number for the next input line.
+             * Set wrongline to force it out later.
+             */
+            c = skipws( global );
+
+            global->workp = global->work;       /* Save name in work    */
+
+            while( c != '\n' && c != EOF_CHAR )
+                {
+                if( (ret = save( global, c )) )
+                    return(ret);
+
+                c = get( global );
+                }
+
+            unget( global );
+
+            if( (ret = save( global, EOS )) )
+                return(ret);
+
+            /*
+             * Split #line argument into <line-number> and <name>
+             * We subtract 1 as we want the number of the next line.
+             */
+            global->line = atoi(global->work) - 1;     /* Reset line number    */
+
+            for( tp = global->work; isdigit(*tp) || type[(unsigned)*tp] == SPA; tp++)
+                ;             /* Skip over digits */
+
+            if( *tp != EOS )
+                {
+                /* Got a filename, so:  */
+
+                if( *tp == '"' && (ep = strrchr(tp + 1, '"')) != NULL )
+                    {
+                    tp++;           /* Skip over left quote */
+
+                    *ep = EOS;      /* And ignore right one */
+                    }
+
+                if( global->infile->progname != NULL )
+                    /* Give up the old name if it's allocated.   */
+                    free( global->infile->progname );
+
+                global->infile->progname = savestring( global, tp );
+                }
+
+            global->wrongline = TRUE;           /* Force output later   */
+            break;
+
+        case L_include:
+            ret = doinclude( global );
+            if( ret )
+                return(ret);
+            break;
+
+        case L_define:
+            ret = dodefine( global );
+            if( ret )
+                return(ret);
+            break;
+
+        case L_undef:
+            doundef( global );
+            break;
+
+        case L_else:
+            if( global->ifptr == &global->ifstack[0] )
+                {
+                cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf );
+
+                dump_line( global, counter );
+
+                return( FPP_OK );
+                }
+            else if( (*global->ifptr & ELSE_SEEN) != 0 )
+                {
+                cerror( global, ERROR_STRING_MAY_NOT_FOLLOW_ELSE, global->tokenbuf );
+
+                dump_line( global, counter );
+
+                return( FPP_OK );
+                }
+
+            *global->ifptr |= ELSE_SEEN;
+
+            if( (*global->ifptr & WAS_COMPILING) != 0 )
+                {
+                if( compiling || (*global->ifptr & TRUE_SEEN) != 0 )
+                    compiling = FALSE;
+                else
+                    {
+                    compiling = TRUE;
+                    }
+                }
+            break;
+
+        case L_elif:
+            if( global->ifptr == &global->ifstack[0] )
+                {
+                cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf );
+
+                dump_line( global, counter );
+
+                return( FPP_OK );
+                }
+            else if( (*global->ifptr & ELSE_SEEN) != 0 )
+                {
+                cerror( global, ERROR_STRING_MAY_NOT_FOLLOW_ELSE, global->tokenbuf );
+
+                dump_line( global, counter );
+
+                return( FPP_OK );
+                }
+
+            if( (*global->ifptr & (WAS_COMPILING | TRUE_SEEN)) != WAS_COMPILING )
+                {
+                compiling = FALSE;        /* Done compiling stuff */
+
+                dump_line( global, counter );   /* Skip this clause */
+
+                return( FPP_OK );
+                }
+
+            ret = doif( global, L_if );
+
+            if( ret )
+                return(ret);
+
+            break;
+
+        case L_error:
+            cerror(global, ERROR_ERROR);
+            break;
+
+        case L_if:
+        case L_ifdef:
+        case L_ifndef:
+            if( ++global->ifptr < &global->ifstack[BLK_NEST] )
+                {
+                *global->ifptr = WAS_COMPILING;
+
+                ret = doif( global, hash );
+
+                if( ret )
+                    return(ret);
+
+                break;
+                }
+
+            cfatal( global, FATAL_TOO_MANY_NESTINGS, global->tokenbuf );
+
+            return( FPP_TOO_MANY_NESTED_STATEMENTS );
+
+        case L_endif:
+            if( global->ifptr == &global->ifstack[0] )
+                {
+                cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf );
+
+                dump_line( global, counter );
+
+                return(FPP_OK);
+                }
+
+            if( !compiling && (*global->ifptr & WAS_COMPILING) != 0 )
+                global->wrongline = TRUE;
+
+            compiling = ((*global->ifptr & WAS_COMPILING) != 0);
+
+            --global->ifptr;
+
+            break;
+
+        case L_assert:
+            {
+            int result;
+
+            ret = eval( global, &result );
+
+            if(ret)
+                return(ret);
+
+            if( result == 0 )
+                cerror( global, ERROR_PREPROC_FAILURE );
+            }
+            break;
+
+        case L_pragma:
+            /*
+             * #pragma is provided to pass "options" to later
+             * passes of the compiler.  cpp doesn't have any yet.
+             */
+            Putstring( global, "#pragma " );
+
+            while( (c = get( global ) ) != '\n' && c != EOF_CHAR )
+                Putchar( global, c );
+
+            unget( global );
+
+            Putchar( global, '\n' );
+
+            break;
+
+        default:
+            /*
+             * Undefined #control keyword.
+             * Note: the correct behavior may be to warn and
+             * pass the line to a subsequent compiler pass.
+             * This would allow #asm or similar extensions.
+             */
+            if( global->warnillegalcpp )
+                cwarn( global, WARN_ILLEGAL_COMMAND, global->tokenbuf );
+
+            Putchar( global, '#' );
+            Putstring( global, global->tokenbuf );
+            Putchar( global, ' ' );
+
+            while( (c = get( global ) ) != '\n' && c != EOF_CHAR )
+                Putchar( global, c );
+
+            unget( global );
+
+            Putchar( global, '\n' );
+
+            break;
+        }
+
+    if( hash != L_include )
+        {
+        #if OLD_PREPROCESSOR
+        /*
+         * Ignore the rest of the #control line so you can write
+         *      #if foo
+         *      #endif  foo
+         */
+        dump_line( global, counter );         /* Take common exit */
+
+        return( FPP_OK );
+        #else
+        if( skipws( global ) != '\n' )
+            {
+            cwarn( global, WARN_UNEXPECTED_TEXT_IGNORED );
+
+            skipnl( global );
+            }
+        #endif
+        }
+
+    (*counter)++;
+
+    return( FPP_OK );
+}
+
+FILE_LOCAL
+void dump_line(struct Global *global, int *counter)
+{
+    skipnl( global );         /* Ignore rest of line  */
+
+    (*counter)++;
+}
+
+FILE_LOCAL
+ReturnCode doif(struct Global *global, int hash)
+{
+    /*
+     * Process an #if, #ifdef, or #ifndef. The latter two are straightforward,
+     * while #if needs a subroutine of its own to evaluate the expression.
+     *
+     * doif() is called only if compiling is TRUE.  If false, compilation
+     * is always supressed, so we don't need to evaluate anything.  This
+     * supresses unnecessary warnings.
+     */
+
+    int c;
+    int found;
+    ReturnCode ret;
+
+    if( (c = skipws( global ) ) == '\n' || c == EOF_CHAR )
+        {
+        unget( global );
+
+        cerror( global, ERROR_MISSING_ARGUMENT );
+
+        #if !OLD_PREPROCESSOR
+        skipnl( global );               /* Prevent an extra     */
+
+        unget( global );                /* Error message        */
+        #endif
+
+        return(FPP_OK);
+        }
+
+    if( hash == L_if )
+        {
+        unget( global );
+
+        ret = eval( global, &found );
+
+        if( ret )
+            return( ret );
+
+        found = (found != 0);     /* Evaluate expr, != 0 is  TRUE */
+
+        hash = L_ifdef;       /* #if is now like #ifdef */
+        }
+    else
+        {
+        if( type[c] != LET )
+            {         /* Next non-blank isn't letter  */
+                          /* ... is an error          */
+            cerror( global, ERROR_MISSING_ARGUMENT );
+
+            #if !OLD_PREPROCESSOR
+            skipnl( global );             /* Prevent an extra     */
+
+            unget( global );              /* Error message        */
+            #endif
+
+            return(FPP_OK);
+            }
+
+        found = ( lookid( global, c ) != NULL ); /* Look for it in symbol table */
+        }
+
+    if( found == (hash == L_ifdef) )
+        {
+        compiling = TRUE;
+
+        *global->ifptr |= TRUE_SEEN;
+        }
+    else
+        compiling = FALSE;
+
+    return(FPP_OK);
+}
+
+INLINE FILE_LOCAL
+ReturnCode doinclude( struct Global *global )
+{
+    /*
+     *  Process the #include control line.
+     *  There are three variations:
+     *
+     *      #include "file" search somewhere relative to the
+     *                      current source file, if not found,
+     *                      treat as #include <file>.
+     *
+     *      #include <file> Search in an implementation-dependent
+     *                      list of places.
+     *
+     *      #include token  Expand the token, it must be one of
+     *                      "file" or <file>, process as such.
+     *
+     *  Note:   the November 12 draft forbids '>' in the #include <file> format.
+     *          This restriction is unnecessary and not implemented.
+     */
+
+    int c;
+    int delim;
+    ReturnCode ret;
+
+    delim = skipws( global );
+
+    if( (ret = macroid( global, &delim )) )
+        return(ret);
+
+    if( delim != '<' && delim != '"' )
+        {
+        cerror( global, ERROR_INCLUDE_SYNTAX );
+
+        return( FPP_OK );
+        }
+
+    if( delim == '<' )
+        delim = '>';
+
+    global->workp = global->work;
+
+    while( (c = get(global)) != '\n' && c != EOF_CHAR )
+        if( (ret = save( global, c )) )       /* Put it away.                */
+            return( ret );
+
+    unget( global );                        /* Force nl after include      */
+
+    /*
+     * The draft is unclear if the following should be done.
+     */
+    while( --global->workp >= global->work &&
+        (*global->workp == ' ' || *global->workp == '\t') )
+        ;               /* Trim blanks from filename    */
+
+    if( *global->workp != delim )
+        {
+        cerror( global, ERROR_INCLUDE_SYNTAX );
+
+        return(FPP_OK);
+        }
+
+    *global->workp = EOS;         /* Terminate filename       */
+
+    ret = openinclude( global, global->work, (delim == '"') );
+
+    if( ret && global->warnnoinclude )
+        {
+        /*
+         * Warn if #include file isn't there.
+         */
+        cwarn( global, WARN_CANNOT_OPEN_INCLUDE, global->work );
+        }
+
+    return( FPP_OK );
+}
+
+#ifdef _AMIGA
+ReturnCode MultiAssignLoad( struct Global *global, char *incptr, char *filename, char *tmpname );
+#endif
+
+ReturnCode openinclude( struct Global *global,
+    char *filename,     /* Input file name         */
+    int searchlocal )   /* TRUE if #include "file" */
+{
+    /*
+     * Actually open an include file.  This routine is only called from
+     * doinclude() above, but was written as a separate subroutine for
+     * programmer convenience.  It searches the list of directories
+     * and actually opens the file, linking it into the list of
+     * active files.  Returns ReturnCode. No error message is printed.
+     */
+
+    char **incptr;
+    char tmpname[NWORK]; /* Filename work area    */
+    size_t len;
+
+    if( filename[0] == '/' )
+        {
+        if( ! openfile( global, filename ) )
+            return(FPP_OK);
+        }
+
+    if( searchlocal )
+        {
+        /*
+         * Look in local directory first.
+         * Try to open filename relative to the directory of the current
+         * source file (as opposed to the current directory). (ARF, SCK).
+         * Note that the fully qualified pathname is always built by
+         * discarding the last pathname component of the source file
+         * name then tacking on the #include argument.
+         */
+        if( hasdirectory( global->infile->filename, tmpname ) )
+            strcat( tmpname, filename );
+        else
+            strcpy( tmpname, filename );
+
+        if( ! openfile( global, tmpname ) )
+            return(FPP_OK);
+        }
+
+    /*
+     * Look in any directories specified by -I command line
+     * arguments, then in the builtin search list.
+     */
+    for( incptr = global->incdir; incptr < global->incend; incptr++ )
+        {
+        len = strlen(*incptr);
+
+        if( len + strlen(filename) >= sizeof(tmpname) )
+            {
+            cfatal( global, FATAL_FILENAME_BUFFER_OVERFLOW );
+
+            return( FPP_FILENAME_BUFFER_OVERFLOW );
+            }
+        else
+            {
+            if( (*incptr)[len-1] != '/' )
+                sprintf( tmpname, "%s/%s", *incptr, filename );
+            else
+                sprintf( tmpname, "%s%s", *incptr, filename );
+
+            if( !openfile( global, tmpname ) )
+                return(FPP_OK);
+            }
+        }
+
+    return( FPP_NO_INCLUDE );
+}
+
+INLINE FILE_LOCAL
+int hasdirectory( char *source,   /* Directory to examine         */
+    char *result )  /* Put directory stuff here     */
+{
+    /*
+     * If a device or directory is found in the source filename string, the
+     * node/device/directory part of the string is copied to result and
+     * hasdirectory returns TRUE.  Else, nothing is copied and it returns FALSE.
+     */
+
+    char *tp2;
+
+    if( (tp2 = strrchr( source, '/' ) ) == NULL )
+        return(FALSE);
+
+    strncpy( result, source, tp2 - source + 1 );
+
+    result[tp2 - source + 1] = EOS;
+
+    return( TRUE );
+}
+
+#ifdef _AMIGA
+//
+//  amp July 9, 1997
+//
+//  Use the OS Luke...
+//
+//  We do the sneaky version and let the OS do all
+//  the hard work so we don't have to mess around
+//  a lot ;)
+//
+ReturnCode MultiAssignLoad( struct Global *global, char *incptr, char *filename, char *tmpname )
+
+{ /* MultiAssignLoad */
+
+    struct MsgPort  *FSTask;
+    struct DevProc  *DevProc = NULL;
+    LONG            RtnCode = FPP_NO_INCLUDE;
+
+    FSTask = GetFileSysTask();
+
+    do
+        {
+        //
+        //  This should not bring up a requester.
+        //  check to see if cpp does in fact tweek
+        //  the process WindowPtr.
+        //
+        DevProc = GetDeviceProc( incptr, DevProc );
+
+        if( DevProc )
+            {
+            SetFileSysTask( DevProc->dvp_Port );
+
+            //
+            //  Normally we would pass the lock and filename
+            //  to the Load() routine, which would CD to the
+            //  directory and Open(filename), but in order to
+            //  satisfy the exisiting openfile() function, we
+            //  bite the bullet and build the complete pathspec
+            //  rather than add the standard Load() routine.
+            //
+            if( NameFromLock( DevProc->dvp_Lock, tmpname, NWORK ) )
+                {
+                AddPart( tmpname, filename, NWORK );
+
+                RtnCode = openfile( global, tmpname );
+
+                if( ! RtnCode )
+                    break;
+                }
+            }
+
+        } while ( RtnCode &&
+            DevProc &&
+            (DevProc->dvp_Flags & DVPF_ASSIGN) &&
+            IoErr() == ERROR_OBJECT_NOT_FOUND); /* repeat if multi-assign */
+
+    SetFileSysTask( FSTask );
+
+    if( DevProc )
+        FreeDeviceProc( DevProc );
+
+    return RtnCode;
+
+} /* MultiAssignLoad */
+#endif  //_AMIGA

3rdparty/bgfx/3rdparty/fcpp/cpp3.c

@@ -0,0 +1,401 @@
+/******************************************************************************
+Copyright (c) 1999 Daniel Stenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+#include        <stdio.h>
+#include        <ctype.h>
+#include        <time.h>        /*OIS*0.92*/
+#include        "cppdef.h"
+#include        "cpp.h"
+
+ReturnCode openfile(struct Global *global, char *filename)
+{
+  /*
+   * Open a file, add it to the linked list of open files.
+   * This is called only from openfile() in cpp2.c.
+   */
+
+  FILE *fp;
+  ReturnCode ret;
+
+  if ((fp = fopen(filename, "r")) == NULL)
+    ret=FPP_OPEN_ERROR;
+  else
+    ret=addfile(global, fp, filename);
+
+  if(!ret && global->depends) {
+	global->depends(filename, global->userdata);
+  }
+
+  if(!ret && global->showincluded) {
+          /* no error occured! */
+          Error(global, "cpp: included \"");
+          Error(global, filename);
+          Error(global, "\"\n");
+  }
+  return(ret);
+}
+
+ReturnCode addfile(struct Global *global,
+                   FILE *fp,            /* Open file pointer */
+                   char *filename)      /* Name of the file  */
+{
+  /*
+   * Initialize tables for this open file.  This is called from openfile()
+   * above (for #include files), and from the entry to cpp to open the main
+   * input file. It calls a common routine, getfile() to build the FILEINFO
+   * structure which is used to read characters. (getfile() is also called
+   * to setup a macro replacement.)
+   */
+
+  FILEINFO *file;
+  ReturnCode ret;
+
+  ret = getfile(global, NBUFF, filename, &file);
+  if(ret)
+    return(ret);
+  file->fp = fp;                        /* Better remember FILE *       */
+  file->buffer[0] = EOS;                /* Initialize for first read    */
+  global->line = 1;                     /* Working on line 1 now        */
+  global->wrongline = TRUE;             /* Force out initial #line      */
+  return(FPP_OK);
+}
+
+int dooptions(struct Global *global, struct fppTag *tags)
+{
+  /*
+   * dooptions is called to process command line arguments (-Detc).
+   * It is called only at cpp startup.
+   */
+  DEFBUF *dp;
+  char end=FALSE; /* end of taglist */
+
+  while(tags && !end) {
+    switch(tags->tag) {
+    case FPPTAG_END:
+      end=TRUE;
+      break;
+    case FPPTAG_INITFUNC:
+      global->initialfunc = (char *) tags->data;
+      break;
+    case FPPTAG_DISPLAYFUNCTIONS:
+      global->outputfunctions = tags->data?1:0;
+      break;
+    case FPPTAG_RIGHTCONCAT:
+      global->rightconcat = tags->data?1:0;
+      break;
+    case FPPTAG_OUTPUTMAIN:
+      global->outputfile = tags->data?1:0;
+      break;
+    case FPPTAG_NESTED_COMMENTS:
+      global->nestcomments = tags->data?1:0;
+      break;
+    case FPPTAG_WARNMISSINCLUDE:
+      global->warnnoinclude = tags->data?1:0;
+      break;
+    case FPPTAG_WARN_NESTED_COMMENTS:
+      global->warnnestcomments =  tags->data?1:0;
+      break;
+    case FPPTAG_OUTPUTSPACE:
+      global->showspace = tags->data?1:0;
+      break;
+    case FPPTAG_OUTPUTBALANCE:
+      global->showbalance = tags->data?1:0;
+      break;
+    case FPPTAG_OUTPUTINCLUDES:
+      global->showincluded = tags->data?1:0;
+      break;
+    case FPPTAG_IGNOREVERSION:
+      global->showversion = tags->data?1:0;
+      break;
+    case FPPTAG_WARNILLEGALCPP:
+      global->warnillegalcpp = tags->data?1:0;
+      break;
+    case FPPTAG_OUTPUTLINE:
+      global->outputLINE = tags->data?1:0;
+      break;
+    case FPPTAG_KEEPCOMMENTS:
+      if(tags->data) {
+        global->cflag = TRUE;
+        global->keepcomments = TRUE;
+      }
+      break;
+    case FPPTAG_DEFINE:
+      /*
+       * If the option is just "-Dfoo", make it -Dfoo=1
+       */
+      {
+        char *symbol=(char *)tags->data;
+        char *text=symbol;
+        while (*text != EOS && *text != '=')
+          text++;
+        if (*text == EOS)
+          text = "1";
+        else
+          *text++ = EOS;
+        /*
+         * Now, save the word and its definition.
+         */
+        dp = defendel(global, symbol, FALSE);
+        if(!dp)
+          return(FPP_OUT_OF_MEMORY);
+        dp->repl = savestring(global, text);
+        dp->nargs = DEF_NOARGS;
+      }
+      break;
+    case FPPTAG_IGNORE_NONFATAL:
+      global->eflag = TRUE;
+      break;
+    case FPPTAG_INCLUDE_DIR:
+      if (global->incend >= &global->incdir[NINCLUDE]) {
+          cfatal(global, FATAL_TOO_MANY_INCLUDE_DIRS);
+          return(FPP_TOO_MANY_INCLUDE_DIRS);
+      }
+      *global->incend++ = (char *)tags->data;
+      break;
+    case FPPTAG_INCLUDE_FILE:
+    case FPPTAG_INCLUDE_MACRO_FILE:
+      if (global->included >= NINCLUDE) {
+          cfatal(global, FATAL_TOO_MANY_INCLUDE_FILES);
+          return(FPP_TOO_MANY_INCLUDE_FILES);
+      }
+      global->include[(unsigned)global->included] = (char *)tags->data;
+
+      global->includeshow[(unsigned)global->included] =
+          (tags->tag == FPPTAG_INCLUDE_FILE);
+
+      global->included++;
+      break;
+    case FPPTAG_BUILTINS:
+      global->nflag|=(tags->data?NFLAG_BUILTIN:0);
+      break;
+    case FPPTAG_PREDEFINES:
+      global->nflag|=(tags->data?NFLAG_PREDEFINE:0);
+      break;
+    case FPPTAG_IGNORE_CPLUSPLUS:
+      global->cplusplus=!tags->data;
+      break;
+    case FPPTAG_SIZEOF_TABLE:
+      {
+        SIZES *sizp;    /* For -S               */
+        int size;       /* For -S               */
+        int isdatum;    /* FALSE for -S*        */
+        int endtest;    /* For -S               */
+
+        char *text=(char *)tags->data;
+
+        sizp = size_table;
+        if ((isdatum = (*text != '*'))) /* If it's just -S,     */
+          endtest = T_FPTR;     /* Stop here            */
+        else {                  /* But if it's -S*      */
+          text++;               /* Step over '*'        */
+          endtest = 0;          /* Stop at end marker   */
+        }
+        while (sizp->bits != endtest && *text != EOS) {
+          if (!isdigit(*text)) {    /* Skip to next digit   */
+            text++;
+            continue;
+          }
+          size = 0;             /* Compile the value    */
+          while (isdigit(*text)) {
+            size *= 10;
+            size += (*text++ - '0');
+          }
+          if (isdatum)
+            sizp->size = size;  /* Datum size           */
+          else
+            sizp->psize = size; /* Pointer size         */
+          sizp++;
+        }
+        if (sizp->bits != endtest)
+          cwarn(global, WARN_TOO_FEW_VALUES_TO_SIZEOF, NULL);
+        else if (*text != EOS)
+          cwarn(global, WARN_TOO_MANY_VALUES_TO_SIZEOF, NULL);
+      }
+      break;
+    case FPPTAG_UNDEFINE:
+      if (defendel(global, (char *)tags->data, TRUE) == NULL)
+        cwarn(global, WARN_NOT_DEFINED, tags->data);
+      break;
+    case FPPTAG_OUTPUT_DEFINES:
+      global->wflag++;
+      break;
+    case FPPTAG_INPUT_NAME:
+      strcpy(global->work, tags->data);    /* Remember input filename */
+      global->first_file=tags->data;
+      break;
+	case FPPTAG_DEPENDS:
+      global->depends=(void (*)(char *, void *))tags->data;
+	  break;
+    case FPPTAG_INPUT:
+      global->input=(char *(*)(char *, int, void *))tags->data;
+      break;
+    case FPPTAG_OUTPUT:
+      global->output=(void (*)(int, void *))tags->data;
+      break;
+    case FPPTAG_ERROR:
+      global->error=(void (*)(void *, char *, va_list))tags->data;
+      break;
+    case FPPTAG_USERDATA:
+      global->userdata=tags->data;
+      break;
+    case FPPTAG_LINE:
+      global->linelines= tags->data?1:0;
+      break;
+    case FPPTAG_EXCLFUNC:
+      global->excludedinit[ global->excluded++ ] = (char *)tags->data;
+      break;
+    case FPPTAG_WEBMODE:
+      global->webmode=(tags->data?1:0);
+      break;
+    default:
+      cwarn(global, WARN_INTERNAL_ERROR, NULL);
+      break;
+    }
+    tags++;
+  }
+  return(0);
+}
+
+ReturnCode initdefines(struct Global *global)
+{
+  /*
+   * Initialize the built-in #define's.  There are two flavors:
+   *    #define decus   1               (static definitions)
+   *    #define __FILE__ ??             (dynamic, evaluated by magic)
+   * Called only on cpp startup.
+   *
+   * Note: the built-in static definitions are supressed by the -N option.
+   * __LINE__, __FILE__, __TIME__ and __DATE__ are always present.
+   */
+
+  char **pp;
+  char *tp;
+  DEFBUF *dp;
+  struct tm *tm;
+
+  int i;
+  time_t tvec;
+
+  static char months[12][4] = {
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+    };
+
+  /*
+   * Predefine the built-in symbols.  Allow the
+   * implementor to pre-define a symbol as "" to
+   * eliminate it.
+   */
+  if (!(global->nflag & NFLAG_BUILTIN)) {
+    for (pp = global->preset; *pp != NULL; pp++) {
+      if (*pp[0] != EOS) {
+        dp = defendel(global, *pp, FALSE);
+        if(!dp)
+          return(FPP_OUT_OF_MEMORY);
+        dp->repl = savestring(global, "1");
+        dp->nargs = DEF_NOARGS;
+      }
+    }
+  }
+  /*
+   * The magic pre-defines (__FILE__ and __LINE__ are
+   * initialized with negative argument counts.  expand()
+   * notices this and calls the appropriate routine.
+   * DEF_NOARGS is one greater than the first "magic" definition.
+   */
+  if (!(global->nflag & NFLAG_PREDEFINE)) {
+    for (pp = global->magic, i = DEF_NOARGS; *pp != NULL; pp++) {
+      dp = defendel(global, *pp, FALSE);
+      if(!dp)
+        return(FPP_OUT_OF_MEMORY);
+      dp->nargs = --i;
+    }
+#if OK_DATE
+    /*
+     * Define __DATE__ as today's date.
+     */
+    dp = defendel(global, "__DATE__", FALSE);
+    tp = malloc(14);
+    if(!tp || !dp)
+      return(FPP_OUT_OF_MEMORY);
+    dp->repl = tp;
+    dp->nargs = DEF_NOARGS;
+    time(&tvec);
+    tm = localtime(&tvec);
+    sprintf(tp, "\"%3s %2d %4d\"",      /* "Aug 20 1988" */
+            months[tm->tm_mon],
+            tm->tm_mday,
+            tm->tm_year + 1900);
+
+    /*
+     * Define __TIME__ as this moment's time.
+     */
+    dp = defendel(global, "__TIME__", FALSE);
+    tp = malloc(11);
+    if(!tp || !dp)
+      return(FPP_OUT_OF_MEMORY);
+    dp->repl = tp;
+    dp->nargs = DEF_NOARGS;
+    sprintf(tp, "\"%2d:%02d:%02d\"",    /* "20:42:31" */
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec);
+#endif
+  }
+  return(FPP_OK);
+}
+
+void deldefines(struct Global *global)
+{
+  /*
+   * Delete the built-in #define's.
+   */
+  char **pp;
+
+
+  /*
+   * Delete the built-in symbols, unless -WW.
+   */
+  if (global->wflag < 2) {
+    for (pp = global->preset; *pp != NULL; pp++) {
+      defendel(global, *pp, TRUE);
+    }
+  }
+  /*
+   * The magic pre-defines __FILE__ and __LINE__
+   */
+  for (pp = global->magic; *pp != NULL; pp++) {
+    defendel(global, *pp, TRUE);
+  }
+#if OK_DATE
+  /*
+   * Undefine __DATE__.
+   */
+  defendel(global, "__DATE__", TRUE);
+
+  /*
+   * Undefine __TIME__.
+   */
+  defendel(global, "__TIME__", TRUE);
+#endif
+  return;
+}
+

3rdparty/bgfx/3rdparty/fcpp/cpp4.c

@@ -0,0 +1,633 @@
+/******************************************************************************
+Copyright (c) 1999 Daniel Stenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+#include	<stdio.h>
+#include	<ctype.h>
+#include	"cppdef.h"
+#include	"cpp.h"
+
+INLINE FILE_LOCAL ReturnCode checkparm(struct Global *, int, DEFBUF *, int);
+INLINE FILE_LOCAL ReturnCode stparmscan(struct Global *, int);
+INLINE FILE_LOCAL ReturnCode textput(struct Global *, char *);
+FILE_LOCAL ReturnCode charput(struct Global *, int);
+INLINE FILE_LOCAL ReturnCode expcollect(struct Global *);
+INLINE FILE_LOCAL char *doquoting(char *, char *);
+
+
+ReturnCode dodefine(struct Global *global)
+{
+  /*
+   * Called from control when a #define is scanned.  This module
+   * parses formal parameters and the replacement string.  When
+   * the formal parameter name is encountered in the replacement
+   * string, it is replaced by a character in the range 128 to
+   * 128+NPARAM (this allows up to 32 parameters within the
+   * Dec Multinational range).  If cpp is ported to an EBCDIC
+   * machine, you will have to make other arrangements.
+   *
+   * There is some special case code to distinguish
+   *	#define foo	bar
+   * from #define foo()   bar
+   *
+   * Also, we make sure that
+   *	#define foo	foo
+   * expands to "foo" but doesn't put cpp into an infinite loop.
+   *
+   * A warning message is printed if you redefine a symbol to a
+   * different text.  I.e,
+   *	#define foo	123
+   *	#define foo	123
+   * is ok, but
+   *	#define foo	123
+   *	#define foo	+123
+   * is not.
+   *
+   * The following subroutines are called from define():
+   * checkparm	called when a token is scanned.  It checks through the
+   *		array of formal parameters.  If a match is found, the
+   *		token is replaced by a control byte which will be used
+   *		to locate the parameter when the macro is expanded.
+   * textput	puts a string in the macro work area (parm[]), updating
+   *		parmp to point to the first free byte in parm[].
+   *		textput() tests for work buffer overflow.
+   * charput	puts a single character in the macro work area (parm[])
+   *		in a manner analogous to textput().
+   */
+  int c;
+  DEFBUF *dp;	/* -> new definition	*/
+  int isredefine;	/* TRUE if redefined	*/
+  char *old = NULL;		/* Remember redefined	*/
+  ReturnCode ret;
+#if OK_CONCAT
+  int quoting;	/* Remember we saw a #	*/
+#endif
+  
+  if (type[(c = skipws(global))] != LET) {
+    cerror(global, ERROR_DEFINE_SYNTAX);
+    global->inmacro = FALSE;		/* Stop <newline> hack	*/
+    return(FPP_OK);
+  }
+  isredefine = FALSE;			/* Set if redefining	*/
+  if ((dp = lookid(global, c)) == NULL) { /* If not known now     */
+    dp = defendel(global, global->tokenbuf, FALSE); /* Save the name  */
+    if(!dp)
+      return(FPP_OUT_OF_MEMORY);
+  } else {				/* It's known:          */
+    isredefine = TRUE;			/* Remember this fact	*/
+    old = dp->repl;			/* Remember replacement */
+    dp->repl = NULL;			/* No replacement now	*/
+  }
+  global->parlist[0] = global->parmp = global->parm; /* Setup parm buffer */
+  if ((c = get(global)) == '(') {       /* With arguments?      */
+    global->nargs = 0;			/* Init formals counter */
+    do {				/* Collect formal parms */
+      if (global->nargs >= LASTPARM) {
+	cfatal(global, FATAL_TOO_MANY_ARGUMENTS_MACRO);
+	return(FPP_TOO_MANY_ARGUMENTS);
+      } else if ((c = skipws(global)) == ')')
+	break;			/* Got them all 	*/
+      else if (type[c] != LET) {         /* Bad formal syntax    */
+	cerror(global, ERROR_DEFINE_SYNTAX);
+	global->inmacro = FALSE;		/* Stop <newline> hack	*/
+	return(FPP_OK);
+      }
+      scanid(global, c);                        /* Get the formal param */
+      global->parlist[global->nargs++] = global->parmp; /* Save its start */
+      ret=textput(global, global->tokenbuf); /* Save text in parm[]  */
+      if(ret)
+	return(ret);
+    } while ((c = skipws(global)) == ',');    /* Get another argument */
+    if (c != ')') {                     /* Must end at )        */
+      cerror(global, ERROR_DEFINE_SYNTAX);
+      global->inmacro = FALSE;		/* Stop <newline> hack	*/
+      return(FPP_OK);
+    }
+    c = ' ';                            /* Will skip to body    */
+  }
+  else {
+    /*
+     * DEF_NOARGS is needed to distinguish between
+     * "#define foo" and "#define foo()".
+     */
+    global->nargs = DEF_NOARGS;         /* No () parameters     */
+  }
+  if (type[c] == SPA)                   /* At whitespace?       */
+    c = skipws(global);                 /* Not any more.        */
+  global->workp = global->work;         /* Replacement put here */
+  global->inmacro = TRUE;               /* Keep \<newline> now	*/
+  quoting = 0;                          /* No # seen yet.	*/
+  while (c != EOF_CHAR && c != '\n') {  /* Compile macro body   */
+#if OK_CONCAT
+    if (c == '#') {                     /* Token concatenation? */
+      if ((c = get(global)) != '#') {   /* No, not really       */
+        quoting = 1;                    /* Maybe quoting op.    */
+        continue;
+      }
+      while (global->workp > global->work && type[(unsigned)*(global->workp - 1)] == SPA)
+        --global->workp;                /* Erase leading spaces */
+//       if ((ret=save(global, TOK_SEP)))  /* Stuff a delimiter    */
+//         return(ret);
+      c = skipws(global);               /* Eat whitespace       */
+      continue;
+    }
+#endif
+    switch (type[c]) {
+    case LET:
+#if OK_CONCAT
+      ret=checkparm(global, c, dp, quoting);      /* Might be a formal    */
+#else
+      ret=checkparm(c, dp);               /* Might be a formal    */
+#endif
+      if(ret)
+	return(ret);
+      break;
+	
+    case DIG:				/* Number in mac. body	*/
+    case DOT:				/* Maybe a float number */
+      ret=scannumber(global, c, save);  /* Scan it off          */
+      if(ret)
+	return(ret);
+      break;
+	
+    case QUO:				/* String in mac. body	*/
+      ret=stparmscan(global, c);
+      if(ret)
+	return(ret);
+      break;
+	
+    case BSH:				/* Backslash		*/
+      ret=save(global, '\\');
+      if(ret)
+	return(ret);
+      if ((c = get(global)) == '\n')
+	global->wrongline = TRUE;
+      ret=save(global, c);
+      if(ret)
+	return(ret);
+      break;
+      
+    case SPA:				/* Absorb whitespace	*/
+      /*
+       * Note: the "end of comment" marker is passed on
+       * to allow comments to separate tokens.
+       */
+      if (global->workp[-1] == ' ')   /* Absorb multiple      */
+	break;			/* spaces		*/
+      else if (c == '\t')
+	c = ' ';                      /* Normalize tabs       */
+      /* Fall through to store character			*/
+    default:				/* Other character	*/
+      ret=save(global, c);
+      if(ret)
+	return(ret);
+      break;
+    }
+    c = get(global);
+    quoting = 0;			/* Only when immediately*/
+    /* preceding a formal	*/
+  }
+  global->inmacro = FALSE;		/* Stop newline hack	*/
+  unget(global);                            /* For control check    */
+  if (global->workp > global->work && global->workp[-1] == ' ') /* Drop trailing blank  */
+    global->workp--;
+  *global->workp = EOS;		/* Terminate work	*/
+  dp->repl = savestring(global, global->work); /* Save the string      */
+  dp->nargs = global->nargs;			/* Save arg count	*/
+  if (isredefine) {                   /* Error if redefined   */
+    if ((old != NULL && dp->repl != NULL && !streq(old, dp->repl))
+	|| (old == NULL && dp->repl != NULL)
+	|| (old != NULL && dp->repl == NULL)) {
+      cerror(global, ERROR_REDEFINE, dp->name);
+    }
+    if (old != NULL)                  /* We don't need the    */
+      free(old);                      /* old definition now.  */
+  }
+  return(FPP_OK);
+}
+
+INLINE FILE_LOCAL
+ReturnCode checkparm(struct Global *global,
+		     int c,
+		     DEFBUF *dp,
+		     int quoting)	/* Preceded by a # ?	*/
+{
+  /*
+   * Replace this param if it's defined.  Note that the macro name is a
+   * possible replacement token. We stuff DEF_MAGIC in front of the token
+   * which is treated as a LETTER by the token scanner and eaten by
+   * the output routine. This prevents the macro expander from
+   * looping if someone writes "#define foo foo".
+   */
+  
+  int i;
+  char *cp;
+  ReturnCode ret=FPP_OK;
+      
+  scanid(global, c);                /* Get parm to tokenbuf */
+  for (i = 0; i < global->nargs; i++) {     /* For each argument    */
+    if (streq(global->parlist[i], global->tokenbuf)) {  /* If it's known */
+#if OK_CONCAT
+      if (quoting) {                    /* Special handling of  */
+	ret=save(global, QUOTE_PARM);     /* #formal inside defn  */
+	if(ret)
+	  return(ret);
+      }
+#endif
+      ret=save(global, i + MAC_PARM);     /* Save a magic cookie  */
+      return(ret);		      /* And exit the search	*/
+    }
+  }
+  if (streq(dp->name, global->tokenbuf))    /* Macro name in body?  */
+    ret=save(global, DEF_MAGIC);            /* Save magic marker    */
+  for (cp = global->tokenbuf; *cp != EOS;)  /* And save             */
+    ret=save(global, *cp++);                /* The token itself     */
+  return(ret);
+}
+
+INLINE FILE_LOCAL
+ReturnCode stparmscan(struct Global *global, int delim)
+{
+  /*
+   * Normal string parameter scan.
+   */
+  
+  unsigned char	*wp;
+  int i;
+  ReturnCode ret;
+      
+  wp = (unsigned char *)global->workp;	/* Here's where it starts       */
+  ret=scanstring(global, delim, save);
+  if(ret)
+    return(ret);		/* Exit on scanstring error	*/
+  global->workp[-1] = EOS;		/* Erase trailing quote 	*/
+  wp++;				/* -> first string content byte */
+  for (i = 0; i < global->nargs; i++) {
+    if (streq(global->parlist[i], (char *)wp)) {
+      *wp++ = MAC_PARM + PAR_MAC;	/* Stuff a magic marker */
+      *wp++ = (i + MAC_PARM);         /* Make a formal marker */
+      *wp = wp[-3];			/* Add on closing quote */
+      global->workp = (char *)wp + 1; 	/* Reset string end	*/
+      return(FPP_OK);
+    }
+  }
+  global->workp[-1] = wp[-1];	/* Nope, reset end quote.	*/
+  return(FPP_OK);
+}
+  
+void doundef(struct Global *global)
+  /*
+   * Remove the symbol from the defined list.
+   * Called from the #control processor.
+   */
+{
+  int c;
+  if (type[(c = skipws(global))] != LET)
+    cerror(global, ERROR_ILLEGAL_UNDEF);
+  else {
+    scanid(global, c);                         /* Get name to tokenbuf */
+    (void) defendel(global, global->tokenbuf, TRUE);
+  }
+}
+
+INLINE FILE_LOCAL  
+ReturnCode textput(struct Global *global, char *text)
+{
+  /*
+   * Put the string in the parm[] buffer.
+   */
+
+  size_t size;
+  
+  size = strlen(text) + 1;
+  if ((global->parmp + size) >= &global->parm[NPARMWORK]) {
+    cfatal(global, FATAL_MACRO_AREA_OVERFLOW);
+    return(FPP_WORK_AREA_OVERFLOW);
+  } else {
+    strcpy(global->parmp, text);
+    global->parmp += size;
+  }
+  return(FPP_OK);
+}
+
+FILE_LOCAL
+ReturnCode charput(struct Global *global, int c)
+{
+  /*
+   * Put the byte in the parm[] buffer.
+   */
+  
+  if (global->parmp >= &global->parm[NPARMWORK]) {
+    cfatal(global, FATAL_MACRO_AREA_OVERFLOW);
+    return(FPP_WORK_AREA_OVERFLOW);
+  }
+  *global->parmp++ = c;
+  return(FPP_OK);
+}
+
+/*
+ *		M a c r o   E x p a n s i o n
+ */
+
+ReturnCode expand(struct Global *global, DEFBUF *tokenp)
+{
+  /*
+   * Expand a macro.  Called from the cpp mainline routine (via subroutine
+   * macroid()) when a token is found in the symbol table.  It calls
+   * expcollect() to parse actual parameters, checking for the correct number.
+   * It then creates a "file" containing a single line containing the
+   * macro with actual parameters inserted appropriately.  This is
+   * "pushed back" onto the input stream.  (When the get() routine runs
+   * off the end of the macro line, it will dismiss the macro itself.)
+   */
+  int c;
+  FILEINFO *file;
+  ReturnCode ret=FPP_OK;
+      
+  /*
+   * If no macro is pending, save the name of this macro
+   * for an eventual error message.
+   */
+  if (global->recursion++ == 0)
+    global->macro = tokenp;
+  else if (global->recursion == RECURSION_LIMIT) {
+    cerror(global, ERROR_RECURSIVE_MACRO, tokenp->name, global->macro->name);
+    if (global->rec_recover) {
+      do {
+	c = get(global);
+      } while (global->infile != NULL && global->infile->fp == NULL);
+      unget(global);
+      global->recursion = 0;
+      return(FPP_OK);
+    }
+  }
+  /*
+   * Here's a macro to expand.
+   */
+  global->nargs = 0;			/* Formals counter	*/
+  global->parmp = global->parm;		/* Setup parm buffer	*/
+  switch (tokenp->nargs) {
+  case (-2):                              /* __LINE__             */
+      if(global->infile->fp)
+	  /* This is a file */
+	  sprintf(global->work, "%d", global->line);
+      else
+	  /* This is a macro! Find out the file line number! */
+	  for (file = global->infile; file != NULL; file = file->parent) {
+	      if (file->fp != NULL) {
+		  sprintf(global->work, "%d", file->line);
+		  break;
+	      }
+	  }
+      ret=ungetstring(global, global->work);
+      if(ret)
+	  return(ret);
+      break;
+    
+  case (-3):                              /* __FILE__             */
+    for (file = global->infile; file != NULL; file = file->parent) {
+      if (file->fp != NULL) {
+	sprintf(global->work, "\"%s\"", (file->progname != NULL)
+		? file->progname : file->filename);
+	ret=ungetstring(global, global->work);
+	if(ret)
+	  return(ret);
+	break;
+      }
+    }
+    break;
+
+  case (-4):				/* __FUNC__ */
+    sprintf(global->work, "\"%s\"", global->functionname[0]?
+	    global->functionname : "<unknown function>");
+    ret=ungetstring(global, global->work);
+    if(ret)
+	return(ret);
+    break;
+
+  case (-5):                              /* __FUNC_LINE__ */
+    sprintf(global->work, "%d", global->funcline);
+    ret=ungetstring(global, global->work);
+    if(ret)
+      return(ret);
+    break;
+
+  default:
+    /*
+     * Nothing funny about this macro.
+     */
+    if (tokenp->nargs < 0) {
+      cfatal(global, FATAL_ILLEGAL_MACRO, tokenp->name);
+      return(FPP_ILLEGAL_MACRO);
+    }
+    while ((c = skipws(global)) == '\n')      /* Look for (, skipping */
+      global->wrongline = TRUE;		/* spaces and newlines	*/
+    if (c != '(') {
+      /*
+       * If the programmer writes
+       *	#define foo() ...
+       *	...
+       *	foo [no ()]
+       * just write foo to the output stream.
+       */
+      unget(global);
+      cwarn(global, WARN_MACRO_NEEDS_ARGUMENTS, tokenp->name);
+
+      /* fputs(tokenp->name, stdout); */
+      Putstring(global, tokenp->name);
+      return(FPP_OK);
+    } else if (!(ret=expcollect(global))) {     /* Collect arguments    */
+      if (tokenp->nargs != global->nargs) {     /* Should be an error?  */
+	cwarn(global, WARN_WRONG_NUMBER_ARGUMENTS, tokenp->name);
+      }
+    } else {				/* Collect arguments		*/
+      return(ret); /* We failed in argument colleting! */
+    }
+  case DEF_NOARGS:			/* No parameters just stuffs	*/
+    ret=expstuff(global, tokenp->name, tokenp->repl); /* expand macro   */
+  }					/* nargs switch 		*/
+  return(ret);
+}
+
+INLINE FILE_LOCAL
+ReturnCode expcollect(struct Global *global)
+{
+  /*
+   * Collect the actual parameters for this macro.
+   */
+
+  int c;
+  int paren;		    /* For embedded ()'s    */
+  ReturnCode ret;
+      
+  for (;;) {
+    paren = 0;			    /* Collect next arg.    */
+    while ((c = skipws(global)) == '\n')/* Skip over whitespace */
+      global->wrongline = TRUE;		/* and newlines.	*/
+    if (c == ')') {                     /* At end of all args?  */
+      /*
+       * Note that there is a guard byte in parm[]
+       * so we don't have to check for overflow here.
+       */
+      *global->parmp = EOS;	    /* Make sure terminated */
+      break;			    /* Exit collection loop */
+    }
+    else if (global->nargs >= LASTPARM) {
+      cfatal(global, FATAL_TOO_MANY_ARGUMENTS_EXPANSION);
+      return(FPP_TOO_MANY_ARGUMENTS);
+    }
+    global->parlist[global->nargs++] = global->parmp; /* At start of new arg */
+    for (;; c = cget(global)) {               /* Collect arg's bytes  */
+      if (c == EOF_CHAR) {
+	cerror(global, ERROR_EOF_IN_ARGUMENT);
+	return(FPP_EOF_IN_MACRO); /* Sorry.               */
+      }
+      else if (c == '\\') {             /* Quote next character */
+	charput(global, c);             /* Save the \ for later */
+	charput(global, cget(global));  /* Save the next char.  */
+	continue;			/* And go get another   */
+      }
+      else if (type[c] == QUO) {        /* Start of string?     */
+	ret=scanstring(global, c, (ReturnCode (*)(struct Global *, int))charput); /* Scan it off    */
+	if(ret)
+	  return(ret);
+	continue;			    /* Go get next char     */
+      }
+      else if (c == '(')                /* Worry about balance  */
+	paren++;			/* To know about commas */
+      else if (c == ')') {              /* Other side too       */
+	if (paren == 0) {               /* At the end?          */
+	  unget(global);                /* Look at it later     */
+	  break;			/* Exit arg getter.     */
+	}
+	paren--;			/* More to come.        */
+      }
+      else if (c == ',' && paren == 0)  /* Comma delimits args  */
+	break;
+      else if (c == '\n')               /* Newline inside arg?  */
+	global->wrongline = TRUE;	/* We'll need a #line   */
+      charput(global, c);               /* Store this one       */
+    }				        /* Collect an argument  */
+    charput(global, EOS);               /* Terminate argument   */
+  }				        /* Collect all args.    */
+  return(FPP_OK);                       /* Normal return        */
+}
+  
+  
+#if OK_CONCAT
+  
+INLINE FILE_LOCAL
+char *doquoting(char *to, char *from)
+{
+  *to++ = '"';
+  while (*from) {
+    if (*from == '\\' || *from == '"')
+      *to++ = '\\';
+    *to++ = *from++;
+  }
+  *to++ = '"';
+      
+  return to;
+}
+  
+#endif
+  
+ReturnCode expstuff(struct Global *global,
+		    char *MacroName,
+		    char *MacroReplace)
+{
+  /*
+   * Stuff the macro body, replacing formal parameters by actual parameters.
+   */
+  int c;		/* Current character	*/
+  char *inp;		/* -> repl string	*/
+  char *defp;		/* -> macro output buff */
+  size_t size;		/* Actual parm. size	*/
+  char *defend;		/* -> output buff end	*/
+  int string_magic;	/* String formal hack	*/
+  FILEINFO *file;	/* Funny #include	*/
+  ReturnCode ret;
+#if OK_CONCAT
+  char quoting;	/* Quote macro argument */
+#endif
+      
+  ret = getfile(global, NBUFF, MacroName, &file);
+  if(ret)
+    return(ret);
+  inp = MacroReplace;			/* -> macro replacement */
+  defp = file->buffer;			/* -> output buffer	*/
+  defend = defp + (NBUFF - 1);              /* Note its end         */
+  if (inp != NULL) {
+    quoting = 0;
+    while ((c = (*inp++ & 0xFF)) != EOS) {
+#if OK_CONCAT
+      if (c == QUOTE_PARM) {                /* Special token for #  */
+	quoting = 1;			/* set flag, for later	*/
+	continue;				/* Get next character	*/
+      }
+#endif
+      if (c >= MAC_PARM && c <= (MAC_PARM + PAR_MAC)) {
+	string_magic = (c == (MAC_PARM + PAR_MAC));
+	if (string_magic)
+	  c = (*inp++ & 0xFF);
+	/*
+	 * Replace formal parameter by actual parameter string.
+	 */
+	if ((c -= MAC_PARM) < global->nargs) {
+	  size = strlen(global->parlist[c]);
+#if OK_CONCAT
+	  if (quoting) {
+	    size++;
+	    size *= 2;		/* worst case condition */
+	  }
+#endif
+	  if ((defp + size) >= defend) {
+	    cfatal(global, FATAL_OUT_OF_SPACE_IN_ARGUMENT, MacroName);
+	    return(FPP_OUT_OF_SPACE_IN_MACRO_EXPANSION);
+	  }
+	  /*
+	   * Erase the extra set of quotes.
+	   */
+	  if (string_magic && defp[-1] == global->parlist[c][0]) {
+	    strcpy(defp-1, global->parlist[c]);
+	    defp += (size - 2);
+	  }
+#if OK_CONCAT
+else if (quoting)
+  defp = doquoting(defp, global->parlist[c]);
+#endif
+else {
+  strcpy(defp, global->parlist[c]);
+  defp += size;
+}
+	}
+      }
+      else if (defp >= defend) {
+	cfatal(global, FATAL_OUT_OF_SPACE_IN_ARGUMENT, MacroName);
+	return(FPP_OUT_OF_SPACE_IN_MACRO_EXPANSION);
+      } else
+	*defp++ = c;
+      quoting = 0;
+    }
+  }
+  *defp = EOS;
+  return(FPP_OK);
+}
+

3rdparty/bgfx/3rdparty/fcpp/cpp5.c

@@ -0,0 +1,903 @@
+/******************************************************************************
+Copyright (c) 1999 Daniel Stenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+#include <stdio.h>
+#include <ctype.h>
+#include "cppdef.h"
+#include "cpp.h"
+
+INLINE FILE_LOCAL ReturnCode evallex(struct Global *, int, int *);
+INLINE FILE_LOCAL ReturnCode dosizeof(struct Global *, int *);
+INLINE FILE_LOCAL int bittest(int);
+INLINE FILE_LOCAL int evalnum(struct Global *, int);
+INLINE FILE_LOCAL int evalchar(struct Global *, int);
+INLINE FILE_LOCAL int *evaleval(struct Global *, int *, int, int);
+
+/*
+ * Evaluate an #if expression.
+ */
+
+static char *opname[] = {		/* For debug and error messages */
+  "end of expression", "val", "id",
+  "+",   "-",  "*",  "/",  "%",
+  "<<", ">>",  "&",  "|",  "^",
+  "==", "!=",  "<", "<=", ">=",  ">",
+  "&&", "||",  "?",  ":",  ",",
+  "unary +", "unary -", "~", "!",  "(",  ")", "(none)",
+};
+
+/*
+ * opdope[] has the operator precedence:
+ *     Bits
+ *	  7	Unused (so the value is always positive)
+ *	6-2	Precedence (000x .. 017x)
+ *	1-0	Binary op. flags:
+ *	    01	The binop flag should be set/cleared when this op is seen.
+ *	    10	The new value of the binop flag.
+ * Note:  Expected, New binop
+ * constant	0	1	Binop, end, or ) should follow constants
+ * End of line	1	0	End may not be preceeded by an operator
+ * binary	1	0	Binary op follows a value, value follows.
+ * unary	0	0	Unary op doesn't follow a value, value follows
+ *   (          0       0       Doesn't follow value, value or unop follows
+ *   )		1	1	Follows value.	Op follows.
+ */
+
+static char opdope[OP_MAX] = {
+  0001, 				/* End of expression		*/
+  0002, 				/* Digit			*/
+  0000, 				/* Letter (identifier)          */
+  0141, 0141, 0151, 0151, 0151, 	/* ADD, SUB, MUL, DIV, MOD	*/
+  0131, 0131, 0101, 0071, 0071, 	/* ASL, ASR, AND,  OR, XOR	*/
+  0111, 0111, 0121, 0121, 0121, 0121,	/*  EQ,  NE,  LT,  LE,	GE,  GT */
+  0061, 0051, 0041, 0041, 0031, 	/* ANA, ORO, QUE, COL, CMA	*/
+  /*
+   * Unary op's follow
+   */
+  0160, 0160, 0160, 0160,		/* NEG, PLU, COM, NOT		*/
+  0170, 0013, 0023,			/* LPA, RPA, END		*/
+};
+/*
+ * OP_QUE and OP_RPA have alternate precedences:
+ */
+#define OP_RPA_PREC	0013
+#define OP_QUE_PREC	0034
+
+/*
+ * S_ANDOR and S_QUEST signal "short-circuit" boolean evaluation, so that
+ *	#if FOO != 0 && 10 / FOO ...
+ * doesn't generate an error message.  They are stored in optab.skip.
+ */
+#define S_ANDOR 	2
+#define S_QUEST 	1
+
+typedef struct optab {
+  char	op;			/* Operator			*/
+  char	prec;			/* Its precedence		*/
+  char	skip;			/* Short-circuit: TRUE to skip	*/
+} OPTAB;
+     
+#ifdef	nomacargs
+     FILE_LOCAL int
+       isbinary(op)
+     int op;
+{
+  return (op >= FIRST_BINOP && op <= LAST_BINOP);
+}
+
+FILE_LOCAL int
+  isunary(op)
+int op;
+{
+  return (op >= FIRST_UNOP && op <= LAST_UNOP);
+}
+#else
+#define isbinary(op)    (op >= FIRST_BINOP && op <= LAST_BINOP)
+#define isunary(op)     (op >= FIRST_UNOP  && op <= LAST_UNOP)
+#endif
+
+/*
+ * The following definitions are used to specify basic variable sizes.
+ */
+
+#if OK_SIZEOF
+
+#ifndef S_CHAR
+#define S_CHAR		(sizeof (char))
+#endif
+#ifndef S_SINT
+#ifdef manx		/* Aztec/Manx C does not like "short int" */
+#define S_SINT		(sizeof (short))
+#else
+#define S_SINT		(sizeof (short int))
+#endif
+#endif
+#ifndef S_INT
+#define S_INT		(sizeof (int))
+#endif
+#ifndef S_LINT
+#define S_LINT		(sizeof (long int))
+#endif
+#ifndef S_FLOAT
+#define S_FLOAT 	(sizeof (float))
+#endif
+#ifndef S_DOUBLE
+#define S_DOUBLE	(sizeof (double))
+#endif
+#ifndef S_PCHAR
+#define S_PCHAR 	(sizeof (char *))
+#endif
+#ifndef S_PSINT
+#ifdef manx		/* Aztec/Manx C does not like "short int" */
+#define S_PSINT 	(sizeof (short *))
+#else
+#define S_PSINT 	(sizeof (short int *))
+#endif
+#endif
+#ifndef S_PINT
+#define S_PINT		(sizeof (int *))
+#endif
+#ifndef S_PLINT
+#define S_PLINT 	(sizeof (long int *))
+#endif
+#ifndef S_PFLOAT
+#define S_PFLOAT	(sizeof (float *))
+#endif
+#ifndef S_PDOUBLE
+#define S_PDOUBLE	(sizeof (double *))
+#endif
+#ifndef S_PFPTR
+#define S_PFPTR 	(sizeof (int (*)()))
+#endif
+
+
+typedef struct types {
+  short	type;			/* This is the bit if		*/
+  char	*name;			/* this is the token word	*/
+} TYPES;
+
+static TYPES basic_types[] = {
+  { T_CHAR,	"char",         },
+  { T_INT,	"int",          },
+  { T_FLOAT,	"float",        },
+  { T_DOUBLE,	"double",       },
+  { T_SHORT,	"short",        },
+  { T_LONG,	"long",         },
+  { T_SIGNED,	"signed",       },
+  { T_UNSIGNED,	"unsigned",     },
+  { 0,		NULL,		},	/* Signal end		*/
+};
+
+/*
+ * Test_table[] is used to test for illegal combinations.
+ */
+static short test_table[] = {
+  T_FLOAT | T_DOUBLE | T_LONG | T_SHORT,
+  T_FLOAT | T_DOUBLE | T_CHAR | T_INT,
+  T_FLOAT | T_DOUBLE | T_SIGNED | T_UNSIGNED,
+  T_LONG  | T_SHORT  | T_CHAR,
+  0						/* end marker	*/
+  };
+
+/*
+ * The order of this table is important -- it is also referenced by
+ * the command line processor to allow run-time overriding of the
+ * built-in size values.  The order must not be changed:
+ *	char, short, int, long, float, double (func pointer)
+ */
+SIZES size_table[] = {
+  { T_CHAR,	S_CHAR, 	S_PCHAR 	},	/* char 	*/
+  { T_SHORT,	S_SINT, 	S_PSINT 	},	/* short int	*/
+  { T_INT,	S_INT,		S_PINT		},	/* int		*/
+  { T_LONG,	S_LINT, 	S_PLINT 	},	/* long 	*/
+  { T_FLOAT,	S_FLOAT,	S_PFLOAT	},	/* float	*/
+  { T_DOUBLE,	S_DOUBLE,	S_PDOUBLE	},	/* double	*/
+  { T_FPTR,	0,		S_PFPTR 	},	/* int (*())    */
+  { 0,		0,		0		},	/* End of table */
+};
+
+#endif /* OK_SIZEOF */
+
+ReturnCode eval(struct Global *global, int *eval)
+{
+  /*
+   * Evaluate an expression.  Straight-forward operator precedence.
+   * This is called from control() on encountering an #if statement.
+   * It calls the following routines:
+   * evallex	Lexical analyser -- returns the type and value of
+   *		the next input token.
+   * evaleval	Evaluate the current operator, given the values on
+   *		the value stack.  Returns a pointer to the (new)
+   *		value stack.
+   * For compatiblity with older cpp's, this return returns 1 (TRUE)
+   * if a syntax error is detected.
+   */
+  int op;		/* Current operator		*/
+  int *valp;		/* -> value vector		*/
+  OPTAB *opp;		/* Operator stack		*/
+  int prec;		/* Op precedence		*/
+  int binop;		/* Set if binary op. needed	*/
+  int op1;		/* Operand from stack		*/
+  int skip;		/* For short-circuit testing	*/
+  int value[NEXP];	/* Value stack			*/
+  OPTAB opstack[NEXP];	/* Operand stack		*/
+  ReturnCode ret;
+  char again=TRUE;
+  
+  valp = value;
+  opp = opstack;
+  opp->op = OP_END;		/* Mark bottom of stack 	*/
+  opp->prec = opdope[OP_END];	/* And its precedence		*/
+  opp->skip = 0;		/* Not skipping now		*/
+  binop = 0;
+
+  while(again) {
+    ret=evallex(global, opp->skip, &op);
+    if(ret)
+      return(ret);
+    if (op == OP_SUB && binop == 0)
+      op = OP_NEG;			/* Unary minus		*/
+    else if (op == OP_ADD && binop == 0)
+      op = OP_PLU;			/* Unary plus		*/
+    else if (op == OP_FAIL) {
+      *eval=1;                    	/* Error in evallex     */
+      return(FPP_OK);
+    }
+    if (op == DIG) {                      /* Value?               */
+      if (binop != 0) {
+	cerror(global, ERROR_MISPLACED_CONSTANT);
+	*eval=1;
+	return(FPP_OK);
+      } else if (valp >= &value[NEXP-1]) {
+	cerror(global, ERROR_IF_OVERFLOW);
+	*eval=1;
+	return(FPP_OK);
+      } else {
+	*valp++ = global->evalue;
+	binop = 1;
+      }
+      again=TRUE;
+      continue;
+    } else if (op > OP_END) {
+      cerror(global, ERROR_ILLEGAL_IF_LINE);
+      *eval=1;
+      return(FPP_OK);
+    }
+    prec = opdope[op];
+    if (binop != (prec & 1)) {
+      cerror(global, ERROR_OPERATOR, opname[op]);
+      *eval=1;
+      return(FPP_OK);
+    }
+    binop = (prec & 2) >> 1;
+    do {
+      if (prec > opp->prec) {
+	if (op == OP_LPA)
+	  prec = OP_RPA_PREC;
+	else if (op == OP_QUE)
+	  prec = OP_QUE_PREC;
+	op1 = opp->skip;		/* Save skip for test	*/
+	/*
+	 * Push operator onto op. stack.
+	 */
+	opp++;
+	if (opp >= &opstack[NEXP]) {
+	  cerror(global, ERROR_EXPR_OVERFLOW, opname[op]);
+	  *eval=1;
+	  return(FPP_OK);
+	}
+	opp->op = op;
+	opp->prec = prec;
+	skip = (valp[-1] != 0);         /* Short-circuit tester */
+	/*
+	 * Do the short-circuit stuff here.  Short-circuiting
+	 * stops automagically when operators are evaluated.
+	 */
+	if ((op == OP_ANA && !skip)
+	    || (op == OP_ORO && skip))
+	  opp->skip = S_ANDOR;	/* And/or skip starts	*/
+	else if (op == OP_QUE)          /* Start of ?: operator */
+	  opp->skip = (op1 & S_ANDOR) | ((!skip) ? S_QUEST : 0);
+	else if (op == OP_COL) {        /* : inverts S_QUEST    */
+	  opp->skip = (op1 & S_ANDOR)
+	    | (((op1 & S_QUEST) != 0) ? 0 : S_QUEST);
+	}
+	else {				/* Other ops leave	*/
+	  opp->skip = op1;		/*  skipping unchanged. */
+	}
+	again=TRUE;
+	continue;
+      }
+      /*
+       * Pop operator from op. stack and evaluate it.
+       * End of stack and '(' are specials.
+       */
+      skip = opp->skip;			/* Remember skip value	*/
+      switch ((op1 = opp->op)) {          /* Look at stacked op   */
+      case OP_END:			/* Stack end marker	*/
+	if (op == OP_EOE) {
+	  *eval=valp[-1];     		/* Finished ok.         */
+	  return(FPP_OK);
+	}
+	/* Read another op.	*/
+	again=TRUE;
+	continue;
+      case OP_LPA:			/* ( on stack           */
+	if (op != OP_RPA) {             /* Matches ) on input   */
+	  cerror(global, ERROR_UNBALANCED_PARENS, opname[op]);
+	  *eval=1;
+	  return(FPP_OK);
+	}
+	opp--;				/* Unstack it		*/
+	/* -- Fall through 	*/
+      case OP_QUE:
+	/* Evaluate true expr.	*/
+	again=TRUE;
+	continue;
+      case OP_COL:			/* : on stack.		*/
+	opp--;				/* Unstack :		*/
+	if (opp->op != OP_QUE) {        /* Matches ? on stack?  */
+	  cerror(global, ERROR_MISPLACED, opname[(unsigned)opp->op]);
+	  *eval=1;
+	  return(FPP_OK);
+	}
+	/*
+	 * Evaluate op1.
+	 */
+      default:				/* Others:		*/
+	opp--;				/* Unstack the operator */
+	valp = evaleval(global, valp, op1, skip);
+	again=FALSE;
+      }					/* op1 switch end	*/
+    } while (!again);			/* Stack unwind loop	*/
+  }
+  return(FPP_OK);
+}
+
+INLINE FILE_LOCAL
+ReturnCode evallex(struct Global *global,
+		   int skip,	/* TRUE if short-circuit evaluation */
+		   int *op)
+{
+  /*
+   * Set *op to next eval operator or value. Called from eval(). It
+   * calls a special-purpose routines for 'char' strings and
+   * numeric values:
+   * evalchar	called to evaluate 'x'
+   * evalnum	called to evaluate numbers.
+   */
+
+  int c, c1, t;
+  ReturnCode ret;
+  char loop;
+  
+  do { /* while(loop); */
+  /* again: */
+    loop=FALSE;
+    do {					/* Collect the token	*/
+      c = skipws(global);
+      if((ret=macroid(global, &c)))
+      return(ret);
+      if (c == EOF_CHAR || c == '\n') {
+	unget(global);
+	*op=OP_EOE;           /* End of expression    */
+	return(FPP_OK);
+      }
+    } while ((t = type[c]) == LET && catenate(global, &ret) && !ret);
+    if(ret)
+      /* If the loop was broken because of a fatal error! */
+      return(ret);
+    if (t == INV) {                         /* Total nonsense       */
+      if (!skip) {
+	if (isascii(c) && isprint(c))
+	  cerror(global, ERROR_ILLEGAL_CHARACTER, c);
+	else
+	  cerror(global, ERROR_ILLEGAL_CHARACTER2, c);
+      }
+      return(FPP_ILLEGAL_CHARACTER);
+    } else if (t == QUO) {                  /* ' or "               */
+      if (c == '\'') {                    /* Character constant   */
+	global->evalue = evalchar(global, skip);  /* Somewhat messy       */
+	*op=DIG;                          /* Return a value       */
+	return(FPP_OK);
+      }
+      cerror(global, ERROR_STRING_IN_IF);
+      return(FPP_CANT_USE_STRING_IN_IF);
+    } else if (t == LET) {                  /* ID must be a macro   */
+      if (streq(global->tokenbuf, "defined")) {   /* Or defined name      */
+	c1 = c = skipws(global);
+	if (c == '(')                     /* Allow defined(name)  */
+	  c = skipws(global);
+	if (type[c] == LET) {
+	  global->evalue = (lookid(global, c) != NULL);
+	  if (c1 != '('                   /* Need to balance      */
+	      || skipws(global) == ')') { /* Did we balance?      */
+	    *op=DIG;
+	    return(FPP_OK);               /* Parsed ok            */
+	  }
+	}
+	cerror(global, ERROR_DEFINED_SYNTAX);
+	return(FPP_BAD_IF_DEFINED_SYNTAX);
+      }
+#if OK_SIZEOF
+else if (streq(global->tokenbuf, "sizeof")) { /* New sizeof hackery   */
+  ret=dosizeof(global, op);             /* Gets own routine     */
+  return(ret);
+}
+#endif
+      global->evalue = 0;
+      *op=DIG;
+      return(FPP_OK);
+    }
+    else if (t == DIG) {                  /* Numbers are harder   */
+      global->evalue = evalnum(global, c);
+    }
+    else if (strchr("!=<>&|\\", c) != NULL) {
+      /*
+       * Process a possible multi-byte lexeme.
+       */
+      c1 = cget(global);                        /* Peek at next char    */
+      switch (c) {
+      case '!':
+	if (c1 == '=') {
+	  *op=OP_NE;
+	  return(FPP_OK);
+	}
+	break;
+	
+      case '=':
+	if (c1 != '=') {                  /* Can't say a=b in #if */
+	  unget(global);
+	  cerror(global, ERROR_ILLEGAL_ASSIGN);
+	  return (FPP_IF_ERROR);
+	}
+	*op=OP_EQ;
+	return(FPP_OK);
+	
+      case '>':
+      case '<':
+	if (c1 == c) {
+	  *op= ((c == '<') ? OP_ASL : OP_ASR);
+	  return(FPP_OK);
+	} else if (c1 == '=') {
+	  *op= ((c == '<') ? OP_LE  : OP_GE);
+	  return(FPP_OK);
+	}
+	break;
+	
+      case '|':
+      case '&':
+	if (c1 == c) {
+	  *op= ((c == '|') ? OP_ORO : OP_ANA);
+	  return(FPP_OK);
+	}
+	break;
+      
+      case '\\':
+	if (c1 == '\n') {                  /* Multi-line if        */
+	  loop=TRUE;
+	  break;
+	}
+	cerror(global, ERROR_ILLEGAL_BACKSLASH);
+	return(FPP_IF_ERROR);
+      }
+      if(!loop)
+	unget(global);
+    }
+  } while(loop);
+  *op=t;
+  return(FPP_OK);
+}
+
+#if OK_SIZEOF
+
+INLINE FILE_LOCAL
+ReturnCode dosizeof(struct Global *global, int *result)
+{
+  /*
+   * Process the sizeof (basic type) operation in an #if string.
+   * Sets evalue to the size and returns
+   *	DIG		success
+   *	OP_FAIL 	bad parse or something.
+   */
+  int c;
+  TYPES *tp;
+  SIZES *sizp;
+  short *testp;
+  short typecode;
+  ReturnCode ret;
+  
+  if ((c = skipws(global)) != '(') {
+    unget(global);
+    cerror(global, ERROR_SIZEOF_SYNTAX);
+    return(FPP_SIZEOF_ERROR);
+  }
+  /*
+   * Scan off the tokens.
+   */
+  typecode = 0;
+  while ((c = skipws(global))) {
+    if((ret=macroid(global, &c)))
+      return(ret);
+    /* (I) return on fail! */
+    if (c  == EOF_CHAR || c == '\n') {
+      /* End of line is a bug */
+      unget(global);
+      cerror(global, ERROR_SIZEOF_SYNTAX);
+      return(FPP_SIZEOF_ERROR);
+    } else if (c == '(') {                /* thing (*)() func ptr */
+      if (skipws(global) == '*'
+	  && skipws(global) == ')') {         /* We found (*)         */
+	if (skipws(global) != '(')            /* Let () be optional   */
+	  unget(global);
+	else if (skipws(global) != ')') {
+	  unget(global);
+	  cerror(global, ERROR_SIZEOF_SYNTAX);
+	  return(FPP_SIZEOF_ERROR);
+	}
+	typecode |= T_FPTR; 		/* Function pointer	*/
+      } else {				/* Junk is a bug	*/
+	unget(global);
+	cerror(global, ERROR_SIZEOF_SYNTAX);
+	return(FPP_SIZEOF_ERROR);
+      }
+    }
+    else if (type[c] != LET)            /* Exit if not a type   */
+      break;
+    else if (!catenate(global, &ret) && !ret) { /* Maybe combine tokens */
+      /*
+       * Look for this unexpandable token in basic_types.
+       * The code accepts "int long" as well as "long int"
+       * which is a minor bug as bugs go (and one shared with
+       * a lot of C compilers).
+       */
+      for (tp = basic_types; tp->name != NULLST; tp++) {
+	if (streq(global->tokenbuf, tp->name))
+	  break;
+      }
+      if (tp->name == NULLST) {
+	cerror(global, ERROR_SIZEOF_UNKNOWN, global->tokenbuf);
+	return(FPP_SIZEOF_ERROR);
+      }
+      typecode |= tp->type;		/* Or in the type bit	*/
+    } else if(ret)
+      return(ret);
+  }
+  /*
+   * We are at the end of the type scan.	Chew off '*' if necessary.
+   */
+  if (c == '*') {
+    typecode |= T_PTR;
+    c = skipws(global);
+  }
+  if (c == ')') {                         /* Last syntax check    */
+    for (testp = test_table; *testp != 0; testp++) {
+      if (!bittest(typecode & *testp)) {
+	cerror(global, ERROR_SIZEOF_ILLEGAL_TYPE);
+	return(FPP_SIZEOF_ERROR);
+      }
+    }
+    /*
+     * We assume that all function pointers are the same size:
+     *		sizeof (int (*)()) == sizeof (float (*)())
+     * We assume that signed and unsigned don't change the size:
+     *		sizeof (signed int) == (sizeof unsigned int)
+     */
+    if ((typecode & T_FPTR) != 0)       /* Function pointer     */
+      typecode = T_FPTR | T_PTR;
+    else {				/* Var or var * datum	*/
+      typecode &= ~(T_SIGNED | T_UNSIGNED);
+      if ((typecode & (T_SHORT | T_LONG)) != 0)
+	typecode &= ~T_INT;
+    }
+    if ((typecode & ~T_PTR) == 0) {
+      cerror(global, ERROR_SIZEOF_NO_TYPE);
+      return(FPP_SIZEOF_ERROR);
+    }
+    /*
+     * Exactly one bit (and possibly T_PTR) may be set.
+     */
+    for (sizp = size_table; sizp->bits != 0; sizp++) {
+      if ((typecode & ~T_PTR) == sizp->bits) {
+	global->evalue = ((typecode & T_PTR) != 0)
+	  ? sizp->psize : sizp->size;
+	*result=DIG;
+	return(FPP_OK);
+      }
+    }					/* We shouldn't fail    */
+    cerror(global, ERROR_SIZEOF_BUG, typecode);
+    return(FPP_SIZEOF_ERROR);
+  }
+  unget(global);
+  cerror(global, ERROR_SIZEOF_SYNTAX);
+  return(FPP_SIZEOF_ERROR);
+}
+
+INLINE FILE_LOCAL
+int bittest(int value)
+{
+  /*
+   * TRUE if value is zero or exactly one bit is set in value.
+   */
+
+#if (4096 & ~(-4096)) == 0
+  return ((value & ~(-value)) == 0);
+#else
+  /*
+   * Do it the hard way (for non 2's complement machines)
+   */
+  return (value == 0 || value ^ (value - 1) == (value * 2 - 1));
+#endif
+}
+
+#endif /* OK_SIZEOF */
+
+INLINE FILE_LOCAL
+int evalnum(struct Global *global, int c)
+{
+  /*
+   * Expand number for #if lexical analysis.  Note: evalnum recognizes
+   * the unsigned suffix, but only returns a signed int value.
+   */
+
+  int value;
+  int base;
+  int c1;
+  
+  if (c != '0')
+    base = 10;
+  else if ((c = cget(global)) == 'x' || c == 'X') {
+    base = 16;
+    c = cget(global);
+  }
+  else base = 8;
+  value = 0;
+  for (;;) {
+    c1 = c;
+    if (isascii(c) && isupper(c1))
+      c1 = tolower(c1);
+    if (c1 >= 'a')
+      c1 -= ('a' - 10);
+    else c1 -= '0';
+    if (c1 < 0 || c1 >= base)
+      break;
+    value *= base;
+    value += c1;
+    c = cget(global);
+  }
+  if (c == 'u' || c == 'U')       /* Unsigned nonsense            */
+    c = cget(global);
+  unget(global);
+  return (value);
+}
+
+INLINE FILE_LOCAL
+int evalchar(struct Global *global,
+	     int skip)		/* TRUE if short-circuit evaluation	*/
+     /*
+      * Get a character constant
+      */
+{
+  int c;
+  int value;
+  int count;
+  
+  global->instring = TRUE;
+  if ((c = cget(global)) == '\\') {
+    switch ((c = cget(global))) {
+    case 'a':                           /* New in Standard      */
+#if ('a' == '\a' || '\a' == ALERT)
+      value = ALERT;			/* Use predefined value */
+#else
+      value = '\a';                   /* Use compiler's value */
+#endif
+      break;
+      
+    case 'b':
+      value = '\b';
+      break;
+      
+    case 'f':
+      value = '\f';
+      break;
+      
+    case 'n':
+      value = '\n';
+      break;
+      
+    case 'r':
+      value = '\r';
+      break;
+      
+    case 't':
+      value = '\t';
+      break;
+      
+    case 'v':                           /* New in Standard      */
+#if ('v' == '\v' || '\v' == VT)
+      value = VT;			/* Use predefined value */
+#else
+      value = '\v';                   /* Use compiler's value */
+#endif
+      break;
+      
+    case 'x':                           /* '\xFF'               */
+      count = 3;
+      value = 0;
+      while ((((c = get(global)) >= '0' && c <= '9')
+	      || (c >= 'a' && c <= 'f')
+	      || (c >= 'A' && c <= 'F'))
+	     && (--count >= 0)) {
+	value *= 16;
+	value += (c <= '9') ? (c - '0') : ((c & 0xF) + 9);
+      }
+      unget(global);
+      break;
+      
+    default:
+      if (c >= '0' && c <= '7') {
+	count = 3;
+	value = 0;
+	while (c >= '0' && c <= '7' && --count >= 0) {
+	  value *= 8;
+	  value += (c - '0');
+	  c = get(global);
+	}
+	unget(global);
+      } else
+	value = c;
+      break;
+    }
+  } else if (c == '\'')
+    value = 0;
+  else value = c;
+  /*
+   * We warn on multi-byte constants and try to hack
+   * (big|little)endian machines.
+   */
+#if BIG_ENDIAN
+  count = 0;
+#endif
+  while ((c = get(global)) != '\'' && c != EOF_CHAR && c != '\n') {
+    if (!skip)
+      cwarn(global, WARN_MULTIBYTE_NOT_PORTABLE, c);
+#if BIG_ENDIAN
+    count += BITS_CHAR;
+    value += (c << count);
+#else
+    value <<= BITS_CHAR;
+    value += c;
+#endif
+  }
+  global->instring = FALSE;
+  return (value);
+}
+
+INLINE FILE_LOCAL
+int *evaleval(struct Global *global,
+	      int *valp,
+	      int op,
+	      int skip)		/* TRUE if short-circuit evaluation	*/
+{
+  /*
+   * Apply the argument operator to the data on the value stack.
+   * One or two values are popped from the value stack and the result
+   * is pushed onto the value stack.
+   *
+   * OP_COL is a special case.
+   *
+   * evaleval() returns the new pointer to the top of the value stack.
+   */
+  int v1, v2 = 0;
+  
+  if (isbinary(op))
+    v2 = *--valp;
+  v1 = *--valp;
+  switch (op) {
+  case OP_EOE:
+    break;
+  case OP_ADD:
+    v1 += v2;
+    break;
+  case OP_SUB:
+    v1 -= v2;
+    break;
+  case OP_MUL:
+    v1 *= v2;
+    break;
+  case OP_DIV:
+  case OP_MOD:
+    if (v2 == 0) {
+      if (!skip) {
+	cwarn(global, WARN_DIVISION_BY_ZERO,
+	      (op == OP_DIV) ? "divide" : "mod");
+      }
+      v1 = 0;
+    }
+    else if (op == OP_DIV)
+      v1 /= v2;
+    else
+      v1 %= v2;
+    break;
+  case OP_ASL:
+    v1 <<= v2;
+    break;
+  case OP_ASR:
+    v1 >>= v2;
+    break;
+  case OP_AND:
+    v1 &= v2;
+    break;
+  case OP_OR:
+    v1 |= v2;
+    break;
+  case OP_XOR:
+    v1 ^= v2;
+    break;
+  case OP_EQ:
+    v1 = (v1 == v2);
+    break;
+  case OP_NE:
+    v1 = (v1 != v2);
+    break;
+  case OP_LT:
+    v1 = (v1 < v2);
+    break;
+  case OP_LE:
+    v1 = (v1 <= v2);
+    break;
+  case OP_GE:
+    v1 = (v1 >= v2);
+    break;
+  case OP_GT:
+    v1 = (v1 > v2);
+    break;
+  case OP_ANA:
+    v1 = (v1 && v2);
+    break;
+  case OP_ORO:
+    v1 = (v1 || v2);
+    break;
+  case OP_COL:
+    /*
+     * v1 has the "true" value, v2 the "false" value.
+     * The top of the value stack has the test.
+     */
+    v1 = (*--valp) ? v1 : v2;
+    break;
+  case OP_NEG:
+    v1 = (-v1);
+    break;
+  case OP_PLU:
+    break;
+  case OP_COM:
+    v1 = ~v1;
+    break;
+  case OP_NOT:
+    v1 = !v1;
+    break;
+  default:
+    cerror(global, ERROR_IF_OPERAND, op);
+    v1 = 0;
+  }
+  *valp++ = v1;
+  return (valp);
+}

3rdparty/bgfx/3rdparty/fcpp/cppadd.h

@@ -0,0 +1,413 @@
+/******************************************************************************
+ *                               FREXXWARE
+ * ----------------------------------------------------------------------------
+ *
+ * Project: Frexx C Preprocessor
+ * $Source: /home/user/start/cpp/RCS/cppadd.h,v $
+ * $Revision: 1.5 $
+ * $Date: 1994/01/24 09:38:12 $
+ * $Author: start $
+ * $State: Exp $
+ * $Locker: start $
+ *
+ * ----------------------------------------------------------------------------
+ * $Log: cppadd.h,v $
+ * Revision 1.5  1994/01/24  09:38:12  start
+ * Added the 'rightconcat' in the global structure.
+ *
+ * Revision 1.4  1993/12/06  13:51:20  start
+ * A lot of new stuff (too much to mention)
+ *
+ * Revision 1.3  1993/11/29  14:01:13  start
+ * New features added
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.1  1993/11/03  09:15:59  start
+ * Initial revision
+ *
+ *
+ *****************************************************************************/
+/**********************************************************************
+ *
+ * cppadd.h
+ *
+ * Prototypes and structures added by Daniel Stenberg.
+ *
+ *******/
+
+#include <stdarg.h>
+#include "memory.h"
+
+struct Global {
+
+  /*
+   * Commonly used global variables:
+   * line       is the current input line number.
+   * wrongline  is set in many places when the actual output
+   *            line is out of sync with the numbering, e.g,
+   *            when expanding a macro with an embedded newline.
+   *
+   * tokenbuf   holds the last identifier scanned (which might
+   *            be a candidate for macro expansion).
+   * errors     is the running cpp error counter.
+   * infile     is the head of a linked list of input files (extended by
+   *            #include and macros being expanded).  infile always points
+   *            to the current file/macro.  infile->parent to the includer,
+   *            etc.  infile->fd is NULL if this input stream is a macro.
+   */
+  int           line;                   /* Current line number          */
+  int           wrongline;              /* Force #line to compiler      */
+  char          *tokenbuf;              /* Buffer for current input token */
+  char      *functionname;  /* Buffer for current function */
+  int       funcline;       /* Line number of current function */
+  int           tokenbsize;             /* Allocated size of tokenbuf,  */
+                                        /* not counting zero at end.    */
+  int           errors;                 /* cpp error counter            */
+  FILEINFO      *infile;                /* Current input file           */
+#if DEBUG
+  int           debug;                  /* TRUE if debugging now        */
+#endif
+  /*
+   * This counter is incremented when a macro expansion is initiated.
+   * If it exceeds a built-in value, the expansion stops -- this tests
+   * for a runaway condition:
+   *    #define X Y
+   *    #define Y X
+   *    X
+   * This can be disabled by falsifying rec_recover.  (Nothing does this
+   * currently: it is a hook for an eventual invocation flag.)
+   */
+  int           recursion;              /* Infinite recursion counter   */
+  int           rec_recover;            /* Unwind recursive macros      */
+
+  /*
+   * instring is set TRUE when a string is scanned.  It modifies the
+   * behavior of the "get next character" routine, causing all characters
+   * to be passed to the caller (except <DEF_MAGIC>).  Note especially that
+   * comments and \<newline> are not removed from the source.  (This
+   * prevents cpp output lines from being arbitrarily long).
+   *
+   * inmacro is set by #define -- it absorbs comments and converts
+   * form-feed and vertical-tab to space, but returns \<newline>
+   * to the caller.  Strictly speaking, this is a bug as \<newline>
+   * shouldn't delimit tokens, but we'll worry about that some other
+   * time -- it is more important to prevent infinitly long output lines.
+   *
+   * instring and inmarcor are parameters to the get() routine which
+   * were made global for speed.
+   */
+  int           instring;       /* TRUE if scanning string      */
+  int           inmacro;        /* TRUE if #defining a macro    */
+  
+  /*
+   * work[] and workp are used to store one piece of text in a temporay
+   * buffer.  To initialize storage, set workp = work.  To store one
+   * character, call save(c);  (This will fatally exit if there isn't
+   * room.)  To terminate the string, call save(EOS).  Note that
+   * the work buffer is used by several subroutines -- be sure your
+   * data won't be overwritten.  The extra byte in the allocation is
+   * needed for string formal replacement.
+   */
+  char          work[NWORK + 1];        /* Work buffer                  */
+  char          *workp;                 /* Work buffer pointer          */
+
+  /*
+   * keepcomments is set TRUE by the -C option.  If TRUE, comments
+   * are written directly to the output stream.  This is needed if
+   * the output from cpp is to be passed to lint (which uses commands
+   * embedded in comments).  cflag contains the permanent state of the
+   * -C flag.  keepcomments is always falsified when processing #control
+   * commands and when compilation is supressed by a false #if
+   *
+   * If eflag is set, CPP returns "success" even if non-fatal errors
+   * were detected.
+   *
+   * If nflag is non-zero, no symbols are predefined except __LINE__.
+   * __FILE__, and __DATE__.  If nflag > 1, absolutely no symbols
+   * are predefined.
+   */
+  char          keepcomments;   /* Write out comments flag      */
+  char          cflag;          /* -C option (keep comments)    */
+  char          eflag;          /* -E option (never fail)       */
+  char          nflag;          /* -N option (no predefines)    */
+  char          wflag;          /* -W option (write #defines)   */
+
+  /*
+   * ifstack[] holds information about nested #if's.  It is always
+   * accessed via *ifptr.  The information is as follows:
+   *    WAS_COMPILING   state of compiling flag at outer level.
+   *    ELSE_SEEN       set TRUE when #else seen to prevent 2nd #else.
+   *    TRUE_SEEN       set TRUE when #if or #elif succeeds
+   * ifstack[0] holds the compiling flag.  It is TRUE if compilation
+   * is currently enabled.  Note that this must be initialized TRUE.
+   */
+  char          ifstack[BLK_NEST];      /* #if information      */
+  char          *ifptr;                 /* -> current ifstack[] */
+
+  /*
+   * incdir[] stores the -i directories (and the system-specific
+   * #include <...> directories.
+   */
+  char  *incdir[NINCLUDE];              /* -i directories               */
+  char  **incend;                       /* -> free space in incdir[]    */
+
+  /*
+   * include[] stores the -X and -x files.
+   */
+  char  *include[NINCLUDE];
+  char  includeshow[NINCLUDE]; /* show it or not! */
+  char  included;
+
+  /*
+   * This is the table used to predefine target machine and operating
+   * system designators.        It may need hacking for specific circumstances.
+   * Note: it is not clear that this is part of the Ansi Standard.
+   * The -B option supresses preset definitions.
+   */
+  char  *preset[5];                     /* names defined at cpp start   */
+
+  /*
+   * The value of these predefined symbols must be recomputed whenever
+   * they are evaluated.        The order must not be changed.
+   */
+  char  *magic[5];                      /* Note: order is important     */
+
+  /*
+   * This is the variable saying if Cpp should remove C++ style comments from
+   * the output. Default is... TRUE, yes, pronto, do it!!!
+   */
+  
+  char cplusplus;
+
+  char *sharpfilename;
+
+
+  /*
+   * parm[], parmp, and parlist[] are used to store #define() argument
+   * lists.  nargs contains the actual number of parameters stored.
+   */
+  char  parm[NPARMWORK + 1];    /* define param work buffer     */
+  char  *parmp;                 /* Free space in parm           */
+  char  *parlist[LASTPARM];     /* -> start of each parameter   */
+  int   nargs;                  /* Parameters for this macro    */
+
+  DEFBUF *macro;                /* Catches start of infinite macro      */
+
+  DEFBUF *symtab[SBSIZE];       /* Symbol table queue headers   */
+
+  int evalue;                   /* Current value from evallex() */
+
+  void (*depends)(char *filename, void *); /* depends function */
+
+  char *(*input)(char *, int, void *);  /* Input function */
+
+  char *first_file;             /* Preprocessed file. */
+
+  void *userdata;               /* Data sent to input function */
+
+  void (*output)(int, void *);  /* output function */
+
+  void (*error)(void *, char *, va_list);       /* error function */
+
+  char linelines;
+
+  char warnillegalcpp; /* warn for illegal preprocessor instructions? */
+
+  char outputLINE;   /* output 'line' in #line instructions */
+
+  char showversion;  /* display version */
+
+  char showincluded; /* display included files */
+
+  char showbalance; /* display paren balance */
+
+  char showspace;   /* display all whitespaces as they are */
+
+  char comment;     /* TRUE if a comment just has been written to output */
+
+  char *spacebuf;    /* Buffer to store whitespaces in if -H */
+
+  long chpos;       /* Number of whitespaces in buffer */
+
+  char nestcomments; /* Allow nested comments */
+
+  char warnnestcomments; /* Warn at nested comments */
+
+  char warnnoinclude; /* Warn at missing include file */
+
+  char outputfile; /* output the main file */
+
+  char out; /* should we output anything now? */
+
+  char rightconcat; /* should the right part of a concatenation be avaluated
+					   before the concat (TRUE) or after (FALSE) */
+  char *initialfunc; /* file to include first in all functions */
+
+  char *excludedinit[20]; /* functions (names) excluded from the initfunc */
+  int excluded;
+
+  char outputfunctions;  /* output all discovered functions to stderr! */
+
+  char webmode; /* WWW process mode */
+};
+
+typedef enum {
+  ERROR_STRING_MUST_BE_IF,
+  ERROR_STRING_MAY_NOT_FOLLOW_ELSE,
+  ERROR_ERROR,
+  ERROR_PREPROC_FAILURE,
+  ERROR_MISSING_ARGUMENT,
+  ERROR_INCLUDE_SYNTAX,
+  ERROR_DEFINE_SYNTAX,
+  ERROR_REDEFINE,
+  ERROR_ILLEGAL_UNDEF,
+  ERROR_RECURSIVE_MACRO,
+  ERROR_EOF_IN_ARGUMENT,
+  ERROR_MISPLACED_CONSTANT,
+  ERROR_IF_OVERFLOW,
+  ERROR_ILLEGAL_IF_LINE,
+  ERROR_OPERATOR,
+  ERROR_EXPR_OVERFLOW,
+  ERROR_UNBALANCED_PARENS,
+  ERROR_MISPLACED,
+  ERROR_STRING_IN_IF,
+  ERROR_DEFINED_SYNTAX,
+  ERROR_ILLEGAL_ASSIGN,
+  ERROR_ILLEGAL_BACKSLASH,
+  ERROR_SIZEOF_SYNTAX,
+  ERROR_SIZEOF_UNKNOWN,
+  ERROR_SIZEOF_ILLEGAL_TYPE,
+  ERROR_SIZEOF_NO_TYPE,
+  ERROR_UNTERMINATED_STRING,
+  ERROR_EOF_IN_COMMENT,
+  ERROR_IFDEF_DEPTH,
+  ERROR_ILLEGAL_CHARACTER,
+  ERROR_ILLEGAL_CHARACTER2,
+  ERROR_SIZEOF_BUG,
+  ERROR_IF_OPERAND,
+  ERROR_STRANG_CHARACTER,
+  ERROR_STRANG_CHARACTER2,
+
+  BORDER_ERROR_WARN, /* below this number: errors, above: warnings */
+
+  WARN_CONTROL_LINE_IN_MACRO,
+  WARN_ILLEGAL_COMMAND,
+  WARN_UNEXPECTED_TEXT_IGNORED,
+  WARN_TOO_FEW_VALUES_TO_SIZEOF,
+  WARN_TOO_MANY_VALUES_TO_SIZEOF,
+  WARN_NOT_DEFINED,
+  WARN_INTERNAL_ERROR,
+  WARN_MACRO_NEEDS_ARGUMENTS,
+  WARN_WRONG_NUMBER_ARGUMENTS,
+  WARN_DIVISION_BY_ZERO,
+  WARN_ILLEGAL_OCTAL,
+  WARN_MULTIBYTE_NOT_PORTABLE,
+  WARN_CANNOT_OPEN_INCLUDE,
+  WARN_BRACKET_DEPTH,
+  WARN_PAREN_DEPTH,
+  WARN_BRACE_DEPTH,
+  WARN_NESTED_COMMENT,
+
+  BORDER_WARN_FATAL, /* below this number: warnings, above: fatals */
+
+  FATAL_TOO_MANY_NESTINGS,
+  FATAL_FILENAME_BUFFER_OVERFLOW,
+  FATAL_TOO_MANY_INCLUDE_DIRS,
+  FATAL_TOO_MANY_INCLUDE_FILES,
+  FATAL_TOO_MANY_ARGUMENTS_MACRO,
+  FATAL_MACRO_AREA_OVERFLOW,
+  FATAL_ILLEGAL_MACRO,
+  FATAL_TOO_MANY_ARGUMENTS_EXPANSION,
+  FATAL_OUT_OF_SPACE_IN_ARGUMENT,
+  FATAL_WORK_AREA_OVERFLOW,
+  FATAL_WORK_BUFFER_OVERFLOW,
+  FATAL_OUT_OF_MEMORY,
+  FATAL_TOO_MUCH_PUSHBACK
+
+
+  } ErrorCode;
+
+/**********************************************************************
+ * RETURN CODES:
+ *********************************************************************/
+
+typedef enum {
+  FPP_OK,
+  FPP_OUT_OF_MEMORY,
+  FPP_TOO_MANY_NESTED_STATEMENTS,
+  FPP_FILENAME_BUFFER_OVERFLOW,
+  FPP_NO_INCLUDE,
+  FPP_OPEN_ERROR,
+  FPP_TOO_MANY_ARGUMENTS,
+  FPP_WORK_AREA_OVERFLOW,
+  FPP_ILLEGAL_MACRO,
+  FPP_EOF_IN_MACRO,
+  FPP_OUT_OF_SPACE_IN_MACRO_EXPANSION,
+  FPP_ILLEGAL_CHARACTER,
+  FPP_CANT_USE_STRING_IN_IF,
+  FPP_BAD_IF_DEFINED_SYNTAX,
+  FPP_IF_ERROR,
+  FPP_SIZEOF_ERROR,
+  FPP_UNTERMINATED_STRING,
+  FPP_TOO_MANY_INCLUDE_DIRS,
+  FPP_TOO_MANY_INCLUDE_FILES,
+  FPP_INTERNAL_ERROR,
+
+  FPP_LAST_ERROR
+} ReturnCode;
+
+/* Nasty defines to make them appear as three different functions! */
+#define cwarn cerror
+#define cfatal cerror 
+
+
+/**********************************************************************
+ * PROTOTYPES:
+ *********************************************************************/
+int PREFIX fppPreProcess(REG(a0) struct fppTag *);
+void Freemem(void *);
+void Error(struct Global *, char *, ...);
+void Putchar(struct Global *, int);
+void Putstring(struct Global *, char *);
+void Putint(struct Global *, int);
+char *savestring(struct Global *, char *);
+ReturnCode addfile(struct Global *, FILE *, char *);
+int catenate(struct Global *, ReturnCode *);
+void cerror(struct Global *, ErrorCode, ...);
+ReturnCode control(struct Global *, int *);
+ReturnCode dodefine(struct Global *);
+int dooptions(struct Global *, struct fppTag *);
+void doundef(struct Global *);
+void dumpparm(char *);
+ReturnCode expand(struct Global *, DEFBUF *);
+int get(struct Global *);
+ReturnCode initdefines(struct Global *);
+void outdefines(struct Global *);
+ReturnCode save(struct Global *, int);
+void scanid(struct Global *, int);
+ReturnCode scannumber(struct Global *, int, ReturnCode(*)(struct Global *, int));
+ReturnCode scanstring(struct Global *, int, ReturnCode(*)(struct Global *, int));
+void unget(struct Global *);
+ReturnCode ungetstring(struct Global *, char *);
+ReturnCode eval(struct Global *, int *);
+#ifdef  DEBUG_EVAL
+void dumpstack(OPTAB[NEXP], register OPTAB *, int [NEXP], register int *);
+#endif
+void skipnl(struct Global *);
+int skipws(struct Global *);
+ReturnCode macroid(struct Global *, int *);
+ReturnCode getfile(struct Global *, size_t, char *, FILEINFO **);
+DEFBUF *lookid(struct Global *, int );
+DEFBUF *defendel(struct Global *, char *, int);
+#if DEBUG
+void dumpdef(char *);
+void dumpadef(char *, register DEFBUF *);
+#endif
+ReturnCode openfile(struct Global *,char *);
+int cget(struct Global *);
+void deldefines(struct Global *);
+char *Getmem(struct Global *, int);
+ReturnCode openinclude(struct Global *, char *, int);
+ReturnCode expstuff(struct Global *, char *, char *);

3rdparty/bgfx/3rdparty/fcpp/cppdef.h

@@ -0,0 +1,383 @@
+/******************************************************************************
+ *                               FREXXWARE
+ * ----------------------------------------------------------------------------
+ *
+ * Project: Frexx C Preprocessor
+ * $Source: /home/user/start/cpp/RCS/cppdef.h,v $
+ * $Revision: 1.4 $
+ * $Date: 1993/12/06 13:51:20 $
+ * $Author: start $
+ * $State: Exp $
+ * $Locker: start $
+ *
+ * ----------------------------------------------------------------------------
+ * $Log: cppdef.h,v $
+ * Revision 1.4  1993/12/06  13:51:20  start
+ * A lot of new stuff (too much to mention)
+ *
+ * Revision 1.3  1993/11/29  14:01:13  start
+ * New features added
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.1  1993/11/03  09:15:59  start
+ * Initial revision
+ *
+ *
+ *****************************************************************************/
+#ifdef EMACS
+
+/* Use the Emacs config file to find out what type of machine */
+
+#define NO_SHORTNAMES
+
+/* Convert Emacs's conventions for BIG_ENDIAN to cpp's convention.  */
+#ifdef BIG_ENDIAN
+#undef BIG_ENDIAN
+#define BIG_ENDIAN TRUE
+#else /* not BIG_ENDIAN */
+#define BIG_ENDIAN FALSE
+#endif /* BIG_ENDIAN */
+
+/* Emacs uses the names index and rindex and defines them as str(r)chr if nec;
+   cpp uses the opposite convention.  Here we flush the macro definitions for
+   Emacs and add the ones cpp wants.  */
+
+#ifdef index
+#undef index
+#undef rindex
+#else /* index is not defined as a macro */
+#define strchr index
+#define strrchr rindex
+#endif /* index is not defined as a macro */
+
+#define NBUFF 2048
+#define NWORK 2048
+
+#endif /* EMACS */
+
+/*
+ *		   S y s t e m	 D e p e n d e n t
+ *		D e f i n i t i o n s	 f o r	 C P P
+ *
+ * Definitions in this file may be edited to configure CPP for particular
+ * host operating systems and target configurations.
+ *
+ * NOTE: cpp assumes it is compiled by a compiler that supports macros
+ * with arguments.  If this is not the case (as for Decus C), #define
+ * nomacarg -- and provide function equivalents for all macros.
+ *
+ * cpp also assumes the host and target implement the Ascii character set.
+ * If this is not the case, you will have to do some editing here and there.
+ */
+
+/*
+ * This redundant definition of TRUE and FALSE works around
+ * a limitation of Decus C.
+ */
+#ifndef TRUE
+#define TRUE			1
+#define FALSE			0
+#endif
+
+/*
+ * Define the HOST operating system.  This is needed so that
+ * cpp can use appropriate filename conventions.
+ */
+#define SYS_UNKNOWN		0
+#define SYS_UNIX		1
+#define SYS_VMS 		2
+#define SYS_RSX 		3
+#define SYS_RT11		4
+#define SYS_LATTICE		5
+#define SYS_ONYX		6
+#define SYS_68000		7
+#define SYS_AMIGADOS		8
+
+#ifndef HOST
+#ifdef	unix
+#define HOST			SYS_UNIX
+#else
+#ifdef	amiga
+#define HOST			SYS_AMIGADOS
+#endif
+#endif
+#endif
+
+/*
+ * We assume that the target is the same as the host system
+ */
+#ifndef TARGET
+#define TARGET			HOST
+#endif
+
+/*
+ * In order to predefine machine-dependent constants,
+ * several strings are defined here:
+ *
+ * MACHINE	defines the target cpu (by name)
+ * SYSTEM	defines the target operating system
+ * COMPILER	defines the target compiler
+ *
+ *	The above may be #defined as "" if they are not wanted.
+ *	They should not be #defined as NULL.
+ *
+ * LINE_PREFIX	defines the # output line prefix, if not "line"
+ *		This should be defined as "" if cpp is to replace
+ *		the "standard" C pre-processor.
+ */
+#define LINE_PREFIX		"line"
+/*
+ * FILE_LOCAL	marks functions which are referenced only in the
+ *		file they reside.  Some C compilers allow these
+ *		to be marked "static" even though they are referenced
+ *		by "extern" statements elsewhere.
+ *
+ * OK_DOLLAR	Should be set TRUE if $ is a valid alphabetic character
+ *		in identifiers (default), or zero if $ is invalid.
+ *		Default is TRUE.
+ *
+ * OK_CONCAT	Should be set TRUE if # may be used to concatenate
+ *		tokens in macros (per the Ansi Draft Standard) or
+ *		FALSE for old-style # processing (needed if cpp is
+ *		to process assembler source code).
+ */
+#define OK_CONCAT TRUE
+/*
+ * OK_DATE	Predefines the compilation date if set TRUE.
+ *		Not permitted by the Nov. 12, 1984 Draft Standard.
+ */
+#define OK_DATE TRUE
+/*
+ *
+ * OK_SIZEOF	Permits sizeof in #if preprocessor expressions.
+ *		According to K&R V2 (page 232), this is not allowed.
+ */
+#define OK_SIZEOF TRUE
+/*
+ * S_CHAR etc.	Define the sizeof the basic TARGET machine word types.
+ *		By default, sizes are set to the values for the HOST
+ *		computer.  If this is inappropriate, see the code in
+ *		cpp3.c for details on what to change.  Also, if you
+ *		have a machine where sizeof (signed int) differs from
+ *		sizeof (unsigned int), you will have to edit code and
+ *		tables in cpp3.c (and extend the -S option definition.)
+ *
+ * CPP_LIBRARY	May be defined if you have a site-specific include directory
+ *		which is to be searched *before* the operating-system
+ *		specific directories.
+ */
+
+#define MACHINE 		"amiga", "m68000"
+#define SYSTEM			"amigados"
+
+
+/*
+ * defaults
+ */
+
+#ifndef MSG_PREFIX
+#define MSG_PREFIX		"cpp: "
+#endif
+
+/*
+ * OLD_PREPROCESSOR forces the definition of OK_DOLLAR, OK_CONCAT,
+ * COMMENT_INVISIBLE to values appropriate for
+ * an old-style preprocessor.
+ */
+
+#if	OLD_PREPROCESSOR
+#define OK_DOLLAR		FALSE
+#define OK_CONCAT		FALSE
+#define COMMENT_INVISIBLE	TRUE
+#endif
+
+/*
+ * RECURSION_LIMIT may be set to -1 to disable the macro recursion test.
+ */
+#ifndef RECURSION_LIMIT
+#define RECURSION_LIMIT 1000
+#endif
+
+/*
+ * BITS_CHAR may be defined to set the number of bits per character.
+ * it is needed only for multi-byte character constants.
+ */
+#ifndef BITS_CHAR
+#define BITS_CHAR		8
+#endif
+
+/*
+ * BIG_ENDIAN is set TRUE on machines (such as the IBM 360 series)
+ * where 'ab' stores 'a' in the high-bits and 'b' in the low-bits.
+ * It is set FALSE on machines (such as the PDP-11 and Vax-11)
+ * where 'ab' stores 'a' in the low-bits and 'b' in the high-bits.
+ * (Or is it the other way around?) -- Warning: BIG_ENDIAN code is untested.
+ * [I *seems* to be the other way around, according to the code /OIS]
+ */
+#ifndef BIG_ENDIAN
+#define BIG_ENDIAN		FALSE
+#endif
+
+/*
+ * COMMENT_INVISIBLE may be defined to allow "old-style" comment
+ * processing, whereby the comment becomes a zero-length token
+ * delimiter.  This permitted tokens to be concatenated in macro
+ * expansions.	This was removed from the Draft Ansi Standard.
+ */
+#ifndef COMMENT_INVISIBLE
+#define COMMENT_INVISIBLE	FALSE
+#endif
+
+/*
+ * OK_DOLLAR enables use of $ as a valid "letter" in identifiers.
+ * This is a permitted extension to the Ansi Standard and is required
+ * for e.g., VMS, RSX-11M, etc.   It should be set FALSE if cpp is
+ * used to preprocess assembler source on Unix systems.  OLD_PREPROCESSOR
+ * sets OK_DOLLAR FALSE for that reason.
+ */
+#ifndef OK_DOLLAR
+#define OK_DOLLAR		TRUE
+#endif
+
+/*
+ * OK_CONCAT enables (one possible implementation of) token concatenation.
+ * If cpp is used to preprocess Unix assembler source, this should be
+ * set FALSE as the concatenation character, #, is used by the assembler.
+ */
+#ifndef OK_CONCAT
+#define OK_CONCAT		TRUE
+#endif
+
+/*
+ * OK_DATE may be enabled to predefine today's date as a string
+ * at the start of each compilation.  This is apparently not permitted
+ * by the Draft Ansi Standard.
+ */
+#ifndef OK_DATE
+#define OK_DATE 	TRUE
+#endif
+
+/*
+ * OK_SIZEOF may be defined to allow sizeof(type) in #if expressions.
+ * Actually, it is none of the preprocessors business how large these
+ * things are, as they might be different with different compiler
+ * options. Also, according to K&R V2, page 232, it is nonstandard.
+ * This option was added in the PDC process, under no. *OIS*0.92*.
+ */
+#ifndef OK_SIZEOF
+#define OK_SIZEOF	FALSE
+#endif
+
+/*
+ * Some common definitions.
+ */
+
+#ifndef DEBUG
+#define DEBUG		FALSE
+#endif
+
+/*
+ * The following definitions are used to allocate memory for
+ * work buffers.  In general, they should not be modified
+ * by implementors.
+ *
+ * PAR_MAC	The maximum number of #define parameters (31 per Standard)
+ *		Note: we need another one for strings.
+ * NBUFF	Input buffer size
+ * NWORK	Work buffer size -- the longest macro
+ *		must fit here after expansion.
+ * NEXP 	The nesting depth of #if expressions
+ * NINCLUDE	The number of directories that may be specified
+ *		on a per-system basis, or by the -I option.
+ * BLK_NEST	The number of nested #if's permitted.
+ */
+
+#ifndef PAR_MAC
+#define PAR_MAC 	   (31 + 1)
+#endif
+
+#ifndef NBUFF
+#define NBUFF			512
+#endif
+
+#ifndef NWORK
+#define NWORK			512
+#endif
+
+#ifndef NEXP
+#define NEXP			128
+#endif
+
+#ifndef NINCLUDE
+#define NINCLUDE		  20
+#endif
+
+#ifndef NPARMWORK
+#define NPARMWORK		(NWORK * 2)
+#endif
+
+#ifndef BLK_NEST
+#define BLK_NEST		32
+#endif
+
+
+/*
+ * Some special constants.  These may need to be changed if cpp
+ * is ported to a wierd machine.
+ *
+ * NOTE: if cpp is run on a non-ascii machine, ALERT and VT may
+ * need to be changed.	They are used to implement the proposed
+ * ANSI standard C control characters '\a' and '\v' only.
+ * DEL is used to tag macro tokens to prevent #define foo foo
+ * from looping.  Note that we don't try to prevent more elaborate
+ * #define loops from occurring.
+ */
+
+#ifndef ALERT
+#define ALERT			'\007'          /* '\a' is "Bell"       */
+#endif
+
+#ifndef VT
+#define VT			'\013'          /* Vertical Tab CTRL/K  */
+#endif
+
+/*
+ * Functions can be declared/defined static to only become in the
+ * scope for functions of the same source file.
+ */
+
+#ifndef FILE_LOCAL
+#define FILE_LOCAL		static		/* file-unique globals */
+#endif
+
+/*
+ * For compilers supporting inlining, the INLINE macro has been added to
+ * functions called from only one place. There might still be some
+ * functions that should have this macro.
+ */
+#ifdef AMIGA
+#define INLINE __inline /* Amiga compiler SAS/C 6.x supports this! */
+#else
+#define INLINE /* don't support that kind of stuff */
+#endif
+
+#if defined(AMIGA) && defined(SHARED)
+#define PREFIX __asm __saveds
+#define REG(x) register __ ## x
+#else
+#define PREFIX
+#define REG(x)
+#endif
+
+/*
+ * SBSIZE defines the number of hash-table slots for the symbol table.
+ */
+#ifndef SBSIZE
+#define SBSIZE  64
+#endif
+
+#define VERSION_TEXT "Frexx C Preprocessor v1.5.1 " \
+"Copyright (C) by FrexxWare 1993 - 2002.\n" \
+"Compiled " __DATE__ "\n"

3rdparty/bgfx/3rdparty/fcpp/fpp.exp

@@ -0,0 +1,2 @@
+#!
+fppPreProcess

3rdparty/bgfx/3rdparty/fcpp/fpp.fd

@@ -0,0 +1,4 @@
+##base _FPPBase
+##bias 30
+fppPreProcess(a)(A0)
+##end

3rdparty/bgfx/3rdparty/fcpp/fpp.h

@@ -0,0 +1,162 @@
+/******************************************************************************
+ *                               FREXXWARE
+ * ----------------------------------------------------------------------------
+ *
+ * Project: Frexx C Preprocessor
+ * $Source: /home/user/start/cpp/RCS/fpp.h,v $
+ * $Revision: 1.5 $
+ * $Date: 1994/01/24 09:38:45 $
+ * $Author: start $
+ * $State: Exp $
+ * $Locker: start $
+ *
+ * ----------------------------------------------------------------------------
+ * $Log: fpp.h,v $
+ * Revision 1.5  1994/01/24  09:38:45  start
+ * Added FPPTAG_RIGHTCONCAT.
+ *
+ * Revision 1.4  1993/12/06  13:51:20  start
+ * A lot of new stuff (too much to mention)
+ *
+ * Revision 1.3  1993/11/29  14:01:13  start
+ * New features added
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.1  1993/11/03  09:15:59  start
+ * Initial revision
+ *
+ *
+ *****************************************************************************/
+/**********************************************************************
+ *
+ * fpp.h
+ *
+ */
+
+
+struct fppTag {
+  int tag;
+  void *data;
+};
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#define NFLAG_BUILTIN   1
+#define NFLAG_PREDEFINE 2
+
+/* end of taglist: */
+#define FPPTAG_END 0
+
+/* To make the preprocessed output keep the comments: */
+#define FPPTAG_KEEPCOMMENTS 1 /* data is TRUE or FALSE */
+
+/* To define symbols to the preprocessor: */
+#define FPPTAG_DEFINE 2 /* data is the string "symbol" or "symbol=<value>" */
+
+/* To make the preprocessor ignore all non-fatal errors: */
+#define FPPTAG_IGNORE_NONFATAL 3 /* data is TRUE or FALSE */
+
+/* To add an include directory to the include directory list: */
+#define FPPTAG_INCLUDE_DIR 4 /* data is directory name ending with a '/' (on
+				amiga a ':' is also valid) */
+
+/* To define all machine specific built-in #defines, default is TRUE: */
+#define FPPTAG_BUILTINS 5 /* data is TRUE or FALSE */
+
+/* To define predefines like __LINE__, __DATE__, etc. default is TRUE: */
+#define FPPTAG_PREDEFINES 6 /* data is TRUE or FALSE */
+
+/* To make fpp leave C++ comments in the output: */
+#define FPPTAG_IGNORE_CPLUSPLUS 7 /* data is TRUE or FALSE */
+
+/* To define new sizes to #if sizeof: */
+#define FPPTAG_SIZEOF_TABLE 8 /* data is sizeof table string */
+
+/* To undefine symbols: */
+#define FPPTAG_UNDEFINE 9 /* data is symbol name */
+
+/* Output all #defines: */
+#define FPPTAG_OUTPUT_DEFINES 10 /* data is TRUE or FALSE */
+
+/* Initial input file name: */
+#define FPPTAG_INPUT_NAME 11 /* data is string */
+
+/* Input function: */
+#define FPPTAG_INPUT 12 /* data is an input funtion */
+
+/* Output function: */
+#define FPPTAG_OUTPUT 13 /* data is an output function */
+
+/* User data, sent in the last argument to the input function: */
+#define FPPTAG_USERDATA 14 /* data is user data */
+
+/* Whether to exclude #line instructions in the output, default is FALSE */
+#define FPPTAG_LINE 15 /* data is TRUE or FALSE */
+
+/* Error function. This is called when FPP finds any warning/error/fatal: */
+#define FPPTAG_ERROR 16 /* data is function pointer to a
+			   "void (*)(void *, char *, va_list)" */
+
+/* Whether to warn for illegal cpp instructions */
+#define FPPTAG_WARNILLEGALCPP 17 /* data is boolean, default is FALSE */
+
+/* Output the 'line' keyword on #line-lines? */
+#define FPPTAG_OUTPUTLINE 18 /* data is boolean, default is TRUE */
+
+/* Do not output the version information string */
+#define FPPTAG_IGNOREVERSION 19 /* data is boolean, default is FALSE */
+
+/* Output all included file names to stderr */
+#define FPPTAG_OUTPUTINCLUDES 20 /* data is boolean, default is FALSE */
+
+/* Display warning if there is any brace, bracket or parentheses unbalance */
+#define FPPTAG_OUTPUTBALANCE 21 /* data is boolean, default is FALSE */
+
+/* Display all whitespaces in the source */
+#define FPPTAG_OUTPUTSPACE 22 /* data is boolean, default is FALSE */
+
+/* Allow nested comments */
+#define FPPTAG_NESTED_COMMENTS 23 /* data is boolean, default is FALSE */
+
+/* Enable warnings at nested comments */
+#define FPPTAG_WARN_NESTED_COMMENTS 24 /* data is boolean, default is FALSE */
+
+/* Enable warnings at missing includes */
+#define FPPTAG_WARNMISSINCLUDE 25 /* data is boolean, default is TRUE */
+
+/* Output the main file */
+#define FPPTAG_OUTPUTMAIN 26 /* data is boolean, default is TRUE */
+
+/* Include file */
+#define FPPTAG_INCLUDE_FILE 27 /* data is char pointer */
+
+/* Include macro file */
+#define FPPTAG_INCLUDE_MACRO_FILE 28 /* data is char pointer */
+
+/* Evaluate the right part of a concatenate before the concat */
+#define FPPTAG_RIGHTCONCAT 29 /* data is boolean, default is FALSE */
+
+/* Include the specified file at the beginning of each function */
+#define FPPTAG_INITFUNC 30 /* data is char pointer or NULL */
+
+/* Define function to be excluded from the "beginning-function-addings" */
+#define FPPTAG_EXCLFUNC 31 /* data is char pointer */
+
+/* Enable output of all function names defined in the source */
+#define FPPTAG_DISPLAYFUNCTIONS 32
+
+/* Switch on WWW-mode */
+#define FPPTAG_WEBMODE 33
+
+/* Depends function: */
+#define FPPTAG_DEPENDS 34 /* data is an depends funtion */
+
+int fppPreProcess(struct fppTag *);

3rdparty/bgfx/3rdparty/fcpp/fpp_pragmas.h

@@ -0,0 +1,20 @@
+#ifdef RCS
+static char rcsid[]="$Id$";
+#endif
+/******************************************************************************
+ *                               FREXXWARE
+ * ----------------------------------------------------------------------------
+ *
+ * Project: Frexx C Preprocessor
+ * $Source$
+ * $Revision$
+ * $Date$
+ * $Author$
+ * $State$
+ * $Locker$
+ *
+ * ----------------------------------------------------------------------------
+ * $Log$
+ *
+ *****************************************************************************/
+#pragma libcall FPPBase fppPreProcess 1E 801

3rdparty/bgfx/3rdparty/fcpp/makefile

@@ -0,0 +1,86 @@
+##############################################################################
+##                              FREXXWARE
+##############################################################################
+##
+## Project: Frexx C Preprocessor
+## $Source: /home/user/start/cpp/RCS/makefile,v $
+## $Revision: 1.3 $
+## $Date: 1994/06/02 09:11:24 $
+## $Author: start $
+## $State: Exp $
+## $Locker:  $
+##
+##############################################################################
+## $Log: makefile,v $
+# Revision 1.3  1994/06/02  09:11:24  start
+# Now uses 'gcc' and -O!
+#
+# Revision 1.2  1993/11/11  07:16:39  start
+# New stuff
+#
+# Revision 1.1  1993/11/03  09:19:28  start
+# Initial revision
+#
+##
+##############################################################################
+
+# Frexx PreProcessor Makefile
+
+#HOST		=-tp -B/home/danne/code/cpp/ -Wp\,-Q\,-Dunix\,-Ddpc\,-DAIX
+#DEFINES    = -Dunix -Dpdc -DAIX -DUNIX -DDEBUG
+DEFINES     = -Dunix -Dpdc -DUNIX -DDEBUG
+DEBUGFLAG	= -g
+LD	        = ld
+LDFLAGS		=
+LIB         = libfpp.a
+CPP         = fpp
+FILECPP     = fcpp
+TEMP		= templib.o
+EXPORT		= fpp.exp
+CC          = gcc
+CFLAGS		= $(DEBUGFLAG) $(DEFINES)
+AR      	= ar
+ARFLAGS 	= rv
+.SUFFIXES: .o .c .c~ .h .h~ .a .i
+OBJS 		= cpp1.o cpp2.o cpp3.o cpp4.o cpp5.o cpp6.o
+FILEOBJS 		= cpp1.o cpp2.o cpp3.o cpp4.o cpp5.o cpp6.o usecpp.o
+
+# ** compile cpp
+#
+
+#all: $(LIB) $(CPP)
+all: $(FILECPP)
+
+$(LIB) : $(OBJS) $(EXPORT)
+	$(LD) $(OBJS) -o $(TEMP) -bE:$(EXPORT) -bM:SRE -T512 -H512 -lc
+	rm -f $(LIB)
+	$(AR) $(ARFLAGS) $(LIB) $(TEMP)
+	rm $(TEMP)
+
+$(CPP) : usecpp.c
+	$(CC) $(CFLAGS) -o $(CPP) usecpp.c -L. -lfpp
+
+$(FILECPP) : $(FILEOBJS)
+	$(CC) $(FILEOBJS) -o $(FILECPP)
+
+.c.o:
+	$(CC) $(CFLAGS) -c $<
+
+cpp1.o:cpp1.c
+cpp2.o:cpp2.c
+cpp3.o:cpp3.c
+cpp4.o:cpp4.c
+cpp5.o:cpp5.c
+cpp6.o:cpp6.c
+memory.o:memory.c
+
+usecpp.o:usecpp.c
+
+clean :
+	rm -f *.o $(FILECPP)
+
+tgz:
+	rm -f makefile*~
+	(dir=`pwd`;name=`basename $$dir`;echo Creates $$name.tar.gz; cd .. ; \
+	tar -cf $$name.tar `ls $$name/*.[ch] $$name/*.exp $$name/*.fd $$name/makefile*` ; \
+	gzip $$name.tar ; chmod a+r $$name.tar.gz ; mv $$name.tar.gz $$name/)

3rdparty/bgfx/3rdparty/fcpp/usecpp.c

@@ -0,0 +1,602 @@
+/******************************************************************************
+Copyright (c) 1999 Daniel Stenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+/******************************************************************************
+ *                               FREXXWARE
+ * ----------------------------------------------------------------------------
+ *
+ * Project: Frexx C Preprocessor
+ * $Source: /home/user/start/cpp/RCS/usecpp.c,v $
+ * $Revision: 1.6 $
+ * $Date: 1994/06/02 09:11:01 $
+ * $Author: start $
+ * $State: Exp $
+ * $Locker: start $
+ *
+ * ----------------------------------------------------------------------------
+ * $Log: usecpp.c,v $
+ * Revision 1.6  1994/06/02  09:11:01  start
+ * Added the '-n' option!
+ *
+ * Revision 1.5  1994/06/02  08:51:49  start
+ * Added three more command line parameters
+ * Made -h invokes exit nice
+ *
+ * Revision 1.4  1994/01/24  09:37:17  start
+ * Major difference.
+ *
+ * Revision 1.3  1993/12/06  13:51:20  start
+ * A lot of new stuff (too much to mention)
+ *
+ * Revision 1.2  1993/11/11  07:16:39  start
+ * New stuff
+ *
+ * Revision 1.1  1993/11/03  09:13:08  start
+ * Initial revision
+ *
+ *
+ *****************************************************************************/
+/**********************************************************************
+ *
+ * usecpp.c
+ *
+ * This is a routine that is should be used to call functions in the
+ * fpp.library. We supply the own_input() and own_output() functions to
+ * the preprocessor to remain flexible.
+ */
+
+#include <stdlib.h>
+
+#ifdef AMIGA
+#include <proto/exec.h>
+#include <exec/types.h>
+
+#if defined(SHARED)
+#include <exec/libraries.h>
+#include <libraries/dos.h>
+
+#include "fpp_pragmas.h"
+#include "fpp_protos.h"
+#include "FPPBase.h"
+struct Library *FPPBase=NULL;
+#define PREFIX __saveds
+#define REG(x) register __ ## x
+#else
+#define PREFIX
+#define REG(x)
+#endif
+
+#elif defined(UNIX)
+#if defined(OS9)
+#include <types.h>
+#else
+#include <sys/types.h>
+#ifdef BSD
+#include <sys/unistd.h> /* for BSD systems (SUN OS at least) */
+#endif
+#endif
+#define PREFIX
+#define REG(x)
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#ifndef OS9
+#include <stdarg.h>
+#else
+#define va_list void *
+#endif
+
+#include "fpp.h"
+#define MAX_TAGS 40 /* maximum number of tags allowed! */
+#define FILE_LOCAL static
+
+#define CPP_PREFS_FILE "cpp.prefs"
+#ifdef AMIGA
+#define DEFAULT_CPP_PREFS_FILE "s:cpp.prefs"
+#else
+#define DEFAULT_CPP_PREFS_FILE "$HOME/cpp.prefs"
+#endif
+
+FILE_LOCAL char PREFIX *own_input(char *, int, void *);
+FILE_LOCAL void PREFIX own_output(int, void *);
+FILE_LOCAL void PREFIX own_error(void *, char *, va_list);
+FILE_LOCAL int SetOptions(int, char **, struct fppTag **);
+FILE_LOCAL char GetPrefs(struct fppTag **, char **);
+FILE_LOCAL char DoString(struct fppTag **, char *);
+
+#ifdef AMIGA
+extern long __stack=8000;
+#endif
+
+FILE_LOCAL char ignore=FALSE;  /* if we should ignore strange flags! */
+FILE_LOCAL char display=FALSE; /* display all options in use! */
+
+FILE_LOCAL char dontreadprefs; /* set if only the command line is valid */
+
+int main(int argc, char **argv)
+{
+  struct fppTag tags[MAX_TAGS];
+  int i;
+  struct fppTag *tagptr = tags;
+  char *dealloc;
+
+  /*
+   * Append system-specific directories to the include directory list.
+   * The include directories will be searched through in the same order
+   * as you add them in the taglist!
+   * The directory _must_ end with a proper directory speparator!
+   */  
+
+  tagptr->tag=FPPTAG_INCLUDE_DIR;
+#if defined (AMIGA)
+  tagptr->data = "INCLUDE:";
+#elif defined (OS9)
+  tagptr->data = "/dd/defs/";
+#else
+  tagptr->data = "/usr/include/";
+#endif
+  tagptr++;
+
+  if(GetPrefs(&tagptr, &dealloc))
+    return(0);
+
+  if( !(i = SetOptions(argc, argv, &tagptr)))
+    return(0);
+  
+  if (argc - i >2) {
+    printf("Too many file arguments. Usage: cpp [options] [input [output]]\n");
+    return(-1);
+  }
+
+  tagptr->tag=FPPTAG_INPUT;
+  tagptr->data=(void *)own_input;
+  tagptr++;
+
+  if(i<argc) {
+    /*
+     * Open input file, "-" means use stdin.
+     */
+    if (strcmp(argv[i], "-")) {
+      if (freopen(argv[i], "r", stdin) == NULL) {
+	perror(argv[i]);
+	fprintf(stderr, "Can't open input file \"%s\"", argv[i]);
+	return(-2);
+      }
+      tagptr->tag=FPPTAG_INPUT_NAME;
+      tagptr->data=argv[i];
+      tagptr++;
+      if(display)
+	fprintf(stderr, "cpp: input: %s\n", argv[i]);
+    } else				/* Else, just get stdin 	*/
+      if(display)
+	fprintf(stderr, "cpp: input: [stdin]\n");
+    i++;
+  } else
+    if(display)
+      fprintf(stderr, "cpp: input: [stdin]\n");
+
+  if(i<argc) {
+    /*
+     * Get output file, "-" means use stdout.
+     */
+    if (strcmp(argv[i], "-")) {
+      if (freopen(argv[i], "w", stdout) == NULL) {
+	perror(argv[i]);
+	fprintf(stderr, "Can't open output file \"%s\"", argv[i]);
+	return(-1);
+      }
+      if(display)
+	fprintf(stderr, "cpp: output: %s\n", argv[i]);
+    } else
+      if(display)
+	fprintf(stderr, "cpp: output: [stdout]\n");
+  } else
+    if(display)
+      fprintf(stderr, "cpp: output: [stdout]\n");
+
+  tagptr->tag=FPPTAG_OUTPUT;
+  tagptr->data=(void *)own_output;
+  tagptr++;
+
+  tagptr->tag=FPPTAG_ERROR;
+  tagptr->data=(void *)own_error;
+  tagptr++;
+
+  /* The LAST tag: */
+
+  tagptr->tag=FPPTAG_END;
+  tagptr->data=0;
+  tagptr++;
+
+#if defined(SHARED) && defined(AMIGA)
+  if(!(FPPBase=OpenLibrary(FPPNAME, 1))) {
+    printf("Error opening %s!\n", FPPNAME);
+    return(-1);
+  }
+#endif
+  fppPreProcess(tags);
+
+#if defined(SHARED) && defined(AMIGA)
+  CloseLibrary((struct Library *)FPPBase);
+#endif
+  /*
+   * Preprocess ready!
+   */
+
+  if( dealloc )
+    free( dealloc );
+
+  return(0);
+}
+
+
+FILE_LOCAL
+char PREFIX *own_input(char *buffer, int size, void *userdata)
+{
+  return(fgets(buffer, size, stdin));
+}
+
+FILE_LOCAL
+void PREFIX own_output(int c, void *userdata)
+{
+  putchar(c);
+}
+
+FILE_LOCAL
+void PREFIX own_error(void *userdata, char *format, va_list arg)
+{
+  vfprintf(stderr, format, arg);
+}
+
+FILE_LOCAL
+char GetPrefs(struct fppTag **tagptr, char **string)
+{
+  
+  FILE     *PrefsFile_PF;
+  unsigned  Length_U;
+  char     *PrefsBuffer_PC;
+  char ret= 0;
+  char *environ;
+
+  *string = NULL;
+
+  /* Open prefs file for read */
+  if ( (PrefsFile_PF = fopen(CPP_PREFS_FILE, "r")) ||
+      (PrefsFile_PF = fopen(DEFAULT_CPP_PREFS_FILE, "r"))) {
+    
+    fseek(PrefsFile_PF, 0 , SEEK_END);
+    Length_U = ftell(PrefsFile_PF);
+    fseek(PrefsFile_PF, 0, SEEK_SET);
+
+    if (*string = (char *)malloc(Length_U+1)) {
+      fread(*string, 1, Length_U, PrefsFile_PF);
+      (*string)[Length_U] = '\0';
+      
+      ret = !DoString(tagptr, *string);
+    }
+    fclose(PrefsFile_PF);
+    if(ret) {
+      free( *string );
+      return ret;
+    }
+  }
+
+  if(environ = getenv("CPP_PREFS")) {
+    ret= !DoString(tagptr, environ);
+    if(ret && *string)
+      free( *string );
+  }
+  return ret;
+}
+
+FILE_LOCAL
+char DoString(struct fppTag **tagptr, char *string)
+{
+  char     *argv[MAX_TAGS];
+  int      argc=1;
+  do {
+    while(*string && *string != '-')
+      string++;
+
+    if(!*string)
+      break;
+
+    argv[argc]=string;
+
+    do {
+      string++;
+      if(*string=='\"') {
+	do
+	  string++;
+	while(*string != '\"');
+	string++;
+      }
+    } while(*string && *string!=' ' && *string != '\n' && *string != '\t');
+    argc++;
+    if(*string) {
+      *string='\0';
+      string++;
+    } else
+      break;
+  } while(1);
+
+  return (SetOptions(argc, argv, tagptr));
+}
+
+FILE_LOCAL
+int SetOptions(int argc, char **argv, struct fppTag **tagptr)
+{
+  int i;
+  char *ap;
+  for (i = 1; i < argc; i++) {
+    ap = argv[i];
+    if (*ap++ != '-' || *ap == '\0')
+      break;
+    else {
+      char c = *ap++;
+
+      if(display)
+	fprintf(stderr, "cpp: option: %s\n", ap-2);
+
+      switch (c) {                    /* Command character    */
+      case 'Q':			      /* ignore unknown flags but */
+	ignore=1;		      /* output them on stderr */
+	break;
+
+      case 'q':			      /* ignore unknown flags */
+	ignore=2;
+	break;
+
+      case 'H':			      /* display all whitespaces */
+	(*tagptr)->tag = FPPTAG_OUTPUTSPACE;
+	(*tagptr)->data= (void *)TRUE;
+	(*tagptr)++;
+	break;
+
+      case 'b': 		      /* display unbalance */
+	(*tagptr)->tag = FPPTAG_OUTPUTBALANCE;
+	(*tagptr)->data= (void *)TRUE;
+	(*tagptr)++;
+	break;
+
+      case 'f':			      /* output all defined functions! */
+	(*tagptr)->tag = FPPTAG_DISPLAYFUNCTIONS;
+	(*tagptr)->data= (void *)TRUE;
+	(*tagptr)++;
+        break;
+
+      case 'F':			      /* output all included files! */
+	(*tagptr)->tag = FPPTAG_OUTPUTINCLUDES;
+	(*tagptr)->data= (void *)TRUE;
+	(*tagptr)++;
+        break;
+
+      case 'V':			      /* do not output version */
+	(*tagptr)->tag = FPPTAG_IGNOREVERSION;
+	(*tagptr)->data= (void *)FALSE;
+	(*tagptr)++;
+	break;
+
+      case 'C':                       /* Keep comments */
+	(*tagptr)->tag = FPPTAG_KEEPCOMMENTS;
+	(*tagptr)->data= (void *)TRUE;
+	(*tagptr)++;
+	break;
+	
+      case 'D':                       /* Define symbol */
+	(*tagptr)->tag=FPPTAG_DEFINE;
+	(*tagptr)->data=argv[i]+2;
+	(*tagptr)++;
+	break;
+
+      case 'd':                       /* Display all options */
+	fprintf(stderr, "FOUND -d flag!\n");
+	display = TRUE;
+	break;
+	
+      case 'E':                       /* Ignore non-fatal errors */
+	(*tagptr)->tag=FPPTAG_IGNORE_NONFATAL;
+	(*tagptr)->data=(void *)TRUE;
+	(*tagptr)++;
+	break;
+	
+      case 'I':                       /* Include directory */
+	(*tagptr)->tag=FPPTAG_INCLUDE_DIR;
+	(*tagptr)->data=ap;
+	(*tagptr)++;
+	break;
+	
+      case 'J':                       /* Allow nested comments */
+	(*tagptr)->tag=FPPTAG_NESTED_COMMENTS;
+	(*tagptr)->data=ap;
+	(*tagptr)++;
+	break;
+	
+      case 'j':                       /* Warn at nested comments */
+	(*tagptr)->tag=FPPTAG_WARN_NESTED_COMMENTS;
+	(*tagptr)->data=ap;
+	(*tagptr)++;
+	break;
+	
+      case 'L':
+	if(*ap == 'L') {	      /* Do not output #line */
+	  (*tagptr)->tag=FPPTAG_LINE;
+	} else {
+	  /* Do not output the 'line' keyword */
+	  (*tagptr)->tag=FPPTAG_OUTPUTLINE;
+	}
+	(*tagptr)->data=(void *)FALSE;
+	(*tagptr)++;
+	break;
+
+      case 'M':                       /* Do not warn at missing includes */
+	(*tagptr)->tag=FPPTAG_WARNMISSINCLUDE;
+	(*tagptr)->data=(void *)FALSE;
+	(*tagptr)++;
+	break;
+
+      case 'n':
+        dontreadprefs^=1; /* toggle prefsreading, default is read prefs */
+
+	/*
+	 * This flag should reset all previously added tags!
+	 */
+
+        break;
+
+      case 'N':                       /* No machine specific built-ins */
+	(*tagptr)->tag=FPPTAG_BUILTINS;
+	(*tagptr)->data=(void *)FALSE;
+	(*tagptr)++;
+	break;
+
+      case 'B':			      /* No predefines like __LINE__, etc. */
+	(*tagptr)->tag=FPPTAG_PREDEFINES;
+	(*tagptr)->data=(void *)FALSE;
+	(*tagptr)++;
+	break;
+	
+      case 'P':			      /* No C++ comments */
+	(*tagptr)->tag=FPPTAG_IGNORE_CPLUSPLUS;
+	(*tagptr)->data=(void *)TRUE;
+	(*tagptr)++;
+	break;
+	
+      case 'p':			      /* warn about illegal # - instructions */
+	(*tagptr)->tag = FPPTAG_WARNILLEGALCPP;
+	(*tagptr)->data= (void *)TRUE;
+	(*tagptr)++;
+	break;
+
+      case 'R':
+	(*tagptr)->tag = FPPTAG_RIGHTCONCAT;
+	(*tagptr)->data= (void *)TRUE;
+	(*tagptr)++;
+	break;
+
+      case 's':			      /* sizeof table */
+	(*tagptr)->tag=FPPTAG_INITFUNC;
+	(*tagptr)->data=ap;
+	(*tagptr)++;
+	break;
+	
+      case 't':			      /* excluded functions */
+	(*tagptr)->tag=FPPTAG_EXCLFUNC;
+	(*tagptr)->data=ap;
+	(*tagptr)++;
+	break;
+	
+      case 'S':			      /* sizeof table */
+	(*tagptr)->tag=FPPTAG_SIZEOF_TABLE;
+	(*tagptr)->data=ap;
+	(*tagptr)++;
+	break;
+	
+      case 'U':                       /* Undefine symbol */
+	(*tagptr)->tag=FPPTAG_UNDEFINE;
+	(*tagptr)->data=ap;
+	(*tagptr)++;
+	break;
+
+      case 'w':			      /* Output all #defines but not the
+					 main file */
+	(*tagptr)->tag=FPPTAG_OUTPUTMAIN;
+	(*tagptr)->data=(void *)FALSE;
+	(*tagptr)++;
+	
+      case 'W':			      /* Output all #defines */
+        if(!strncmp(ap, "WW", 2)) {
+          (*tagptr)->tag=FPPTAG_WEBMODE;
+          (*tagptr)->data=(void *)TRUE;
+          (*tagptr)++;
+        }
+        else {
+          (*tagptr)->tag=FPPTAG_OUTPUT_DEFINES;
+          (*tagptr)->data=(void *)TRUE;
+          (*tagptr)++;
+        }
+	break;
+
+      case 'X':
+	(*tagptr)->tag=FPPTAG_INCLUDE_FILE;
+	(*tagptr)->data=ap;
+	(*tagptr)++;
+	break;
+
+/*
+      case 'x':
+	tags[tag]->tag=FPPTAG_INCLUDE_MACRO_FILE;
+	tags[tag++]->data=ap;
+	break;
+*/
+      case 'h':
+      case '?': /* if a question mark is possible to specify! */
+      default:			/* What is this one?	*/
+	if( ignore < 2 && c != 'h') {
+	  fprintf(stderr, "cpp: unknown option: -%s\n", ap-1);
+	}
+	if(!ignore || c == 'h') {
+	  fprintf(stderr,
+		  "Usage: cpp [options] [infile [outfile] ]\n\n"
+		  "The following options are valid:\n"
+		  "  -B\tNo mahcine specific built-in symbols\n"
+		  "  -b\tOutput any parentheses, brace or bracket unbalance\n"
+		  "  -C\tWrite source file comments to output\n"
+		  "  -D\tDefine a symbol with the given (optional) value \"symbol[=value]\"\n"
+		  "  -d\tDisplay all specified options\n"
+		  "  -E\tIgnore non-fatal errors\n"
+		  "  -F\tOutput all included file names on stderr\n"
+		  "  -f\tOutput all defined functions' names on stderr\n"
+		  "  -H\tOutput all whitespaces from the source file\n"
+		  "  -h\tOutput this help text\n"
+		  "  -I\tAdd directory to the #include search list\n"
+		  "  -J\tAllow nested comments\n"
+		  "  -j\tEnable warnings for nested comments\n"
+		  "  -LL\tDon't output #line instructions\n"
+		  "  -L\tDon't output the 'line' keyword in \"#line\" instructions\n"
+		  "  -M\tDon't warn for missing include files\n"
+		  "  -N\tDon't predefine target-specific names\n"
+		  "  -n\tToggle prefs usage\n"
+		  "  -P\tDon't recognize C++ comment style\n"
+		  "  -p\tEnable warnings on non ANSI preprocessor instructions\n"
+		  "  -Q\tIgnore but visualize undefined flags\n"
+		  "  -q\tIgnore all undefined flags\n"
+		  "  -R\tEvaluate the right part first in symbol concatenations\n"
+		  "  -s\tInclude the following string at the top of each function\n"
+		  "  -S\tSpecify sizes for #if sizeof\n"
+		  "  -t\tThis function should not get an initial function\n"
+		  "  -U\tUndefine symbol\n"
+		  "  -V\tDon't output version information\n"
+		  "  -W\tOutput all #defines\n"
+                  "  -WWW\tWeb mode preprocessing\n"
+		  "  -w\tOnly output #defines\n"
+		  "  -X\tInclude file\n");
+	  return(0);
+	}	/* if (!ignore) */
+      }		/* Switch on all options	*/
+    }		/* If it's a -option            */
+  }		/* For all arguments		*/
+
+  return i;
+
+} /* end of function */

3rdparty/bgfx/3rdparty/forsyth-too/LICENSE.md

@@ -0,0 +1,13 @@
+This is an implementation of Tom Forsyth's "Linear-Speed Vertex Cache
+Optimization" algorithm as described here:
+http://home.comcast.net/~tom_forsyth/papers/fast_vert_cache_opt.html
+
+This code was authored and released into the public domain by
+Adrian Stone (stone@gameangst.com).
+
+THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER
+LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

3rdparty/bgfx/3rdparty/forsyth-too/forsythtriangleorderoptimizer.cpp

@@ -0,0 +1,350 @@
+//-----------------------------------------------------------------------------
+//  This is an implementation of Tom Forsyth's "Linear-Speed Vertex Cache 
+//  Optimization" algorithm as described here:
+//  http://home.comcast.net/~tom_forsyth/papers/fast_vert_cache_opt.html
+//
+//  This code was authored and released into the public domain by
+//  Adrian Stone (stone@gameangst.com).
+//
+//  THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+//  SHALL ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER 
+//  LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+//  IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#include <assert.h>
+#include <math.h>
+#include <vector>
+#include <limits>
+#include <algorithm>
+
+namespace Forsyth
+{
+    typedef unsigned int uint;
+    typedef unsigned short uint16;
+    typedef unsigned char byte;
+
+    //-----------------------------------------------------------------------------
+    //  OptimizeFaces
+    //-----------------------------------------------------------------------------
+    //  Parameters:
+    //      indexList
+    //          input index list
+    //      indexCount
+    //          the number of indices in the list
+    //      vertexCount
+    //          the largest index value in indexList
+    //      newIndexList
+    //          a pointer to a preallocated buffer the same size as indexList to
+    //          hold the optimized index list
+    //      lruCacheSize
+    //          the size of the simulated post-transform cache (max:64)
+    //-----------------------------------------------------------------------------
+    void OptimizeFaces(const uint16* indexList, uint indexCount, uint vertexCount, uint16* newIndexList, uint16 lruCacheSize);
+
+    namespace
+    {
+        // code for computing vertex score was taken, as much as possible
+        // directly from the original publication.
+        float ComputeVertexCacheScore(int cachePosition, int vertexCacheSize)
+        {
+            const float FindVertexScore_CacheDecayPower = 1.5f;
+            const float FindVertexScore_LastTriScore = 0.75f;
+
+            float score = 0.0f;
+            if ( cachePosition < 0 )
+            {
+                // Vertex is not in FIFO cache - no score.
+            }
+            else
+            {
+                if ( cachePosition < 3 )
+                {
+                    // This vertex was used in the last triangle,
+                    // so it has a fixed score, whichever of the three
+                    // it's in. Otherwise, you can get very different
+                    // answers depending on whether you add
+                    // the triangle 1,2,3 or 3,1,2 - which is silly.
+                    score = FindVertexScore_LastTriScore;
+                }
+                else
+                {
+                    assert ( cachePosition < vertexCacheSize );
+                    // Points for being high in the cache.
+                    const float scaler = 1.0f / ( vertexCacheSize - 3 );
+                    score = 1.0f - ( cachePosition - 3 ) * scaler;
+                    score = powf ( score, FindVertexScore_CacheDecayPower );
+                }
+            }
+
+            return score;
+        }
+
+        float ComputeVertexValenceScore(uint numActiveFaces)
+        {
+            const float FindVertexScore_ValenceBoostScale = 2.0f;
+            const float FindVertexScore_ValenceBoostPower = 0.5f;
+
+            float score = 0.f;
+
+            // Bonus points for having a low number of tris still to
+            // use the vert, so we get rid of lone verts quickly.
+            float valenceBoost = powf ( static_cast<float>(numActiveFaces),
+                -FindVertexScore_ValenceBoostPower );
+            score += FindVertexScore_ValenceBoostScale * valenceBoost;
+
+            return score;
+        }
+
+
+        const int kMaxVertexCacheSize = 64;
+        const uint kMaxPrecomputedVertexValenceScores = 64;
+        float s_vertexCacheScores[kMaxVertexCacheSize+1][kMaxVertexCacheSize];
+        float s_vertexValenceScores[kMaxPrecomputedVertexValenceScores];
+
+        bool ComputeVertexScores()
+        {
+            for (int cacheSize=0; cacheSize<=kMaxVertexCacheSize; ++cacheSize)
+            {
+                for (int cachePos=0; cachePos<cacheSize; ++cachePos)
+                {
+                    s_vertexCacheScores[cacheSize][cachePos] = ComputeVertexCacheScore(cachePos, cacheSize);
+                }
+            }
+
+            for (uint valence=0; valence<kMaxPrecomputedVertexValenceScores; ++valence)
+            {
+                s_vertexValenceScores[valence] = ComputeVertexValenceScore(valence);
+            }
+
+            return true;
+        }
+        bool s_vertexScoresComputed = ComputeVertexScores();
+
+//        inline float FindVertexCacheScore(uint cachePosition, uint maxSizeVertexCache)
+//        {
+//            return s_vertexCacheScores[maxSizeVertexCache][cachePosition];
+//        }
+
+//        inline float FindVertexValenceScore(uint numActiveTris)
+//        {
+//            return s_vertexValenceScores[numActiveTris];
+//        }
+
+        float FindVertexScore(uint numActiveFaces, uint cachePosition, uint vertexCacheSize)
+        {
+            assert(s_vertexScoresComputed);
+
+            if ( numActiveFaces == 0 )
+            {
+                // No tri needs this vertex!
+                return -1.0f;
+            }
+
+            float score = 0.f;
+            if (cachePosition < vertexCacheSize)
+            {
+                score += s_vertexCacheScores[vertexCacheSize][cachePosition];
+            }
+
+            if (numActiveFaces < kMaxPrecomputedVertexValenceScores)
+            {
+                score += s_vertexValenceScores[numActiveFaces];
+            }
+            else
+            {
+                score += ComputeVertexValenceScore(numActiveFaces);
+            }
+
+            return score;
+        }
+
+        struct OptimizeVertexData
+        {
+            float   score;
+            uint    activeFaceListStart;
+            uint    activeFaceListSize;
+            uint16  cachePos0;
+            uint16  cachePos1;
+            OptimizeVertexData() : score(0.f), activeFaceListStart(0), activeFaceListSize(0), cachePos0(0), cachePos1(0) { }
+        };
+    }
+
+    void OptimizeFaces(const uint16* indexList, uint indexCount, uint vertexCount, uint16* newIndexList, uint16 lruCacheSize)
+    {
+        std::vector<OptimizeVertexData> vertexDataList;
+        vertexDataList.resize(vertexCount);
+
+        // compute face count per vertex
+        for (uint i=0; i<indexCount; ++i)
+        {
+            uint16 index = indexList[i];
+            assert(index < vertexCount);
+            OptimizeVertexData& vertexData = vertexDataList[index];
+            vertexData.activeFaceListSize++;
+        }
+
+        std::vector<uint> activeFaceList;
+
+        const uint16 kEvictedCacheIndex = std::numeric_limits<uint16>::max();
+
+        {
+            // allocate face list per vertex
+            uint curActiveFaceListPos = 0;
+            for (uint i=0; i<vertexCount; ++i)
+            {
+                OptimizeVertexData& vertexData = vertexDataList[i];
+                vertexData.cachePos0 = kEvictedCacheIndex;
+                vertexData.cachePos1 = kEvictedCacheIndex;
+                vertexData.activeFaceListStart = curActiveFaceListPos;
+                curActiveFaceListPos += vertexData.activeFaceListSize;
+                vertexData.score = FindVertexScore(vertexData.activeFaceListSize, vertexData.cachePos0, lruCacheSize);
+                vertexData.activeFaceListSize = 0;
+            }
+            activeFaceList.resize(curActiveFaceListPos);
+        }
+
+        // fill out face list per vertex
+        for (uint i=0; i<indexCount; i+=3)
+        {
+            for (uint j=0; j<3; ++j)
+            {
+                uint16 index = indexList[i+j];
+                OptimizeVertexData& vertexData = vertexDataList[index];
+                activeFaceList[vertexData.activeFaceListStart + vertexData.activeFaceListSize] = i;
+                vertexData.activeFaceListSize++;
+            }
+        }
+
+        std::vector<byte> processedFaceList;
+        processedFaceList.resize(indexCount);
+
+        uint16 vertexCacheBuffer[(kMaxVertexCacheSize+3)*2];
+        uint16* cache0 = vertexCacheBuffer;
+        uint16* cache1 = vertexCacheBuffer+(kMaxVertexCacheSize+3);
+        uint16 entriesInCache0 = 0;
+
+        uint bestFace = 0;
+        float bestScore = -1.f;
+
+        const float maxValenceScore = FindVertexScore(1, kEvictedCacheIndex, lruCacheSize) * 3.f;
+
+        for (uint i = 0; i < indexCount; i += 3)
+        {
+            if (bestScore < 0.f)
+            {
+                // no verts in the cache are used by any unprocessed faces so
+                // search all unprocessed faces for a new starting point
+                for (uint j = 0; j < indexCount; j += 3)
+                {
+                    if (processedFaceList[j] == 0)
+                    {
+                        uint face = j;
+                        float faceScore = 0.f;
+                        for (uint k=0; k<3; ++k)
+                        {
+                            uint16 index = indexList[face+k];
+                            OptimizeVertexData& vertexData = vertexDataList[index];
+                            assert(vertexData.activeFaceListSize > 0);
+                            assert(vertexData.cachePos0 >= lruCacheSize);
+                            faceScore += vertexData.score;
+                        }
+
+                        if (faceScore > bestScore)
+                        {
+                            bestScore = faceScore;
+                            bestFace = face;
+
+                            assert(bestScore <= maxValenceScore);
+                            if (bestScore >= maxValenceScore)
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+                assert(bestScore >= 0.f);
+            }
+
+            processedFaceList[bestFace] = 1;
+            uint16 entriesInCache1 = 0;
+
+            // add bestFace to LRU cache and to newIndexList
+            for (uint v = 0; v < 3; ++v)
+            {
+                uint16 index = indexList[bestFace+v];
+                newIndexList[i+v] = index;
+
+                OptimizeVertexData& vertexData = vertexDataList[index];
+
+                if (vertexData.cachePos1 >= entriesInCache1)
+                {
+                    vertexData.cachePos1 = entriesInCache1;
+                    cache1[entriesInCache1++] = index;
+
+                    if (vertexData.activeFaceListSize == 1)
+                    {
+                        --vertexData.activeFaceListSize;
+                        continue;
+                    }
+                }
+
+                assert(vertexData.activeFaceListSize > 0);
+                uint* begin = &activeFaceList[vertexData.activeFaceListStart];
+                uint* end = &(activeFaceList[vertexData.activeFaceListStart + vertexData.activeFaceListSize - 1]) + 1;
+                uint* it = std::find(begin, end, bestFace);
+                assert(it != end);
+                std::swap(*it, *(end-1));
+                --vertexData.activeFaceListSize;
+                vertexData.score = FindVertexScore(vertexData.activeFaceListSize, vertexData.cachePos1, lruCacheSize);
+
+            }
+
+            // move the rest of the old verts in the cache down and compute their new scores
+            for (uint c0 = 0; c0 < entriesInCache0; ++c0)
+            {
+                uint16 index = cache0[c0];
+                OptimizeVertexData& vertexData = vertexDataList[index];
+
+                if (vertexData.cachePos1 >= entriesInCache1)
+                {
+                    vertexData.cachePos1 = entriesInCache1;
+                    cache1[entriesInCache1++] = index;
+                    vertexData.score = FindVertexScore(vertexData.activeFaceListSize, vertexData.cachePos1, lruCacheSize);
+                }
+            }
+
+            // find the best scoring triangle in the current cache (including up to 3 that were just evicted)
+            bestScore = -1.f;
+            for (uint c1 = 0; c1 < entriesInCache1; ++c1)
+            {
+                uint16 index = cache1[c1];
+                OptimizeVertexData& vertexData = vertexDataList[index];
+                vertexData.cachePos0 = vertexData.cachePos1;
+                vertexData.cachePos1 = kEvictedCacheIndex;
+                for (uint j=0; j<vertexData.activeFaceListSize; ++j)
+                {
+                    uint face = activeFaceList[vertexData.activeFaceListStart+j];
+                    float faceScore = 0.f;
+                    for (uint v=0; v<3; v++)
+                    {
+                        uint16 faceIndex = indexList[face+v];
+                        OptimizeVertexData& faceVertexData = vertexDataList[faceIndex];
+                        faceScore += faceVertexData.score;
+                    }
+                    if (faceScore > bestScore)
+                    {
+                        bestScore = faceScore;
+                        bestFace = face;
+                    }
+                }
+            }
+
+            std::swap(cache0, cache1);
+            entriesInCache0 = std::min(entriesInCache1, lruCacheSize);
+        }
+    }
+
+} // namespace Forsyth

3rdparty/bgfx/3rdparty/forsyth-too/forsythtriangleorderoptimizer.h

@@ -0,0 +1,44 @@
+//-----------------------------------------------------------------------------
+//  This is an implementation of Tom Forsyth's "Linear-Speed Vertex Cache
+//  Optimization" algorithm as described here:
+//  http://home.comcast.net/~tom_forsyth/papers/fast_vert_cache_opt.html
+//
+//  This code was authored and released into the public domain by
+//  Adrian Stone (stone@gameangst.com).
+//
+//  THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+//  SHALL ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+//  IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef __FORSYTH_TRIANGLE_REORDER__
+#define __FORSYTH_TRIANGLE_REORDER__
+
+#include <stdint.h>
+
+namespace Forsyth
+{
+	//-----------------------------------------------------------------------------
+	//  OptimizeFaces
+	//-----------------------------------------------------------------------------
+	//  Parameters:
+	//      indexList
+	//          input index list
+	//      indexCount
+	//          the number of indices in the list
+	//      vertexCount
+	//          the largest index value in indexList
+	//      newIndexList
+	//          a pointer to a preallocated buffer the same size as indexList to
+	//          hold the optimized index list
+	//      lruCacheSize
+	//          the size of the simulated post-transform cache (max:64)
+	//-----------------------------------------------------------------------------
+	void OptimizeFaces(const uint16_t* indexList, uint32_t indexCount, uint32_t vertexCount, uint16_t* newIndexList, uint16_t lruCacheSize);
+
+} // namespace Forsyth
+
+#endif // __FORSYTH_TRIANGLE_REORDER__

3rdparty/bgfx/3rdparty/freetype/FTL.TXT

@@ -0,0 +1,169 @@
+                    The FreeType Project LICENSE
+                    ----------------------------
+
+                            2006-Jan-27
+
+                    Copyright 1996-2002, 2006 by
+          David Turner, Robert Wilhelm, and Werner Lemberg
+
+
+
+Introduction
+============
+
+  The FreeType  Project is distributed in  several archive packages;
+  some of them may contain, in addition to the FreeType font engine,
+  various tools and  contributions which rely on, or  relate to, the
+  FreeType Project.
+
+  This  license applies  to all  files found  in such  packages, and
+  which do not  fall under their own explicit  license.  The license
+  affects  thus  the  FreeType   font  engine,  the  test  programs,
+  documentation and makefiles, at the very least.
+
+  This  license   was  inspired  by  the  BSD,   Artistic,  and  IJG
+  (Independent JPEG  Group) licenses, which  all encourage inclusion
+  and  use of  free  software in  commercial  and freeware  products
+  alike.  As a consequence, its main points are that:
+
+    o We don't promise that this software works. However, we will be
+      interested in any kind of bug reports. (`as is' distribution)
+
+    o You can  use this software for whatever you  want, in parts or
+      full form, without having to pay us. (`royalty-free' usage)
+
+    o You may not pretend that  you wrote this software.  If you use
+      it, or  only parts of it,  in a program,  you must acknowledge
+      somewhere  in  your  documentation  that  you  have  used  the
+      FreeType code. (`credits')
+
+  We  specifically  permit  and  encourage  the  inclusion  of  this
+  software, with  or without modifications,  in commercial products.
+  We  disclaim  all warranties  covering  The  FreeType Project  and
+  assume no liability related to The FreeType Project.
+
+
+  Finally,  many  people  asked  us  for  a  preferred  form  for  a
+  credit/disclaimer to use in compliance with this license.  We thus
+  encourage you to use the following text:
+
+   """
+    Portions of this software are copyright © <year> The FreeType
+    Project (www.freetype.org).  All rights reserved.
+   """
+
+  Please replace <year> with the value from the FreeType version you
+  actually use.
+
+
+Legal Terms
+===========
+
+0. Definitions
+--------------
+
+  Throughout this license,  the terms `package', `FreeType Project',
+  and  `FreeType  archive' refer  to  the  set  of files  originally
+  distributed  by the  authors  (David Turner,  Robert Wilhelm,  and
+  Werner Lemberg) as the `FreeType Project', be they named as alpha,
+  beta or final release.
+
+  `You' refers to  the licensee, or person using  the project, where
+  `using' is a generic term including compiling the project's source
+  code as  well as linking it  to form a  `program' or `executable'.
+  This  program is  referred to  as  `a program  using the  FreeType
+  engine'.
+
+  This  license applies  to all  files distributed  in  the original
+  FreeType  Project,   including  all  source   code,  binaries  and
+  documentation,  unless  otherwise  stated   in  the  file  in  its
+  original, unmodified form as  distributed in the original archive.
+  If you are  unsure whether or not a particular  file is covered by
+  this license, you must contact us to verify this.
+
+  The FreeType  Project is copyright (C) 1996-2000  by David Turner,
+  Robert Wilhelm, and Werner Lemberg.  All rights reserved except as
+  specified below.
+
+1. No Warranty
+--------------
+
+  THE FREETYPE PROJECT  IS PROVIDED `AS IS' WITHOUT  WARRANTY OF ANY
+  KIND, EITHER  EXPRESS OR IMPLIED,  INCLUDING, BUT NOT  LIMITED TO,
+  WARRANTIES  OF  MERCHANTABILITY   AND  FITNESS  FOR  A  PARTICULAR
+  PURPOSE.  IN NO EVENT WILL ANY OF THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE  FOR ANY DAMAGES CAUSED  BY THE USE OR  THE INABILITY TO
+  USE, OF THE FREETYPE PROJECT.
+
+2. Redistribution
+-----------------
+
+  This  license  grants  a  worldwide, royalty-free,  perpetual  and
+  irrevocable right  and license to use,  execute, perform, compile,
+  display,  copy,   create  derivative  works   of,  distribute  and
+  sublicense the  FreeType Project (in  both source and  object code
+  forms)  and  derivative works  thereof  for  any  purpose; and  to
+  authorize others  to exercise  some or all  of the  rights granted
+  herein, subject to the following conditions:
+
+    o Redistribution of  source code  must retain this  license file
+      (`FTL.TXT') unaltered; any  additions, deletions or changes to
+      the original  files must be clearly  indicated in accompanying
+      documentation.   The  copyright   notices  of  the  unaltered,
+      original  files must  be  preserved in  all  copies of  source
+      files.
+
+    o Redistribution in binary form must provide a  disclaimer  that
+      states  that  the software is based in part of the work of the
+      FreeType Team,  in  the  distribution  documentation.  We also
+      encourage you to put an URL to the FreeType web page  in  your
+      documentation, though this isn't mandatory.
+
+  These conditions  apply to any  software derived from or  based on
+  the FreeType Project,  not just the unmodified files.   If you use
+  our work, you  must acknowledge us.  However, no  fee need be paid
+  to us.
+
+3. Advertising
+--------------
+
+  Neither the  FreeType authors and  contributors nor you  shall use
+  the name of the  other for commercial, advertising, or promotional
+  purposes without specific prior written permission.
+
+  We suggest,  but do not require, that  you use one or  more of the
+  following phrases to refer  to this software in your documentation
+  or advertising  materials: `FreeType Project',  `FreeType Engine',
+  `FreeType library', or `FreeType Distribution'.
+
+  As  you have  not signed  this license,  you are  not  required to
+  accept  it.   However,  as  the FreeType  Project  is  copyrighted
+  material, only  this license, or  another one contracted  with the
+  authors, grants you  the right to use, distribute,  and modify it.
+  Therefore,  by  using,  distributing,  or modifying  the  FreeType
+  Project, you indicate that you understand and accept all the terms
+  of this license.
+
+4. Contacts
+-----------
+
+  There are two mailing lists related to FreeType:
+
+    o freetype@nongnu.org
+
+      Discusses general use and applications of FreeType, as well as
+      future and  wanted additions to the  library and distribution.
+      If  you are looking  for support,  start in  this list  if you
+      haven't found anything to help you in the documentation.
+
+    o freetype-devel@nongnu.org
+
+      Discusses bugs,  as well  as engine internals,  design issues,
+      specific licenses, porting, etc.
+
+  Our home page can be found at
+
+    http://www.freetype.org
+
+
+--- end of FTL.TXT ---

3rdparty/bgfx/3rdparty/freetype/README.md

@@ -0,0 +1,5 @@
+The Freetype code is copyright 2013 The FreeType Project.
+All rights reserved. (www.freetype.org).
+Distributed under the FreeType License: see FTL.TXT.
+
+freetype.h is an amalagmation of Freetype 2.4.11 made by Jeremie Roy in march 2013.

3rdparty/bgfx/3rdparty/glsl-optimizer/.gitattributes

@@ -0,0 +1,4 @@
+*.dsp -crlf
+*.dsw -crlf
+*.sln -crlf
+*.vcproj -crlf

3rdparty/bgfx/3rdparty/glsl-optimizer/.gitignore

@@ -0,0 +1,78 @@
+node_modules
+*.a
+*.dll
+*.exe
+*.ilk
+*.sdf
+*.opensdf
+*.la
+*.lo
+*.log
+*.o
+*.obj
+*.os
+*.pc
+*.pdb
+*.pyc
+*.pyo
+*.so
+*.so.*
+*.sw[a-z]
+*.tar
+*.tar.bz2
+*.tar.gz
+*.trs
+*.zip
+*~
+depend
+depend.bak
+bin/ltmain.sh
+lib
+lib64
+configure
+configure.lineno
+autom4te.cache
+aclocal.m4
+config.log
+config.status
+cscope*
+.scon*
+config.py
+build
+libtool
+manifest.txt
+.dir-locals.el
+.deps/
+.dirstamp
+.libs/
+Makefile
+Makefile.in
+
+ipch
+
+*.pbxuser
+*.perspectivev3
+*.mode1v3
+.svn
+*.ncb
+*.user
+*.suo
+*.dSYM
+xcuserdata
+*.xcworkspace
+
+cmake_install.cmake
+Makefile
+CMakeFiles/
+CMakeCache.txt
+.project
+.cproject
+glsl_main
+glsl_test
+glslopt
+glsl_compiler
+.settings/
+.pydevproject
+
+build
+metalTemp.metal

3rdparty/bgfx/3rdparty/glsl-optimizer/.npmignore

@@ -0,0 +1,2 @@
+projects
+tests

3rdparty/bgfx/3rdparty/glsl-optimizer/CMakeLists.txt

@@ -0,0 +1,51 @@
+cmake_minimum_required(VERSION 2.8)
+
+include_directories(include)
+include_directories(src/mesa)
+include_directories(src/mapi)
+include_directories(src/glsl)
+include_directories(src)
+
+option (DEBUG "Enable debugging" FALSE)
+
+if(${DEBUG} MATCHES "on")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0")
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0")
+else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Os -DNDEBUG")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Os -DNDEBUG")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -s")
+endif()
+
+file(GLOB glcpp-library_sources src/glsl/glcpp/*.c src/util/*.c)
+#file(GLOB glcpp-library_sources_remove src/glsl/glcpp/glcpp.c)
+#list(REMOVE_ITEM glcpp-library_sources ${glcpp-library_sources_remove})
+add_library(glcpp-library ${glcpp-library_sources})
+
+file(GLOB mesa_sources src/mesa/program/*.c src/mesa/main/*.c)
+add_library(mesa ${mesa_sources})
+
+file(GLOB glsl_sources src/glsl/*.cpp src/glsl/*.c)
+file(GLOB glsl_sources_remove src/glsl/main.cpp src/glsl/builtin_stubs.cpp)
+list(REMOVE_ITEM glsl_sources ${glsl_sources_remove})
+add_library(glsl_optimizer ${glsl_sources})
+target_link_libraries(glsl_optimizer glcpp-library mesa)
+
+add_executable(glsl_compiler src/glsl/main.cpp)
+target_link_libraries(glsl_compiler glsl_optimizer)
+
+file(GLOB glsl_test_sources tests/*.cpp)
+add_executable(glsl_test ${glsl_test_sources})
+target_link_libraries(glsl_test glsl_optimizer)
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    # OSX-specific build requirements
+    find_library(OpenGL_LIBRARY OpenGL )
+    target_link_libraries(glsl_test ${OpenGL_LIBRARY})
+endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+
+file(GLOB glslopt_sources contrib/glslopt/*.cpp)
+add_executable(glslopt ${glslopt_sources})
+target_link_libraries(glslopt glsl_optimizer)
+
+#add_executable(glcpp src/glsl/glcpp/glcpp.c)
+#target_link_libraries(glcpp glsl_optimizer)

3rdparty/bgfx/3rdparty/glsl-optimizer/Changelog.md

@@ -0,0 +1,221 @@
+GLSL optimizer Change Log
+=========================
+
+2016 06
+-------
+
+Fixed:
+
+* Fixed Metal translation in some cases having wrong precision on constants or constant arrays.
+
+
+2016 05
+-------
+
+Fixed:
+
+* Fixed Metal translation in some cases having wrong precision on struct members.
+* Fixed Metal translation in some cases emitting struct declarations vs. constant initializers in wrong order.
+
+
+2016 03
+-------
+
+Fixed:
+
+* Fixed translation performance regression in loop analysis (regressed in 2015 06 fixes).
+
+
+2015 08
+-------
+
+Changes:
+
+* 2D shadow and 2D array uniforms got their own glslopt_basic_type entries.
+
+Fixes:
+
+* Fixed translation of 2D texture arrays (GLSL with EXT_texture_array, GLES3 and Metal).
+
+
+2015 06
+-------
+
+Fixes:
+
+* Fixed some cases of different precision matrix assignments being miscompiled on Metal.
+* Fixed yet more issues with translation of weird loops.
+* Fixed translation of matrix+scalar, matrix-scalar, matrix/scalar operations on Metal.
+
+
+2015 05
+-------
+
+Fixes:
+
+* Fixes some cases of highp/mediump sampler sampling resulting in resulting temporaries wrongly being lowp.
+
+
+2015 04
+-------
+
+Goodies:
+
+* GLES2: support EXT_draw_instanced / gl_InstanceIDEXT.
+* Support gl_VertexID in GLSL < 1.30 when EXT_gpu_shader4 is used.
+
+Fixes:
+
+* Metal: fixed some bugs with translation of weird loops.
+
+
+2015 02
+-------
+
+Tweaks:
+
+* Texture LOD sampling functions on GLES2.0 now produce a wrapper call, that does approximation
+  (mip bias) on devices that don't support GL_EXT_shader_texture_lod.
+* Undefined precision integers on GLES now default to highp.
+
+
+2015 01
+-------
+
+Fixes:
+
+* Float literals are printed with 7 significant digits now.
+* Metal: GLSL mod() is properly translated into Metal's fmod().
+* Metal: Fixed some cases of reciprocal (1/x) printing missing half precision cast.
+* GLES3: textureOffset with a mipmap bias is printed correctly now.
+* Fixed a bug with loop inductor detection if the inductor was used before the loop for some things.
+* Fixed printing of int/float bitcast operations.
+* Improved precision determination of some constructs.
+
+
+2014 10
+-------
+
+Goodies:
+
+* Support for translating GLSL shaders into Apple Metal shading language.
+  Exactly same process; GLSL in (preferably ES3 variant), optimization passes, Metal out.
+  All uniforms currently will be put into one constant buffer.
+  Pass kGlslTargetMetal target to get Metal.
+* Shader reflection API. See glslopt_shader_get_* functions. Binding indices
+  are only automatically assigned on Metal now; on GL/ES targets the reflection API is only
+  useful to get list of inputs/uniforms, their names and types.
+* Improved dead code elimation: some cases of swizzled/masked assignments where same variable was on both sides
+  were not eliminated if that variable was totally unused later.
+* Merged with upstream Mesa, comes with new optimizations (min/max pruning, tree rebalancing, vector_insert lowering).
+
+Fixes:
+
+* sampler3D declarations were missing precision qualifier on GLES3.0.
+
+
+2014 09
+-------
+
+Goodies:
+
+* Supports GL_EXT_draw_buffers in ES2.0, for MRT.
+
+
+2014 08
+-------
+
+Goodies:
+
+* Supports GL_EXT_shader_framebuffer_fetch now, in both ES2.0 & 3.0.
+
+Fixes:
+
+* Fixed printing of infinities & NaNs.
+* Fixed vectorization pass in some cases going wrong on texture lookups.
+
+
+2014 06
+-------
+
+Goodies:
+
+* Optimization: split vectors with only some used components into scalars.
+
+Fixes:
+
+* Fixed more issues with for-loop printing.
+* Fixed printing of unsigned integer swizzled & constants.
+
+2014 03
+-------
+
+Fixes:
+
+* Fixed missing precision qualifier in some ES shaders (mostly due to expansion of ternary ?: check).
+
+2014 02
+-------
+
+Fixes:
+
+* Fixed vectorize pass introduced last month going wrong with dot products.
+
+2014 01
+-------
+
+Goodies:
+
+* Better optimization: vectorize assignments to individual vector channels.
+* More OpenGL ES 2.0 conformant printing of complex for-loops (loop inductions printed
+  as += or ++; loop initializers inside loop body).
+
+Fixes:
+
+* Fixed array assignments sometimes appearing in pre-GLSL1.20 versions, especially with
+  complex loops that couldn't be unrolled.
+* Fixed output of textureOffset and texelFetch.
+* Fixed error messages on MRT outputs on GL & GLES3 (now supports 4 MRTs).
+
+2013 12
+-------
+
+Goodies:
+
+* Optimized performance; was spending half of the time in stupid string code.
+* Added glslopt_shader_get_stats to get *very* approximate shader complexity stats.
+* Nicer printing of complicated for-loops.
+
+Fixes:
+
+* Fixed printing of struct initializers.
+
+
+2013 11
+-------
+
+Goodies:
+
+* Better optimizations: CSE; `A+(-B) => A-B`; `!A || !B => !(A && B)`.
+* Merged with upstream Mesa.
+
+Fixes:
+
+* Fixed location qualifiers, ES3.0 version printing, samplerCubeShadow sampling operations.
+
+
+2013 10
+-------
+
+Goodies:
+
+* Initial OpenGL ES 3.0 support
+* API to query shader input names; glslopt_shader_get_input_count and glslopt_shader_get_input_name
+
+Changes:
+
+* Xcode project files updated to Xcode 5
+
+Fixes:
+
+* VS2013 fixes

3rdparty/bgfx/3rdparty/glsl-optimizer/README.md

@@ -0,0 +1,96 @@
+GLSL optimizer
+==============
+
+A C++ library that takes GLSL shaders, does some GPU-independent optimizations on them
+and outputs GLSL or Metal source back. Optimizations are function inlining, dead code removal, copy propagation,
+constant folding, constant propagation, arithmetic optimizations and so on.
+
+Apparently quite a few mobile platforms are pretty bad at optimizing shaders; and
+unfortunately they *also* lack offline shader compilers. So using a GLSL optimizer offline
+before can make the shader run much faster on a platform like that. See performance numbers
+in [this blog post](http://aras-p.info/blog/2010/09/29/glsl-optimizer/).
+
+Even for drivers that have decent shader optimization, GLSL optimizer could be useful to just strip away
+dead code, make shaders smaller and do uniform/input reflection offline.
+
+Almost all actual code is [Mesa 3D's GLSL](http://cgit.freedesktop.org/mesa/mesa/log/)
+compiler; all this library does is spits out optimized GLSL or Metal back, and adds GLES type precision
+handling to the optimizer.
+
+This GLSL optimizer is made for [Unity's](http://unity3d.com/) purposes and is built-in
+starting with Unity 3.0.
+
+GLSL Optimizer is licensed according to the terms of the MIT license.
+
+See [change log here](Changelog.md).
+
+
+Usage
+-----
+
+Visual Studio 2010 (Windows, x86/x64) and Xcode 5+ (Mac, i386) project files for a static
+library are provided in `projects/vs2010/glsl_optimizer.sln` and `projects/xcode5/glsl_optimizer_lib`
+respectively.
+
+> Note: only the VS and Xcode project files are maintained and should work at any time.
+> There's also a cmake and gyp build system for Linux et al., and some stuff in contrib folder -
+> all that may or might not work.
+
+For Linux you can use cmake. Just type "cmake . && make" in the root directory.
+This will build the optimizer library and some executable binaries.
+
+Interface for the library is `src/glsl/glsl_optimizer.h`. General usage is:
+ 
+	ctx = glslopt_initialize(targetVersion);
+	for (lots of shaders) {
+		shader = glslopt_optimize (ctx, shaderType, shaderSource, options);
+		if (glslopt_get_status (shader)) {
+			newSource = glslopt_get_output (shader);
+		} else {
+			errorLog = glslopt_get_log (shader);
+		}
+		glslopt_shader_delete (shader);
+	}
+	glslopt_cleanup (ctx);
+
+
+Tests
+-----
+
+There's a testing suite for catching regressions, see `tests` folder. In VS, build
+and run `glsl_optimizer_tests` project; in Xcode use `projects/xcode5/glsl_optimizer_tests`
+project. The test executable requires path to the `tests` folder as an argument.
+
+Each test comes as three text files; input, expected IR dump and expected optimized
+GLSL dump. GLES3 tests are also converted into Metal.
+
+If you're making changes to the project and want pull requests accepted easier, I'd
+appreciate if there would be no test suite regressions. If you are implementing a
+feature, it would be cool to add tests to cover it as well!
+
+
+Notes
+-----
+
+* GLSL versions 1.10 and 1.20 are supported. 1.10 is the default, use #version 120 to specify 
+1.20. Higher GLSL versions might work, but aren't tested now.
+* GLSL ES versions 1.00 and 3.00 are supported.
+
+
+Dev Notes
+---------
+
+Pulling Mesa upstream:
+
+    git fetch upstream
+    git merge upstream/master
+    sh removeDeletedByUs.sh
+    # inspect files, git rm unneeded ones, fix conflicts etc.
+    # git commit
+    
+Rebuilding flex/bison parsers:
+
+* When .y/.l files are changed, the parsers are *not* rebuilt automatically,
+* Run ./generateParsers.sh to do that. You'll need bison & flex (on Mac, do "Install Command Line Tools" from Xcode)
+* I use bison 2.3 and flex 2.5.35 (in OS X 10.8/10.9)
+

3rdparty/bgfx/3rdparty/glsl-optimizer/autogen.sh

@@ -0,0 +1,14 @@
+#! /bin/sh
+
+srcdir=`dirname "$0"`
+test -z "$srcdir" && srcdir=.
+
+ORIGDIR=`pwd`
+cd "$srcdir"
+
+autoreconf -v --install || exit 1
+cd $ORIGDIR || exit $?
+
+if test -z "$NOCONFIGURE"; then
+    "$srcdir"/configure "$@"
+fi

3rdparty/bgfx/3rdparty/glsl-optimizer/binding.gyp

@@ -0,0 +1,28 @@
+{
+  'includes': [
+    'target_defaults.gypi',
+  ],
+  'targets': [
+    {
+      "include_dirs" : [
+          "<!(node -e \"require('nan')\")"
+      ],
+      'target_name': 'glslOptimizer',
+      'dependencies': [
+        'src/glsl_optimizer_lib.gyp:*',
+      ],
+      'sources': [
+        'src/node/binding.cpp',
+        'src/node/shader.h',
+        'src/node/shader.cpp',
+        'src/node/compiler.h',
+        'src/node/compiler.cpp'
+      ],
+      'conditions': [
+        ['OS=="win"', {
+          'msvs_disabled_warnings': [4506],
+        }],
+      ],              
+    }
+  ]
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/contrib/staticlib/Build/Tool/SourceFiles

@@ -0,0 +1,90 @@
+	../../../../src/mesa/program/hash_table.c
+	../../../../src/mesa/program/hash_table.h
+	../../../../src/mesa/program/symbol_table.c
+	../../../../src/mesa/program/symbol_table.h
+	../../../../src/talloc/talloc.c
+	../../../../src/talloc/talloc.h
+	../../../../src/glsl/ast.h
+	../../../../src/glsl/ast_expr.cpp
+	../../../../src/glsl/ast_function.cpp
+	../../../../src/glsl/ast_to_hir.cpp
+	../../../../src/glsl/ast_type.cpp
+	../../../../src/glsl/builtin_function.cpp
+	../../../../src/glsl/builtin_types.h
+	../../../../src/glsl/builtin_variables.h
+	../../../../src/glsl/glsl_lexer.cpp
+	../../../../src/glsl/glsl_lexer.lpp
+	../../../../src/glsl/glsl_optimizer.cpp
+	../../../../src/glsl/glsl_optimizer.h
+#	../../../../src/glsl/glsl_optimizer_main.cpp
+	../../../../src/glsl/glsl_parser.cpp
+	../../../../src/glsl/glsl_parser.h
+	../../../../src/glsl/glsl_parser.ypp
+	../../../../src/glsl/glsl_parser_extras.cpp
+	../../../../src/glsl/glsl_parser_extras.h
+	../../../../src/glsl/glsl_symbol_table.h
+	../../../../src/glsl/glsl_types.cpp
+	../../../../src/glsl/glsl_types.h
+	../../../../src/glsl/hir_field_selection.cpp
+	../../../../src/glsl/ir.cpp
+	../../../../src/glsl/ir.h
+	../../../../src/glsl/ir_algebraic.cpp
+	../../../../src/glsl/ir_basic_block.cpp
+	../../../../src/glsl/ir_basic_block.h
+	../../../../src/glsl/ir_clone.cpp
+	../../../../src/glsl/ir_constant_expression.cpp
+	../../../../src/glsl/ir_constant_folding.cpp
+	../../../../src/glsl/ir_constant_propagation.cpp
+	../../../../src/glsl/ir_constant_variable.cpp
+	../../../../src/glsl/ir_copy_propagation.cpp
+	../../../../src/glsl/ir_dead_code.cpp
+	../../../../src/glsl/ir_dead_code_local.cpp
+	../../../../src/glsl/ir_dead_functions.cpp
+	../../../../src/glsl/ir_div_to_mul_rcp.cpp
+	../../../../src/glsl/ir_expression_flattening.cpp
+	../../../../src/glsl/ir_expression_flattening.h
+	../../../../src/glsl/ir_function.cpp
+	../../../../src/glsl/ir_function_can_inline.cpp
+	../../../../src/glsl/ir_function_inlining.cpp
+	../../../../src/glsl/ir_function_inlining.h
+	../../../../src/glsl/ir_hierarchical_visitor.cpp
+	../../../../src/glsl/ir_hierarchical_visitor.h
+	../../../../src/glsl/ir_hv_accept.cpp
+	../../../../src/glsl/ir_if_return.cpp
+	../../../../src/glsl/ir_if_simplification.cpp
+	../../../../src/glsl/ir_if_to_cond_assign.cpp
+	../../../../src/glsl/ir_import_prototypes.cpp
+	../../../../src/glsl/ir_mat_op_to_vec.cpp
+	../../../../src/glsl/ir_mod_to_fract.cpp
+	../../../../src/glsl/ir_noop_swizzle.cpp
+	../../../../src/glsl/ir_optimization.h
+	../../../../src/glsl/ir_print_glsl_visitor.cpp
+	../../../../src/glsl/ir_print_glsl_visitor.h
+	../../../../src/glsl/ir_print_visitor.cpp
+	../../../../src/glsl/ir_print_visitor.h
+	../../../../src/glsl/ir_reader.cpp
+	../../../../src/glsl/ir_reader.h
+	../../../../src/glsl/ir_rvalue_visitor.cpp
+	../../../../src/glsl/ir_rvalue_visitor.h
+	../../../../src/glsl/ir_structure_splitting.cpp
+	../../../../src/glsl/ir_sub_to_add_neg.cpp
+	../../../../src/glsl/ir_swizzle_swizzle.cpp
+	../../../../src/glsl/ir_tree_grafting.cpp
+	../../../../src/glsl/ir_unused_structs.cpp
+	../../../../src/glsl/ir_unused_structs.h
+	../../../../src/glsl/ir_validate.cpp
+	../../../../src/glsl/ir_variable.cpp
+	../../../../src/glsl/ir_variable_refcount.cpp
+	../../../../src/glsl/ir_variable_refcount.h
+	../../../../src/glsl/ir_vec_index_to_cond_assign.cpp
+	../../../../src/glsl/ir_vec_index_to_swizzle.cpp
+	../../../../src/glsl/ir_visitor.h
+	../../../../src/glsl/link_functions.cpp
+	../../../../src/glsl/linker.cpp
+	../../../../src/glsl/linker.h
+	../../../../src/glsl/list.h
+#	../../../../src/glsl/main.cpp
+	../../../../src/glsl/program.h
+	../../../../src/glsl/s_expression.cpp
+	../../../../src/glsl/s_expression.h
+	../../../../src/glsl/msvc/msvccompat.h

3rdparty/bgfx/3rdparty/glsl-optimizer/contrib/staticlib/Build/Tool/glsloptlib.bdgcfg

@@ -0,0 +1,9 @@
+[General]
+Type = StaticLibrary
+SourceFiles = SourceFiles
+Platform = Tool
+
+[Project]
+IncludePaths=../../../../src/talloc;../../../../include;../../../../src/mesa;../../../../src/mapi;../../../../src/glsl/msvc;../../../../src/glsl
+Defines=snprintf=_snprintf;NOMINMAX;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE
+DisabledVcWarnings=4291;4996;4800;4099;4244;4018;4245

3rdparty/bgfx/3rdparty/glsl-optimizer/contrib/staticlib/Build/Tool/glsloptlib.vcproj

@@ -0,0 +1,829 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="glsloptlib"
+	ProjectGUID="{793576AD-FB15-5AA1-F2F5-488372B23341}"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(ProjectDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ProjectDir)$(ConfigurationName)"
+			ConfigurationType="4"
+			UseOfMFC="0"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalOptions=""
+				AdditionalIncludeDirectories=";../../../../src/talloc;../../../../include;../../../../src/mesa;../../../../src/mapi;../../../../src/glsl/msvc;../../../../src/glsl;../../../../../../../Shared;../../../../../../../Tools/Shared;../../../../../freetype-2.1.10/include;../../../../../Lua/include;../../../../../FreeImage;../../../../../../Include;../../../../.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;snprintf=_snprintf;NOMINMAX;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;AURORA_TOOL;AURORA_DEBUGG"
+				StringPooling="false"
+				MinimalRebuild="false"
+				ExceptionHandling="2"
+				BasicRuntimeChecks="3"
+				SmallerTypeCheck="true"
+				RuntimeLibrary="3"
+				StructMemberAlignment="3"
+				BufferSecurityCheck="true"
+				EnableFunctionLevelLinking="true"
+				EnableEnhancedInstructionSet="0"
+				FloatingPointExceptions="false"
+				DisableLanguageExtensions="false"
+				DefaultCharIsUnsigned="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				OpenMP="false"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough="PreCompiled.h"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+				CallingConvention="0"
+				CompileAs="0"
+				DisableSpecificWarnings="4512;4127;4996;4291;4291;4996;4800;4099;4244;4018;4245"
+				UseFullPaths="false"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				LinkLibraryDependencies="false"
+				AdditionalDependencies=" "
+				AdditionalLibraryDirectories="../../../../../freetype-2.1.10/lib;../../../../../Lua/lib;../../../../../FreeImage;../../../../../../Lib "
+				OutputFile="$(OutDir)\$(ProjectName).lib"
+				SuppressStartupBanner="true"
+				AdditionalOptions="/IGNORE:4221 /IGNORE:4006"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description=""
+				CommandLine=""
+				ExcludedFromBuild="false"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(ProjectDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ProjectDir)$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			UseOfMFC="0"
+			WholeProgramOptimization="0"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				AdditionalOptions=""
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="2"
+				OmitFramePointers="false"
+				WholeProgramOptimization="false"
+				AdditionalIncludeDirectories=";../../../../src/talloc;../../../../include;../../../../src/mesa;../../../../src/mapi;../../../../src/glsl/msvc;../../../../src/glsl;../../../../../../../Shared;../../../../../../../Tools/Shared;../../../../../freetype-2.1.10/include;../../../../../Lua/include;../../../../../FreeImage;../../../../../../Include;../../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;snprintf=_snprintf;NOMINMAX;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;AURORA_TOOL;AURORA_RELEASE"
+				StringPooling="false"
+				MinimalRebuild="false"
+				ExceptionHandling="2"
+				BasicRuntimeChecks="0"
+				SmallerTypeCheck="false"
+				RuntimeLibrary="2"
+				StructMemberAlignment="3"
+				BufferSecurityCheck="false"
+				EnableFunctionLevelLinking="true"
+				EnableEnhancedInstructionSet="2"
+				FloatingPointExceptions="false"
+				DisableLanguageExtensions="false"
+				DefaultCharIsUnsigned="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				OpenMP="false"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough="PreCompiled.h"
+				AssemblerOutput="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+				CallingConvention="0"
+				CompileAs="0"
+				DisableSpecificWarnings="4512;4127;4996;4291;4291;4996;4800;4099;4244;4018;4245"
+				UseFullPaths="false"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				LinkLibraryDependencies="false"
+				AdditionalDependencies=" "
+				AdditionalLibraryDirectories="../../../../../freetype-2.1.10/lib;../../../../../Lua/lib;../../../../../FreeImage;../../../../../../Lib "
+				OutputFile="$(OutDir)\$(ProjectName).lib"
+				SuppressStartupBanner="true"
+				AdditionalOptions="/IGNORE:4221  /IGNORE:4006"
+			/>			
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description=""
+				CommandLine=""
+				ExcludedFromBuild="false"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Profile|Win32"
+			OutputDirectory="$(ProjectDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ProjectDir)$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			UseOfMFC="0"
+			WholeProgramOptimization="0"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				AdditionalOptions=""
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="2"
+				OmitFramePointers="false"
+				WholeProgramOptimization="false"
+				AdditionalIncludeDirectories=";../../../../src/talloc;../../../../include;../../../../src/mesa;../../../../src/mapi;../../../../src/glsl/msvc;../../../../src/glsl;../../../../../../../Shared;../../../../../../../Tools/Shared;../../../../../freetype-2.1.10/include;../../../../../Lua/include;../../../../../FreeImage;../../../../../../Include;../../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;snprintf=_snprintf;NOMINMAX;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;AURORA_TOOL;AURORA_PROFILE"
+				StringPooling="false"
+				MinimalRebuild="false"
+				ExceptionHandling="2"
+				BasicRuntimeChecks="0"
+				SmallerTypeCheck="false"
+				RuntimeLibrary="2"
+				StructMemberAlignment="3"
+				BufferSecurityCheck="false"
+				EnableFunctionLevelLinking="false"
+				EnableEnhancedInstructionSet="2"
+				FloatingPointExceptions="false"
+				DisableLanguageExtensions="false"
+				DefaultCharIsUnsigned="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				OpenMP="false"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough="PreCompiled.h"
+				AssemblerOutput="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+				CallingConvention="0"
+				CompileAs="0"
+				DisableSpecificWarnings="4512;4127;4996;4291;4291;4996;4800;4099;4244;4018;4245"
+				UseFullPaths="false"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				LinkLibraryDependencies="false"
+				AdditionalDependencies=" "
+				AdditionalLibraryDirectories="../../../../../freetype-2.1.10/lib;../../../../../Lua/lib;../../../../../FreeImage;../../../../../../Lib "
+				OutputFile="$(OutDir)\$(ProjectName).lib"
+				SuppressStartupBanner="true"
+				AdditionalOptions="/IGNORE:4221  /IGNORE:4006"
+			/>			
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description=""
+				CommandLine=""
+				ExcludedFromBuild="false"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Final|Win32"
+			OutputDirectory="$(ProjectDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ProjectDir)$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			UseOfMFC="0"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				AdditionalOptions=""
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="2"
+				OmitFramePointers="false"
+				WholeProgramOptimization="true"
+				AdditionalIncludeDirectories=";../../../../src/talloc;../../../../include;../../../../src/mesa;../../../../src/mapi;../../../../src/glsl/msvc;../../../../src/glsl;../../../../../../../Shared;../../../../../../../Tools/Shared;../../../../../freetype-2.1.10/include;../../../../../Lua/include;../../../../../FreeImage;../../../../../../Include;../../../../.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;snprintf=_snprintf;NOMINMAX;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;AURORA_TOOL;AURORA_FINAL;AURORA_RETAIL"
+				StringPooling="false"
+				MinimalRebuild="false"
+				ExceptionHandling="2"
+				BasicRuntimeChecks="0"
+				SmallerTypeCheck="false"
+				RuntimeLibrary="2"
+				StructMemberAlignment="3"
+				BufferSecurityCheck="false"
+				EnableFunctionLevelLinking="false"
+				EnableEnhancedInstructionSet="2"
+				FloatingPointExceptions="false"
+				DisableLanguageExtensions="false"
+				DefaultCharIsUnsigned="true"
+				TreatWChar_tAsBuiltInType="true"
+				ForceConformanceInForLoopScope="true"
+				RuntimeTypeInfo="true"
+				OpenMP="false"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough="PreCompiled.h"
+				AssemblerOutput="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+				CallingConvention="0"
+				CompileAs="0"
+				DisableSpecificWarnings="4512;4127;4996;4291;4291;4996;4800;4099;4244;4018;4245"
+				UseFullPaths="false"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				LinkLibraryDependencies="false"
+				AdditionalDependencies=" "
+				AdditionalLibraryDirectories="../../../../../freetype-2.1.10/lib;../../../../../Lua/lib;../../../../../FreeImage;../../../../../../Lib "
+				OutputFile="$(OutDir)\$(ProjectName).lib"
+				SuppressStartupBanner="true"
+				AdditionalOptions="/IGNORE:4221  /IGNORE:4006"
+			/>			
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				Description=""
+				CommandLine=""
+				ExcludedFromBuild="false"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="src"
+			>
+			<Filter
+				Name="mesa"
+				>
+				<Filter
+					Name="program"
+					>
+					<File
+						RelativePath="..\..\..\..\src\mesa\program\hash_table.c"
+						>
+					</File>
+					<File
+						RelativePath="..\..\..\..\src\mesa\program\hash_table.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\..\..\src\mesa\program\symbol_table.c"
+						>
+					</File>
+					<File
+						RelativePath="..\..\..\..\src\mesa\program\symbol_table.h"
+						>
+					</File>
+				</Filter>
+			</Filter>
+			<Filter
+				Name="talloc"
+				>
+				<File
+					RelativePath="..\..\..\..\src\talloc\talloc.c"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\talloc\talloc.h"
+					>
+				</File>
+			</Filter>
+			<Filter
+				Name="glsl"
+				>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ast.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ast_expr.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ast_function.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ast_to_hir.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ast_type.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\builtin_function.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\builtin_types.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\builtin_variables.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_lexer.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_lexer.lpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_optimizer.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_optimizer.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_parser.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_parser.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_parser.ypp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_parser_extras.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_parser_extras.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_symbol_table.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_types.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\glsl_types.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\hir_field_selection.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_algebraic.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_basic_block.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_basic_block.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_clone.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_constant_expression.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_constant_folding.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_constant_propagation.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_constant_variable.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_copy_propagation.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_dead_code.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_dead_code_local.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_dead_functions.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_div_to_mul_rcp.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_expression_flattening.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_expression_flattening.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_function.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_function_can_inline.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_function_inlining.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_function_inlining.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_hierarchical_visitor.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_hierarchical_visitor.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_hv_accept.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_if_return.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_if_simplification.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_if_to_cond_assign.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_import_prototypes.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_mat_op_to_vec.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_mod_to_fract.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_noop_swizzle.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_optimization.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_print_glsl_visitor.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_print_glsl_visitor.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_print_visitor.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_print_visitor.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_reader.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_reader.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_rvalue_visitor.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_rvalue_visitor.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_structure_splitting.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_sub_to_add_neg.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_swizzle_swizzle.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_tree_grafting.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_unused_structs.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_unused_structs.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_validate.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_variable.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_variable_refcount.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_variable_refcount.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_vec_index_to_cond_assign.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_vec_index_to_swizzle.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\ir_visitor.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\link_functions.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\linker.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\linker.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\list.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\program.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\s_expression.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\..\src\glsl\s_expression.h"
+					>
+				</File>
+				<Filter
+					Name="msvc"
+					>
+					<File
+						RelativePath="..\..\..\..\src\glsl\msvc\msvccompat.h"
+						>
+					</File>
+				</Filter>
+			</Filter>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

3rdparty/bgfx/3rdparty/glsl-optimizer/generateParsers.sh

@@ -0,0 +1,5 @@
+#! /bin/sh
+flex --nounistd -osrc/glsl/glcpp/glcpp-lex.c src/glsl/glcpp/glcpp-lex.l
+flex --nounistd -osrc/glsl/glsl_lexer.cpp src/glsl/glsl_lexer.ll
+bison -v -o "src/glsl/glcpp/glcpp-parse.c" -p "glcpp_parser_" --defines=src/glsl/glcpp/glcpp-parse.h src/glsl/glcpp/glcpp-parse.y
+bison -v -o "src/glsl/glsl_parser.cpp" -p "_mesa_glsl_" --defines=src/glsl/glsl_parser.h src/glsl/glsl_parser.yy

3rdparty/bgfx/3rdparty/glsl-optimizer/include/c99/inttypes.h

@@ -0,0 +1,305 @@
+// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006 Alexander Chemeris
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+// 
+//   3. The name of the author may be used to endorse or promote products
+//      derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_INTTYPES_H_ // [
+#define _MSC_INTTYPES_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include "stdint.h"
+
+// 7.8 Format conversion of integer types
+
+typedef struct {
+   intmax_t quot;
+   intmax_t rem;
+} imaxdiv_t;
+
+// 7.8.1 Macros for format specifiers
+
+#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
+
+// The fprintf macros for signed integers are:
+#define PRId8       "d"
+#define PRIi8       "i"
+#define PRIdLEAST8  "d"
+#define PRIiLEAST8  "i"
+#define PRIdFAST8   "d"
+#define PRIiFAST8   "i"
+
+#define PRId16       "hd"
+#define PRIi16       "hi"
+#define PRIdLEAST16  "hd"
+#define PRIiLEAST16  "hi"
+#define PRIdFAST16   "hd"
+#define PRIiFAST16   "hi"
+
+#define PRId32       "I32d"
+#define PRIi32       "I32i"
+#define PRIdLEAST32  "I32d"
+#define PRIiLEAST32  "I32i"
+#define PRIdFAST32   "I32d"
+#define PRIiFAST32   "I32i"
+
+#define PRId64       "I64d"
+#define PRIi64       "I64i"
+#define PRIdLEAST64  "I64d"
+#define PRIiLEAST64  "I64i"
+#define PRIdFAST64   "I64d"
+#define PRIiFAST64   "I64i"
+
+#define PRIdMAX     "I64d"
+#define PRIiMAX     "I64i"
+
+#define PRIdPTR     "Id"
+#define PRIiPTR     "Ii"
+
+// The fprintf macros for unsigned integers are:
+#define PRIo8       "o"
+#define PRIu8       "u"
+#define PRIx8       "x"
+#define PRIX8       "X"
+#define PRIoLEAST8  "o"
+#define PRIuLEAST8  "u"
+#define PRIxLEAST8  "x"
+#define PRIXLEAST8  "X"
+#define PRIoFAST8   "o"
+#define PRIuFAST8   "u"
+#define PRIxFAST8   "x"
+#define PRIXFAST8   "X"
+
+#define PRIo16       "ho"
+#define PRIu16       "hu"
+#define PRIx16       "hx"
+#define PRIX16       "hX"
+#define PRIoLEAST16  "ho"
+#define PRIuLEAST16  "hu"
+#define PRIxLEAST16  "hx"
+#define PRIXLEAST16  "hX"
+#define PRIoFAST16   "ho"
+#define PRIuFAST16   "hu"
+#define PRIxFAST16   "hx"
+#define PRIXFAST16   "hX"
+
+#define PRIo32       "I32o"
+#define PRIu32       "I32u"
+#define PRIx32       "I32x"
+#define PRIX32       "I32X"
+#define PRIoLEAST32  "I32o"
+#define PRIuLEAST32  "I32u"
+#define PRIxLEAST32  "I32x"
+#define PRIXLEAST32  "I32X"
+#define PRIoFAST32   "I32o"
+#define PRIuFAST32   "I32u"
+#define PRIxFAST32   "I32x"
+#define PRIXFAST32   "I32X"
+
+#define PRIo64       "I64o"
+#define PRIu64       "I64u"
+#define PRIx64       "I64x"
+#define PRIX64       "I64X"
+#define PRIoLEAST64  "I64o"
+#define PRIuLEAST64  "I64u"
+#define PRIxLEAST64  "I64x"
+#define PRIXLEAST64  "I64X"
+#define PRIoFAST64   "I64o"
+#define PRIuFAST64   "I64u"
+#define PRIxFAST64   "I64x"
+#define PRIXFAST64   "I64X"
+
+#define PRIoMAX     "I64o"
+#define PRIuMAX     "I64u"
+#define PRIxMAX     "I64x"
+#define PRIXMAX     "I64X"
+
+#define PRIoPTR     "Io"
+#define PRIuPTR     "Iu"
+#define PRIxPTR     "Ix"
+#define PRIXPTR     "IX"
+
+// The fscanf macros for signed integers are:
+#define SCNd8       "d"
+#define SCNi8       "i"
+#define SCNdLEAST8  "d"
+#define SCNiLEAST8  "i"
+#define SCNdFAST8   "d"
+#define SCNiFAST8   "i"
+
+#define SCNd16       "hd"
+#define SCNi16       "hi"
+#define SCNdLEAST16  "hd"
+#define SCNiLEAST16  "hi"
+#define SCNdFAST16   "hd"
+#define SCNiFAST16   "hi"
+
+#define SCNd32       "ld"
+#define SCNi32       "li"
+#define SCNdLEAST32  "ld"
+#define SCNiLEAST32  "li"
+#define SCNdFAST32   "ld"
+#define SCNiFAST32   "li"
+
+#define SCNd64       "I64d"
+#define SCNi64       "I64i"
+#define SCNdLEAST64  "I64d"
+#define SCNiLEAST64  "I64i"
+#define SCNdFAST64   "I64d"
+#define SCNiFAST64   "I64i"
+
+#define SCNdMAX     "I64d"
+#define SCNiMAX     "I64i"
+
+#ifdef _WIN64 // [
+#  define SCNdPTR     "I64d"
+#  define SCNiPTR     "I64i"
+#else  // _WIN64 ][
+#  define SCNdPTR     "ld"
+#  define SCNiPTR     "li"
+#endif  // _WIN64 ]
+
+// The fscanf macros for unsigned integers are:
+#define SCNo8       "o"
+#define SCNu8       "u"
+#define SCNx8       "x"
+#define SCNX8       "X"
+#define SCNoLEAST8  "o"
+#define SCNuLEAST8  "u"
+#define SCNxLEAST8  "x"
+#define SCNXLEAST8  "X"
+#define SCNoFAST8   "o"
+#define SCNuFAST8   "u"
+#define SCNxFAST8   "x"
+#define SCNXFAST8   "X"
+
+#define SCNo16       "ho"
+#define SCNu16       "hu"
+#define SCNx16       "hx"
+#define SCNX16       "hX"
+#define SCNoLEAST16  "ho"
+#define SCNuLEAST16  "hu"
+#define SCNxLEAST16  "hx"
+#define SCNXLEAST16  "hX"
+#define SCNoFAST16   "ho"
+#define SCNuFAST16   "hu"
+#define SCNxFAST16   "hx"
+#define SCNXFAST16   "hX"
+
+#define SCNo32       "lo"
+#define SCNu32       "lu"
+#define SCNx32       "lx"
+#define SCNX32       "lX"
+#define SCNoLEAST32  "lo"
+#define SCNuLEAST32  "lu"
+#define SCNxLEAST32  "lx"
+#define SCNXLEAST32  "lX"
+#define SCNoFAST32   "lo"
+#define SCNuFAST32   "lu"
+#define SCNxFAST32   "lx"
+#define SCNXFAST32   "lX"
+
+#define SCNo64       "I64o"
+#define SCNu64       "I64u"
+#define SCNx64       "I64x"
+#define SCNX64       "I64X"
+#define SCNoLEAST64  "I64o"
+#define SCNuLEAST64  "I64u"
+#define SCNxLEAST64  "I64x"
+#define SCNXLEAST64  "I64X"
+#define SCNoFAST64   "I64o"
+#define SCNuFAST64   "I64u"
+#define SCNxFAST64   "I64x"
+#define SCNXFAST64   "I64X"
+
+#define SCNoMAX     "I64o"
+#define SCNuMAX     "I64u"
+#define SCNxMAX     "I64x"
+#define SCNXMAX     "I64X"
+
+#ifdef _WIN64 // [
+#  define SCNoPTR     "I64o"
+#  define SCNuPTR     "I64u"
+#  define SCNxPTR     "I64x"
+#  define SCNXPTR     "I64X"
+#else  // _WIN64 ][
+#  define SCNoPTR     "lo"
+#  define SCNuPTR     "lu"
+#  define SCNxPTR     "lx"
+#  define SCNXPTR     "lX"
+#endif  // _WIN64 ]
+
+#endif // __STDC_FORMAT_MACROS ]
+
+// 7.8.2 Functions for greatest-width integer types
+
+// 7.8.2.1 The imaxabs function
+#define imaxabs _abs64
+
+// 7.8.2.2 The imaxdiv function
+
+// This is modified version of div() function from Microsoft's div.c found
+// in %MSVC.NET%\crt\src\div.c
+#ifdef STATIC_IMAXDIV // [
+static
+#else // STATIC_IMAXDIV ][
+_inline
+#endif // STATIC_IMAXDIV ]
+imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
+{
+   imaxdiv_t result;
+
+   result.quot = numer / denom;
+   result.rem = numer % denom;
+
+   if (numer < 0 && result.rem > 0) {
+      // did division wrong; must fix up
+      ++result.quot;
+      result.rem -= denom;
+   }
+
+   return result;
+}
+
+// 7.8.2.3 The strtoimax and strtoumax functions
+#define strtoimax _strtoi64
+#define strtoumax _strtoui64
+
+// 7.8.2.4 The wcstoimax and wcstoumax functions
+#define wcstoimax _wcstoi64
+#define wcstoumax _wcstoui64
+
+
+#endif // _MSC_INTTYPES_H_ ]

3rdparty/bgfx/3rdparty/glsl-optimizer/include/c99/stdbool.h

@@ -0,0 +1,47 @@
+/**************************************************************************
+ *
+ * Copyright 2007-2010 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ **************************************************************************/
+
+#ifndef _STDBOOL_H_
+#define _STDBOOL_H_
+
+#ifndef __cplusplus
+
+#define false   0
+#define true    1
+#define bool    _Bool
+
+/* For compilers that don't have the builtin _Bool type. */
+#if ((defined(_MSC_VER) && _MSC_VER < 1800) || \
+    (defined __GNUC__&& __STDC_VERSION__ < 199901L && __GNUC__ < 3)) && !defined(_lint)
+typedef unsigned char _Bool;
+#endif
+
+#endif /* !__cplusplus */
+
+#define __bool_true_false_are_defined   1
+
+#endif /* !_STDBOOL_H_ */

3rdparty/bgfx/3rdparty/glsl-optimizer/include/c99/stdint.h

@@ -0,0 +1,247 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006-2008 Alexander Chemeris
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+// 
+//   3. The name of the author may be used to endorse or promote products
+//      derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#ifdef __cplusplus
+extern "C" {
+#endif
+#  include <wchar.h>
+#ifdef __cplusplus
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#     define _W64 __w64
+#  else
+#     define _W64
+#  endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+   typedef signed char       int8_t;
+   typedef signed short      int16_t;
+   typedef signed int        int32_t;
+   typedef unsigned char     uint8_t;
+   typedef unsigned short    uint16_t;
+   typedef unsigned int      uint32_t;
+#else
+   typedef signed __int8     int8_t;
+   typedef signed __int16    int16_t;
+   typedef signed __int32    int32_t;
+   typedef unsigned __int8   uint8_t;
+   typedef unsigned __int16  uint16_t;
+   typedef unsigned __int32  uint32_t;
+#endif
+typedef signed __int64       int64_t;
+typedef unsigned __int64     uint64_t;
+
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint64_t  uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+   typedef signed __int64    intptr_t;
+   typedef unsigned __int64  uintptr_t;
+#else // _WIN64 ][
+   typedef _W64 signed int   intptr_t;
+   typedef _W64 unsigned int uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else // _WIN64 ][
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  // _WIN64 ][
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  // _WIN64 ]
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX // [
+#  ifdef _WIN64 // [
+#     define SIZE_MAX  _UI64_MAX
+#  else // _WIN64 ][
+#     define SIZE_MAX  _UI32_MAX
+#  endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#  define WCHAR_MIN  0
+#endif  // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  // WCHAR_MAX ]
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+#define INTMAX_C   INT64_C
+#define UINTMAX_C  UINT64_C
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+
+#endif // _MSC_STDINT_H_ ]

3rdparty/bgfx/3rdparty/glsl-optimizer/include/c99_compat.h

@@ -0,0 +1,175 @@
+/**************************************************************************
+ *
+ * Copyright 2007-2013 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef _C99_COMPAT_H_
+#define _C99_COMPAT_H_
+
+
+/*
+ * MSVC hacks.
+ */
+#if defined(_MSC_VER)
+
+// BK - STFU!
+#  pragma warning(disable:4244) // warning C4244: 'function' : conversion from 'intmax_t' to 'int', possible loss of data
+#  pragma warning(disable:4267) // warning C4267: '=' : conversion from 'size_t' to 'unsigned int', possible loss of data
+#  pragma warning(disable:4351) // warning C4351: new behavior: elements of array '`anonymous-namespace'::per_vertex_accumulator::fields' will be default initialized
+#  pragma warning(disable:4345) // warning C4345: behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized
+#  pragma warning(disable:4715) // warning C4715: 'write_mask_to_swizzle' : not all control paths return a value
+#  pragma warning(disable:4800) // warning C4800: 'unsigned int' : forcing value to bool 'true' or 'false' (performance warning)
+#  pragma warning(disable:4456) // warning C4456: declaration of 'deref_var' hides previous local declaration
+#  pragma warning(disable:4457) // warning C4457: declaration of 'idx' hides function parameter
+#  pragma warning(disable:4458) // warning C4458: declaration of 'type' hides class member
+#  pragma warning(disable:4018) // warning C4018: '<': signed / unsigned mismatch
+#  pragma warning(disable:4805) // warning C4805: '|=': unsafe mix of type 'GLboolean' and type 'bool' in operation
+
+   /*
+    * Visual Studio 2012 will complain if we define the `inline` keyword, but
+    * actually it only supports the keyword on C++.
+    *
+    * To avoid this the _ALLOW_KEYWORD_MACROS must be set.
+    */
+#  if (_MSC_VER >= 1700) && !defined(_ALLOW_KEYWORD_MACROS)
+#    define _ALLOW_KEYWORD_MACROS
+#  endif
+
+   /*
+    * XXX: MSVC has a `__restrict` keyword, but it also has a
+    * `__declspec(restrict)` modifier, so it is impossible to define a
+    * `restrict` macro without interfering with the latter.  Furthermore the
+    * MSVC standard library uses __declspec(restrict) under the _CRTRESTRICT
+    * macro.  For now resolve this issue by redefining _CRTRESTRICT, but going
+    * forward we should probably should stop using restrict, especially
+    * considering that our code does not obbey strict aliasing rules any way.
+    */
+#  include <crtdefs.h>
+#  undef _CRTRESTRICT
+#  define _CRTRESTRICT
+#else
+// BK - STFU!
+#  pragma GCC diagnostic ignored "-Wunknown-pragmas" // for clang to disable GCC pragmas
+#  pragma GCC diagnostic ignored "-Wpragmas"         // for GCC to disable clang pragmas
+#  pragma GCC diagnostic ignored "-Wformat="
+#  pragma GCC diagnostic ignored "-Wformat-extra-args"
+#  pragma GCC diagnostic ignored "-Wignored-qualifiers"
+#  pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#  pragma GCC diagnostic ignored "-Wreorder"
+#  pragma GCC diagnostic ignored "-Woverloaded-virtual"
+#  pragma GCC diagnostic ignored "-Wsign-compare"
+#  pragma GCC diagnostic ignored "-Wunneeded-internal-declaration"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wunused-private-field"
+#  pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+
+/*
+ * C99 inline keyword
+ */
+#ifndef inline
+#  ifdef __cplusplus
+     /* C++ supports inline keyword */
+#  elif defined(__GNUC__)
+#    define inline __inline__
+#  elif defined(_MSC_VER)
+#    define inline __inline
+#  elif defined(__ICL)
+#    define inline __inline
+#  elif defined(__INTEL_COMPILER)
+     /* Intel compiler supports inline keyword */
+#  elif defined(__WATCOMC__) && (__WATCOMC__ >= 1100)
+#    define inline __inline
+#  elif defined(__SUNPRO_C) && defined(__C99FEATURES__)
+     /* C99 supports inline keyword */
+#  elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+     /* C99 supports inline keyword */
+#  else
+#    define inline
+#  endif
+#endif
+
+
+/*
+ * C99 restrict keyword
+ *
+ * See also:
+ * - http://cellperformance.beyond3d.com/articles/2006/05/demystifying-the-restrict-keyword.html
+ */
+#ifndef restrict
+#  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+     /* C99 */
+#  elif defined(__SUNPRO_C) && defined(__C99FEATURES__)
+     /* C99 */
+#  elif defined(__GNUC__)
+#    define restrict __restrict__
+#  elif defined(_MSC_VER)
+#    define restrict __restrict
+#  else
+#    define restrict /* */
+#  endif
+#endif
+
+
+/*
+ * C99 __func__ macro
+ */
+#ifndef __func__
+#  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(_MSC_VER)
+     /* C99 */
+#  elif defined(__SUNPRO_C) && defined(__C99FEATURES__)
+     /* C99 */
+#  elif defined(__GNUC__)
+#    if __GNUC__ >= 2
+#      define __func__ __FUNCTION__
+#    else
+#      define __func__ "<unknown>"
+#    endif
+#  elif defined(_MSC_VER)
+#    if _MSC_VER >= 1300
+#      define __func__ __FUNCTION__
+#    else
+#      define __func__ "<unknown>"
+#    endif
+#  else
+#    define __func__ "<unknown>"
+#  endif
+#endif
+
+
+/* Simple test case for debugging */
+#if 0
+static inline const char *
+test_c99_compat_h(const void * restrict a,
+                  const void * restrict b)
+{
+   return __func__;
+}
+#endif
+
+
+#endif /* _C99_COMPAT_H_ */

3rdparty/bgfx/3rdparty/glsl-optimizer/license.txt

@@ -0,0 +1,21 @@
+GLSL Optimizer is licensed according to the terms of the MIT license:
+
+Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+Copyright (C) 2010-2013  Unity Technologies All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

3rdparty/bgfx/3rdparty/glsl-optimizer/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "glsl-optimizer",
+  "version": "0.1.0",
+  "description": "GLSL optimizer",
+  "main": "build/Release/glslOptimizer.node",
+  "scripts": {
+    "install": "node-gyp rebuild"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aras-p/glsl-optimizer.git"
+  },
+  "keywords": [
+    "glsl",
+    "webgl",
+    "shader",
+    "optimize",
+    "optimizer",
+    "opengl",
+    "essl",
+    "es",
+    "opengles"
+  ],
+  "readmeFilename": "README.md",
+  "author": "Aras Pranckevičius",
+  "license": "MIT",
+  "gypfile": true,
+  "bugs": {
+    "url": "https://github.com/aras-p/glsl-optimizer/issues"
+  },
+  "homepage": "https://github.com/aras-p/glsl-optimizer",
+  "directories": {
+    "test": "tests"
+  },
+  "dependencies": {
+    "nan": "~1.2.0"
+  }
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/projects/vs2010/glsl_optimizer.sln

@@ -0,0 +1,36 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "glsl_optimizer_lib", "glsl_optimizer_lib.vcxproj", "{B475A403-9D9B-410D-8A93-BA49FC4DD811}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "glsl_optimizer_tests", "glsl_optimizer_tests.vcxproj", "{BB382242-6EBB-445F-989C-B9BA61D17965}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{B475A403-9D9B-410D-8A93-BA49FC4DD811}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B475A403-9D9B-410D-8A93-BA49FC4DD811}.Debug|Win32.Build.0 = Debug|Win32
+		{B475A403-9D9B-410D-8A93-BA49FC4DD811}.Debug|x64.ActiveCfg = Debug|x64
+		{B475A403-9D9B-410D-8A93-BA49FC4DD811}.Debug|x64.Build.0 = Debug|x64
+		{B475A403-9D9B-410D-8A93-BA49FC4DD811}.Release|Win32.ActiveCfg = Release|Win32
+		{B475A403-9D9B-410D-8A93-BA49FC4DD811}.Release|Win32.Build.0 = Release|Win32
+		{B475A403-9D9B-410D-8A93-BA49FC4DD811}.Release|x64.ActiveCfg = Release|x64
+		{B475A403-9D9B-410D-8A93-BA49FC4DD811}.Release|x64.Build.0 = Release|x64
+		{BB382242-6EBB-445F-989C-B9BA61D17965}.Debug|Win32.ActiveCfg = Debug|Win32
+		{BB382242-6EBB-445F-989C-B9BA61D17965}.Debug|Win32.Build.0 = Debug|Win32
+		{BB382242-6EBB-445F-989C-B9BA61D17965}.Debug|x64.ActiveCfg = Debug|x64
+		{BB382242-6EBB-445F-989C-B9BA61D17965}.Debug|x64.Build.0 = Debug|x64
+		{BB382242-6EBB-445F-989C-B9BA61D17965}.Release|Win32.ActiveCfg = Release|Win32
+		{BB382242-6EBB-445F-989C-B9BA61D17965}.Release|Win32.Build.0 = Release|Win32
+		{BB382242-6EBB-445F-989C-B9BA61D17965}.Release|x64.ActiveCfg = Release|x64
+		{BB382242-6EBB-445F-989C-B9BA61D17965}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

3rdparty/bgfx/3rdparty/glsl-optimizer/projects/vs2010/glsl_optimizer_lib.vcxproj

@@ -0,0 +1,372 @@
+<?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="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B475A403-9D9B-410D-8A93-BA49FC4DD811}</ProjectGuid>
+    <RootNamespace>glsl_optimizer_lib</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</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)'=='Debug|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)'=='Release|x64'" 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|x64'" 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'">build/$(ProjectName)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">build/$(ProjectName)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">build/$(ProjectName)/$(Platform)/$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">build/$(ProjectName)/$(Platform)/$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">build/$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">build/$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">build/$(ProjectName)/$(Platform)/$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">build/$(ProjectName)/$(Platform)/$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>../../src/mesa;../../src;../../include/c99;../../include;../../src/glsl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;NOMINMAX;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;__STDC_VERSION__=199901L;__STDC__;strdup=_strdup;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>false</MinimalRebuild>
+      <ExceptionHandling>
+      </ExceptionHandling>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <ForcedIncludeFiles>%(ForcedIncludeFiles)</ForcedIncludeFiles>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)$(ProjectName)-win32.lib</OutputFile>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>../../src/mesa;../../src;../../include/c99;../../include;../../src/glsl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;NOMINMAX;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;__STDC_VERSION__=199901L;__STDC__;strdup=_strdup;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>false</MinimalRebuild>
+      <ExceptionHandling>
+      </ExceptionHandling>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <ForcedIncludeFiles>%(ForcedIncludeFiles)</ForcedIncludeFiles>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)$(ProjectName)-x64.lib</OutputFile>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <AdditionalIncludeDirectories>../../src/mesa;../../src;../../include/c99;../../include;../../src/glsl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;NOMINMAX;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;__STDC_VERSION__=199901L;__STDC__;strdup=_strdup;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>
+      </ExceptionHandling>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <ForcedIncludeFiles>%(ForcedIncludeFiles)</ForcedIncludeFiles>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)$(ProjectName)-win32.lib</OutputFile>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <AdditionalIncludeDirectories>../../src/mesa;../../src;../../include/c99;../../include;../../src/glsl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;NOMINMAX;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;__STDC_VERSION__=199901L;__STDC__;strdup=_strdup;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>
+      </ExceptionHandling>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <ForcedIncludeFiles>%(ForcedIncludeFiles)</ForcedIncludeFiles>
+    </ClCompile>
+    <Lib>
+      <OutputFile>$(OutDir)$(ProjectName)-x64.lib</OutputFile>
+    </Lib>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\src\glsl\ast.h" />
+    <ClInclude Include="..\..\src\glsl\builtin_type_macros.h" />
+    <ClInclude Include="..\..\src\glsl\glsl_optimizer.h" />
+    <ClInclude Include="..\..\src\glsl\glsl_parser.h" />
+    <ClInclude Include="..\..\src\glsl\glsl_parser_extras.h" />
+    <ClInclude Include="..\..\src\glsl\glsl_symbol_table.h" />
+    <ClInclude Include="..\..\src\glsl\glsl_types.h" />
+    <ClInclude Include="..\..\src\glsl\ir.h" />
+    <ClInclude Include="..\..\src\glsl\ir_basic_block.h" />
+    <ClInclude Include="..\..\src\glsl\ir_builder.h" />
+    <ClInclude Include="..\..\src\glsl\ir_expression_flattening.h" />
+    <ClInclude Include="..\..\src\glsl\ir_function_inlining.h" />
+    <ClInclude Include="..\..\src\glsl\ir_hierarchical_visitor.h" />
+    <ClInclude Include="..\..\src\glsl\ir_optimization.h" />
+    <ClInclude Include="..\..\src\glsl\ir_print_glsl_visitor.h" />
+    <ClInclude Include="..\..\src\glsl\ir_print_metal_visitor.h" />
+    <ClInclude Include="..\..\src\glsl\ir_print_visitor.h" />
+    <ClInclude Include="..\..\src\glsl\ir_rvalue_visitor.h" />
+    <ClInclude Include="..\..\src\glsl\ir_stats.h" />
+    <ClInclude Include="..\..\src\glsl\ir_uniform.h" />
+    <ClInclude Include="..\..\src\glsl\ir_unused_structs.h" />
+    <ClInclude Include="..\..\src\glsl\ir_variable_refcount.h" />
+    <ClInclude Include="..\..\src\glsl\ir_visitor.h" />
+    <ClInclude Include="..\..\src\glsl\linker.h" />
+    <ClInclude Include="..\..\src\glsl\link_uniform_block_active_visitor.h" />
+    <ClInclude Include="..\..\src\glsl\link_varyings.h" />
+    <ClInclude Include="..\..\src\glsl\list.h" />
+    <ClInclude Include="..\..\src\glsl\loop_analysis.h" />
+    <ClInclude Include="..\..\src\glsl\program.h" />
+    <ClInclude Include="..\..\src\glsl\s_expression.h" />
+    <ClInclude Include="..\..\src\glsl\standalone_scaffolding.h" />
+    <ClInclude Include="..\..\src\glsl\strtod.h" />
+    <ClInclude Include="..\..\src\glsl\glcpp\glcpp-parse.h" />
+    <ClInclude Include="..\..\src\glsl\glcpp\glcpp.h" />
+    <ClInclude Include="..\..\src\mesa\program\hash_table.h" />
+    <ClInclude Include="..\..\src\mesa\program\prog_instruction.h" />
+    <ClInclude Include="..\..\src\mesa\program\prog_parameter.h" />
+    <ClInclude Include="..\..\src\mesa\program\prog_statevars.h" />
+    <ClInclude Include="..\..\src\mesa\program\symbol_table.h" />
+    <ClInclude Include="..\..\src\mesa\main\compiler.h" />
+    <ClInclude Include="..\..\src\mesa\main\config.h" />
+    <ClInclude Include="..\..\src\mesa\main\context.h" />
+    <ClInclude Include="..\..\src\mesa\main\core.h" />
+    <ClInclude Include="..\..\src\mesa\main\dd.h" />
+    <ClInclude Include="..\..\src\mesa\main\glheader.h" />
+    <ClInclude Include="..\..\src\mesa\main\glminimal.h" />
+    <ClInclude Include="..\..\src\mesa\main\imports.h" />
+    <ClInclude Include="..\..\src\mesa\main\macros.h" />
+    <ClInclude Include="..\..\src\mesa\main\mtypes.h" />
+    <ClInclude Include="..\..\src\mesa\main\simple_list.h" />
+    <ClInclude Include="..\..\src\util\hash_table.h" />
+    <ClInclude Include="..\..\src\util\ralloc.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\glsl\ast_array_index.cpp" />
+    <ClCompile Include="..\..\src\glsl\ast_expr.cpp" />
+    <ClCompile Include="..\..\src\glsl\ast_function.cpp" />
+    <ClCompile Include="..\..\src\glsl\ast_to_hir.cpp" />
+    <ClCompile Include="..\..\src\glsl\ast_type.cpp" />
+    <ClCompile Include="..\..\src\glsl\builtin_functions.cpp" />
+    <ClCompile Include="..\..\src\glsl\builtin_types.cpp" />
+    <ClCompile Include="..\..\src\glsl\builtin_variables.cpp" />
+    <ClCompile Include="..\..\src\glsl\glsl_lexer.cpp" />
+    <ClCompile Include="..\..\src\glsl\glsl_optimizer.cpp" />
+    <ClCompile Include="..\..\src\glsl\glsl_parser.cpp" />
+    <ClCompile Include="..\..\src\glsl\glsl_parser_extras.cpp" />
+    <ClCompile Include="..\..\src\glsl\glsl_symbol_table.cpp" />
+    <ClCompile Include="..\..\src\glsl\glsl_types.cpp" />
+    <ClCompile Include="..\..\src\glsl\hir_field_selection.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_basic_block.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_builder.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_clone.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_constant_expression.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_equals.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_expression_flattening.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_function.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_function_can_inline.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_function_detect_recursion.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_hierarchical_visitor.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_hv_accept.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_import_prototypes.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_print_glsl_visitor.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_print_metal_visitor.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_print_visitor.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_rvalue_visitor.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_stats.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_unused_structs.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_validate.cpp" />
+    <ClCompile Include="..\..\src\glsl\ir_variable_refcount.cpp" />
+    <ClCompile Include="..\..\src\glsl\link_atomics.cpp" />
+    <ClCompile Include="..\..\src\glsl\link_functions.cpp" />
+    <ClCompile Include="..\..\src\glsl\link_interface_blocks.cpp" />
+    <ClCompile Include="..\..\src\glsl\link_uniform_blocks.cpp" />
+    <ClCompile Include="..\..\src\glsl\link_uniform_block_active_visitor.cpp" />
+    <ClCompile Include="..\..\src\glsl\link_uniform_initializers.cpp" />
+    <ClCompile Include="..\..\src\glsl\link_uniforms.cpp" />
+    <ClCompile Include="..\..\src\glsl\linker.cpp" />
+    <ClCompile Include="..\..\src\glsl\link_varyings.cpp" />
+    <ClCompile Include="..\..\src\glsl\loop_analysis.cpp" />
+    <ClCompile Include="..\..\src\glsl\loop_controls.cpp" />
+    <ClCompile Include="..\..\src\glsl\loop_unroll.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_clip_distance.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_discard.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_discard_flow.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_if_to_cond_assign.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_instructions.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_jumps.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_mat_op_to_vec.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_named_interface_blocks.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_noise.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_offset_array.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_output_reads.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_packed_varyings.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_packing_builtins.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_ubo_reference.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_variable_index_to_cond_assign.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_vector_insert.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_vec_index_to_cond_assign.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_vec_index_to_swizzle.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_vector.cpp" />
+    <ClCompile Include="..\..\src\glsl\lower_vertex_id.cpp" />
+    <ClCompile Include="..\..\src\glsl\main.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_algebraic.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_array_splitting.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_constant_folding.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_constant_propagation.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_constant_variable.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_copy_propagation.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_copy_propagation_elements.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_cse.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_dead_builtin_variables.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_dead_builtin_varyings.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_dead_code.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_dead_code_local.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_dead_functions.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_flatten_nested_if_blocks.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_flip_matrices.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_function_inlining.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_if_simplification.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_minmax.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_noop_swizzle.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_rebalance_tree.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_redundant_jumps.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_structure_splitting.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_swizzle_swizzle.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_tree_grafting.cpp" />
+    <ClCompile Include="..\..\src\glsl\opt_vectorize.cpp" />
+    <ClCompile Include="..\..\src\glsl\s_expression.cpp" />
+    <ClCompile Include="..\..\src\glsl\standalone_scaffolding.cpp" />
+    <ClCompile Include="..\..\src\glsl\strtod.c" />
+    <ClCompile Include="..\..\src\glsl\glcpp\glcpp-lex.c" />
+    <ClCompile Include="..\..\src\glsl\glcpp\glcpp-parse.c" />
+    <ClCompile Include="..\..\src\glsl\glcpp\glcpp.c">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glcpp\pp.c" />
+    <ClCompile Include="..\..\src\mesa\main\imports.c" />
+    <ClCompile Include="..\..\src\mesa\program\prog_hash_table.c" />
+    <ClCompile Include="..\..\src\mesa\program\symbol_table.c" />
+    <ClCompile Include="..\..\src\util\hash_table.c" />
+    <ClCompile Include="..\..\src\util\ralloc.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <CustomBuildStep Include="..\..\src\glsl\glsl_lexer.lpp">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </CustomBuildStep>
+    <CustomBuildStep Include="..\..\src\glsl\glsl_parser.ypp">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </CustomBuildStep>
+    <CustomBuildStep Include="..\..\src\glsl\glcpp\glcpp-lex.l">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </CustomBuildStep>
+    <CustomBuildStep Include="..\..\src\glsl\glcpp\glcpp-parse.y">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </CustomBuildStep>
+    <None Include="..\..\README.md" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

3rdparty/bgfx/3rdparty/glsl-optimizer/projects/vs2010/glsl_optimizer_lib.vcxproj.filters

@@ -0,0 +1,518 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="src">
+      <UniqueIdentifier>{95543dab-5f63-41a8-8860-7e1659edc0b2}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="src\glsl">
+      <UniqueIdentifier>{c4cf23cb-22b9-4496-9cf7-8b25dc1e405f}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="src\glsl\glcpp">
+      <UniqueIdentifier>{7ec0058a-15c6-427d-9fce-27af39000e81}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="src\mesa">
+      <UniqueIdentifier>{28f43e08-dfe8-424d-886c-db6e2ee33957}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="src\mesa\program">
+      <UniqueIdentifier>{fd238409-ea7e-4bbe-8566-d5b8e7330242}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="src\mesa\main">
+      <UniqueIdentifier>{b58605f3-8f5a-4800-838c-a0a04d1bdc96}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\src\glsl\ast.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\glsl_optimizer.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\glsl_parser.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\glsl_parser_extras.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\glsl_symbol_table.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\glsl_types.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_basic_block.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_expression_flattening.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_function_inlining.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_hierarchical_visitor.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_optimization.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_print_glsl_visitor.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_print_metal_visitor.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_print_visitor.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_rvalue_visitor.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_unused_structs.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_variable_refcount.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_visitor.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\linker.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\list.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\loop_analysis.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\program.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\s_expression.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\standalone_scaffolding.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\strtod.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\glcpp\glcpp-parse.h">
+      <Filter>src\glsl\glcpp</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\glcpp\glcpp.h">
+      <Filter>src\glsl\glcpp</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\program\prog_instruction.h">
+      <Filter>src\mesa\program</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\program\prog_parameter.h">
+      <Filter>src\mesa\program</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\program\prog_statevars.h">
+      <Filter>src\mesa\program</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\program\symbol_table.h">
+      <Filter>src\mesa\program</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\compiler.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\config.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\context.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\core.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\dd.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\glheader.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\glminimal.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\imports.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\macros.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\mtypes.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\main\simple_list.h">
+      <Filter>src\mesa\main</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_uniform.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\mesa\program\hash_table.h">
+      <Filter>src\mesa\program</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\link_uniform_block_active_visitor.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\link_varyings.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_builder.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\builtin_type_macros.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\glsl\ir_stats.h">
+      <Filter>src\glsl</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\util\hash_table.h">
+      <Filter>src\util</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\util\ralloc.h">
+      <Filter>src\util</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\glsl\ast_expr.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ast_function.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ast_to_hir.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ast_type.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\builtin_functions.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\builtin_variables.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glsl_lexer.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glsl_optimizer.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glsl_parser.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glsl_parser_extras.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glsl_symbol_table.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glsl_types.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\hir_field_selection.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_basic_block.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_clone.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_constant_expression.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_equals.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_expression_flattening.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_function.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_function_can_inline.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_function_detect_recursion.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_hierarchical_visitor.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_hv_accept.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_import_prototypes.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_print_glsl_visitor.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_print_metal_visitor.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_print_visitor.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_rvalue_visitor.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_unused_structs.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_validate.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_variable_refcount.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\link_atomics.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\link_functions.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\link_uniform_initializers.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\link_uniforms.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\linker.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\loop_analysis.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\loop_controls.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\loop_unroll.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_clip_distance.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_discard.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_discard_flow.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_if_to_cond_assign.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_instructions.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_jumps.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_mat_op_to_vec.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_noise.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_variable_index_to_cond_assign.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_vec_index_to_cond_assign.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_vec_index_to_swizzle.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_vector.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\main.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_algebraic.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_array_splitting.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_constant_folding.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_constant_propagation.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_constant_variable.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_copy_propagation.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_copy_propagation_elements.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_cse.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_dead_code.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_dead_code_local.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_dead_functions.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_function_inlining.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_if_simplification.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_noop_swizzle.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_redundant_jumps.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_structure_splitting.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_swizzle_swizzle.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_tree_grafting.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_vectorize.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\s_expression.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\standalone_scaffolding.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\strtod.c">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glcpp\glcpp-lex.c">
+      <Filter>src\glsl\glcpp</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glcpp\glcpp-parse.c">
+      <Filter>src\glsl\glcpp</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glcpp\glcpp.c">
+      <Filter>src\glsl\glcpp</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\glcpp\pp.c">
+      <Filter>src\glsl\glcpp</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\mesa\program\symbol_table.c">
+      <Filter>src\mesa\program</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\mesa\main\imports.c">
+      <Filter>src\mesa\main</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\mesa\program\prog_hash_table.c">
+      <Filter>src\mesa\program</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ast_array_index.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\link_uniform_block_active_visitor.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\link_uniform_blocks.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\link_varyings.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_flatten_nested_if_blocks.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_builder.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_packed_varyings.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_packing_builtins.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\link_interface_blocks.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_named_interface_blocks.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_offset_array.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_output_reads.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_ubo_reference.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_vector_insert.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\lower_vertex_id.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\builtin_types.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_dead_builtin_variables.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_minmax.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_rebalance_tree.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_dead_builtin_varyings.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\opt_flip_matrices.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\glsl\ir_stats.cpp">
+      <Filter>src\glsl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\util\hash_table.c">
+      <Filter>src\util</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\util\ralloc.c">
+      <Filter>src\util</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\README.md" />
+  </ItemGroup>
+  <ItemGroup>
+    <CustomBuildStep Include="..\..\src\glsl\glsl_lexer.lpp">
+      <Filter>src\glsl</Filter>
+    </CustomBuildStep>
+    <CustomBuildStep Include="..\..\src\glsl\glsl_parser.ypp">
+      <Filter>src\glsl</Filter>
+    </CustomBuildStep>
+    <CustomBuildStep Include="..\..\src\glsl\glcpp\glcpp-lex.l">
+      <Filter>src\glsl\glcpp</Filter>
+    </CustomBuildStep>
+    <CustomBuildStep Include="..\..\src\glsl\glcpp\glcpp-parse.y">
+      <Filter>src\glsl\glcpp</Filter>
+    </CustomBuildStep>
+  </ItemGroup>
+</Project>

3rdparty/bgfx/3rdparty/glsl-optimizer/projects/vs2010/glsl_optimizer_tests.vcxproj

@@ -0,0 +1,186 @@
+<?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="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{BB382242-6EBB-445F-989C-B9BA61D17965}</ProjectGuid>
+    <RootNamespace>glsl_optimizer_tests</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</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)'=='Debug|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)'=='Release|x64'" 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|x64'" 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'">build/$(ProjectName)/$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">build/$(ProjectName)/$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
+    <GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</GenerateManifest>
+    <EmbedManifest Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</EmbedManifest>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">build/$(ProjectName)/$(Platform)/$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">build/$(ProjectName)/$(Platform)/$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
+    <GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</GenerateManifest>
+    <EmbedManifest Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</EmbedManifest>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">build/$(ProjectName)/$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">build/$(ProjectName)/$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</GenerateManifest>
+    <EmbedManifest Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</EmbedManifest>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">build/$(ProjectName)/$(Platform)/$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">build/$(ProjectName)/$(Platform)/$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
+    <GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</GenerateManifest>
+    <EmbedManifest Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</EmbedManifest>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>false</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>opengl32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>false</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>opengl32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <TargetMachine>MachineX64</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>opengl32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>opengl32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <TargetMachine>MachineX64</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="glsl_optimizer_lib.vcxproj">
+      <Project>{b475a403-9d9b-410d-8a93-ba49fc4dd811}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\tests\glsl_optimizer_tests.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

3rdparty/bgfx/3rdparty/glsl-optimizer/projects/xcode5/glsl_optimizer_lib.xcodeproj/project.pbxproj

@@ -0,0 +1,882 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		2B38545F1293BE5000F3E692 /* lower_if_to_cond_assign.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854481293BE5000F3E692 /* lower_if_to_cond_assign.cpp */; };
+		2B3854601293BE5000F3E692 /* lower_jumps.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854491293BE5000F3E692 /* lower_jumps.cpp */; };
+		2B3854611293BE5000F3E692 /* lower_mat_op_to_vec.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B38544A1293BE5000F3E692 /* lower_mat_op_to_vec.cpp */; };
+		2B3854641293BE5000F3E692 /* lower_vec_index_to_cond_assign.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B38544D1293BE5000F3E692 /* lower_vec_index_to_cond_assign.cpp */; };
+		2B3854651293BE5000F3E692 /* lower_vec_index_to_swizzle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B38544E1293BE5000F3E692 /* lower_vec_index_to_swizzle.cpp */; };
+		2B3854661293BE5000F3E692 /* opt_algebraic.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B38544F1293BE5000F3E692 /* opt_algebraic.cpp */; };
+		2B3854671293BE5000F3E692 /* opt_constant_folding.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854501293BE5000F3E692 /* opt_constant_folding.cpp */; };
+		2B3854681293BE5000F3E692 /* opt_constant_propagation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854511293BE5000F3E692 /* opt_constant_propagation.cpp */; };
+		2B3854691293BE5000F3E692 /* opt_constant_variable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854521293BE5000F3E692 /* opt_constant_variable.cpp */; };
+		2B38546A1293BE5000F3E692 /* opt_copy_propagation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854531293BE5000F3E692 /* opt_copy_propagation.cpp */; };
+		2B38546B1293BE5000F3E692 /* opt_dead_code_local.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854541293BE5000F3E692 /* opt_dead_code_local.cpp */; };
+		2B38546C1293BE5000F3E692 /* opt_dead_code.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854551293BE5000F3E692 /* opt_dead_code.cpp */; };
+		2B38546D1293BE5000F3E692 /* opt_dead_functions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854561293BE5000F3E692 /* opt_dead_functions.cpp */; };
+		2B38546E1293BE5000F3E692 /* opt_function_inlining.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854571293BE5000F3E692 /* opt_function_inlining.cpp */; };
+		2B38546F1293BE5000F3E692 /* opt_if_simplification.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854581293BE5000F3E692 /* opt_if_simplification.cpp */; };
+		2B3854701293BE5000F3E692 /* opt_noop_swizzle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3854591293BE5000F3E692 /* opt_noop_swizzle.cpp */; };
+		2B3854711293BE5000F3E692 /* opt_structure_splitting.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B38545A1293BE5000F3E692 /* opt_structure_splitting.cpp */; };
+		2B3854721293BE5000F3E692 /* opt_swizzle_swizzle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B38545B1293BE5000F3E692 /* opt_swizzle_swizzle.cpp */; };
+		2B3854731293BE5000F3E692 /* opt_tree_grafting.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B38545C1293BE5000F3E692 /* opt_tree_grafting.cpp */; };
+		2B39E41519E959F9001C6A17 /* hash_table.c in Sources */ = {isa = PBXBuildFile; fileRef = 2B39E41019E959F9001C6A17 /* hash_table.c */; };
+		2B39E41619E959F9001C6A17 /* hash_table.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B39E41119E959F9001C6A17 /* hash_table.h */; };
+		2B39E41719E959F9001C6A17 /* macros.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B39E41219E959F9001C6A17 /* macros.h */; };
+		2B39E41819E959F9001C6A17 /* ralloc.c in Sources */ = {isa = PBXBuildFile; fileRef = 2B39E41319E959F9001C6A17 /* ralloc.c */; };
+		2B39E41919E959F9001C6A17 /* ralloc.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B39E41419E959F9001C6A17 /* ralloc.h */; };
+		2B39E41F19E95FA7001C6A17 /* lower_offset_array.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B39E41A19E95FA7001C6A17 /* lower_offset_array.cpp */; };
+		2B39E42019E95FA7001C6A17 /* lower_vertex_id.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B39E41B19E95FA7001C6A17 /* lower_vertex_id.cpp */; };
+		2B39E42119E95FA7001C6A17 /* opt_dead_builtin_variables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B39E41C19E95FA7001C6A17 /* opt_dead_builtin_variables.cpp */; };
+		2B39E42219E95FA7001C6A17 /* opt_minmax.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B39E41D19E95FA7001C6A17 /* opt_minmax.cpp */; };
+		2B39E42319E95FA7001C6A17 /* opt_rebalance_tree.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B39E41E19E95FA7001C6A17 /* opt_rebalance_tree.cpp */; };
+		2B3A6B9015FA043D000DCBE1 /* link_uniforms.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3A6B8E15FA043D000DCBE1 /* link_uniforms.cpp */; };
+		2B3A6B9715FA0468000DCBE1 /* link_uniform_initializers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3A6B9515FA0468000DCBE1 /* link_uniform_initializers.cpp */; };
+		2B3A6BA815FA0494000DCBE1 /* lower_clip_distance.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3A6B9C15FA0494000DCBE1 /* lower_clip_distance.cpp */; };
+		2B3A6BA915FA0494000DCBE1 /* lower_discard_flow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3A6B9D15FA0494000DCBE1 /* lower_discard_flow.cpp */; };
+		2B3A6BAA15FA0494000DCBE1 /* lower_output_reads.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3A6B9E15FA0494000DCBE1 /* lower_output_reads.cpp */; };
+		2B3A6BAC15FA0494000DCBE1 /* lower_ubo_reference.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3A6BA015FA0494000DCBE1 /* lower_ubo_reference.cpp */; };
+		2B3A6BAD15FA0494000DCBE1 /* opt_array_splitting.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3A6BA115FA0494000DCBE1 /* opt_array_splitting.cpp */; };
+		2B3A6BDA15FA08E1000DCBE1 /* ir_builder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B3A6BD715FA08E1000DCBE1 /* ir_builder.cpp */; };
+		2B3A6BDB15FA08E1000DCBE1 /* ir_builder.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B3A6BD815FA08E1000DCBE1 /* ir_builder.h */; };
+		2B47DA011209C87B00937F2C /* prog_hash_table.c in Sources */ = {isa = PBXBuildFile; fileRef = 2B47D9FD1209C87B00937F2C /* prog_hash_table.c */; };
+		2B47DA021209C87B00937F2C /* hash_table.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B47D9FE1209C87B00937F2C /* hash_table.h */; };
+		2B47DA031209C87B00937F2C /* symbol_table.c in Sources */ = {isa = PBXBuildFile; fileRef = 2B47D9FF1209C87B00937F2C /* symbol_table.c */; };
+		2B47DA041209C87B00937F2C /* symbol_table.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B47DA001209C87B00937F2C /* symbol_table.h */; };
+		2B62491112191339003F6EEE /* ir_rvalue_visitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B62490D12191339003F6EEE /* ir_rvalue_visitor.cpp */; };
+		2B62491212191339003F6EEE /* ir_rvalue_visitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B62490E12191339003F6EEE /* ir_rvalue_visitor.h */; };
+		2B655A7313E0322E00B5278F /* ir_function_detect_recursion.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B655A7113E0322E00B5278F /* ir_function_detect_recursion.cpp */; };
+		2B655A7913E0324F00B5278F /* standalone_scaffolding.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B655A7613E0324F00B5278F /* standalone_scaffolding.cpp */; };
+		2B655A7A13E0324F00B5278F /* standalone_scaffolding.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B655A7713E0324F00B5278F /* standalone_scaffolding.h */; };
+		2B6A99F41223B1670059FBED /* glcpp-lex.c in Sources */ = {isa = PBXBuildFile; fileRef = 2B6A99EC1223B1670059FBED /* glcpp-lex.c */; };
+		2B6A99F61223B1670059FBED /* glcpp-parse.c in Sources */ = {isa = PBXBuildFile; fileRef = 2B6A99EE1223B1670059FBED /* glcpp-parse.c */; };
+		2B6A99F71223B1670059FBED /* glcpp-parse.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B6A99EF1223B1670059FBED /* glcpp-parse.h */; };
+		2B6A99FA1223B1670059FBED /* glcpp.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B6A99F21223B1670059FBED /* glcpp.h */; };
+		2B6A99FB1223B1670059FBED /* pp.c in Sources */ = {isa = PBXBuildFile; fileRef = 2B6A99F31223B1670059FBED /* pp.c */; };
+		2B6AC7B9161EC99C0094FD86 /* prog_instruction.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B6AC7B5161EC99C0094FD86 /* prog_instruction.h */; };
+		2B6AC7BA161EC99C0094FD86 /* prog_parameter.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B6AC7B6161EC99C0094FD86 /* prog_parameter.h */; };
+		2B6AC7BB161EC99C0094FD86 /* prog_statevars.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B6AC7B7161EC99C0094FD86 /* prog_statevars.h */; };
+		2B6AC7BD161EC9D40094FD86 /* ir_uniform.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B6AC7BC161EC9D40094FD86 /* ir_uniform.h */; };
+		2B6AC8AD161ED9080094FD86 /* glminimal.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B6AC8AC161ED9080094FD86 /* glminimal.h */; };
+		2B78C91D1858B052007F5D2A /* ir_equals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B78C91C1858B052007F5D2A /* ir_equals.cpp */; };
+		2B8979DE182C0C4700718F8A /* builtin_functions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B8979DD182C0C4700718F8A /* builtin_functions.cpp */; };
+		2B8979E0182C195C00718F8A /* opt_cse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B8979DF182C195C00718F8A /* opt_cse.cpp */; };
+		2B8979E2182CB62900718F8A /* link_atomics.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B8979E1182CB62900718F8A /* link_atomics.cpp */; };
+		2B92A05E15F9FF4700CFED4A /* builtin_variables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B92A05C15F9FF4700CFED4A /* builtin_variables.cpp */; };
+		2B9F0A3D189664F3002FF617 /* opt_vectorize.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B9F0A3C189664F3002FF617 /* opt_vectorize.cpp */; };
+		2BA55A9C1207FEA6002DC82D /* ast_expr.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A511207FEA6002DC82D /* ast_expr.cpp */; };
+		2BA55A9D1207FEA6002DC82D /* ast_function.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A521207FEA6002DC82D /* ast_function.cpp */; };
+		2BA55A9E1207FEA6002DC82D /* ast_to_hir.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A531207FEA6002DC82D /* ast_to_hir.cpp */; };
+		2BA55A9F1207FEA6002DC82D /* ast_type.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A541207FEA6002DC82D /* ast_type.cpp */; };
+		2BA55AA01207FEA6002DC82D /* ast.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A551207FEA6002DC82D /* ast.h */; };
+		2BA55AA41207FEA6002DC82D /* glsl_lexer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A591207FEA6002DC82D /* glsl_lexer.cpp */; };
+		2BA55AA61207FEA6002DC82D /* glsl_optimizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A5B1207FEA6002DC82D /* glsl_optimizer.cpp */; };
+		2BA55AA71207FEA6002DC82D /* glsl_optimizer.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A5C1207FEA6002DC82D /* glsl_optimizer.h */; };
+		2BA55AA81207FEA6002DC82D /* glsl_parser_extras.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A5D1207FEA6002DC82D /* glsl_parser_extras.cpp */; };
+		2BA55AA91207FEA6002DC82D /* glsl_parser_extras.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A5E1207FEA6002DC82D /* glsl_parser_extras.h */; };
+		2BA55AAA1207FEA6002DC82D /* glsl_parser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A5F1207FEA6002DC82D /* glsl_parser.cpp */; };
+		2BA55AAB1207FEA6002DC82D /* glsl_parser.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A601207FEA6002DC82D /* glsl_parser.h */; };
+		2BA55AAD1207FEA6002DC82D /* glsl_symbol_table.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A621207FEA6002DC82D /* glsl_symbol_table.h */; };
+		2BA55AAE1207FEA6002DC82D /* glsl_types.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A631207FEA6002DC82D /* glsl_types.cpp */; };
+		2BA55AAF1207FEA6002DC82D /* glsl_types.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A641207FEA6002DC82D /* glsl_types.h */; };
+		2BA55AB01207FEA6002DC82D /* hir_field_selection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A651207FEA6002DC82D /* hir_field_selection.cpp */; };
+		2BA55AB21207FEA6002DC82D /* ir_basic_block.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A671207FEA6002DC82D /* ir_basic_block.cpp */; };
+		2BA55AB31207FEA6002DC82D /* ir_basic_block.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A681207FEA6002DC82D /* ir_basic_block.h */; };
+		2BA55AB41207FEA6002DC82D /* ir_clone.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A691207FEA6002DC82D /* ir_clone.cpp */; };
+		2BA55AB51207FEA6002DC82D /* ir_constant_expression.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A6A1207FEA6002DC82D /* ir_constant_expression.cpp */; };
+		2BA55ABC1207FEA6002DC82D /* ir_expression_flattening.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A711207FEA6002DC82D /* ir_expression_flattening.cpp */; };
+		2BA55ABD1207FEA6002DC82D /* ir_expression_flattening.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A721207FEA6002DC82D /* ir_expression_flattening.h */; };
+		2BA55ABE1207FEA6002DC82D /* ir_function_can_inline.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A731207FEA6002DC82D /* ir_function_can_inline.cpp */; };
+		2BA55AC01207FEA6002DC82D /* ir_function_inlining.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A751207FEA6002DC82D /* ir_function_inlining.h */; };
+		2BA55AC11207FEA6002DC82D /* ir_function.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A761207FEA6002DC82D /* ir_function.cpp */; };
+		2BA55AC21207FEA6002DC82D /* ir_hierarchical_visitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A771207FEA6002DC82D /* ir_hierarchical_visitor.cpp */; };
+		2BA55AC31207FEA6002DC82D /* ir_hierarchical_visitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A781207FEA6002DC82D /* ir_hierarchical_visitor.h */; };
+		2BA55AC41207FEA6002DC82D /* ir_hv_accept.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A791207FEA6002DC82D /* ir_hv_accept.cpp */; };
+		2BA55AC81207FEA6002DC82D /* ir_import_prototypes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A7D1207FEA6002DC82D /* ir_import_prototypes.cpp */; };
+		2BA55ACB1207FEA6002DC82D /* ir_optimization.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A801207FEA6002DC82D /* ir_optimization.h */; };
+		2BA55ACC1207FEA6002DC82D /* ir_print_glsl_visitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A811207FEA6002DC82D /* ir_print_glsl_visitor.cpp */; };
+		2BA55ACD1207FEA6002DC82D /* ir_print_glsl_visitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A821207FEA6002DC82D /* ir_print_glsl_visitor.h */; };
+		2BA55ACE1207FEA6002DC82D /* ir_print_visitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A831207FEA6002DC82D /* ir_print_visitor.cpp */; };
+		2BA55ACF1207FEA6002DC82D /* ir_print_visitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A841207FEA6002DC82D /* ir_print_visitor.h */; };
+		2BA55AD51207FEA6002DC82D /* ir_unused_structs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A8A1207FEA6002DC82D /* ir_unused_structs.cpp */; };
+		2BA55AD61207FEA6002DC82D /* ir_unused_structs.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A8B1207FEA6002DC82D /* ir_unused_structs.h */; };
+		2BA55AD71207FEA6002DC82D /* ir_validate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A8C1207FEA6002DC82D /* ir_validate.cpp */; };
+		2BA55AD81207FEA6002DC82D /* ir_variable_refcount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A8D1207FEA6002DC82D /* ir_variable_refcount.cpp */; };
+		2BA55AD91207FEA6002DC82D /* ir_variable_refcount.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A8E1207FEA6002DC82D /* ir_variable_refcount.h */; };
+		2BA55ADD1207FEA6002DC82D /* ir_visitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A921207FEA6002DC82D /* ir_visitor.h */; };
+		2BA55ADE1207FEA6002DC82D /* ir.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A931207FEA6002DC82D /* ir.cpp */; };
+		2BA55ADF1207FEA6002DC82D /* ir.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A941207FEA6002DC82D /* ir.h */; };
+		2BA55AE01207FEA6002DC82D /* link_functions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A951207FEA6002DC82D /* link_functions.cpp */; };
+		2BA55AE11207FEA6002DC82D /* linker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A961207FEA6002DC82D /* linker.cpp */; };
+		2BA55AE21207FEA6002DC82D /* linker.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A971207FEA6002DC82D /* linker.h */; };
+		2BA55AE31207FEA6002DC82D /* list.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A981207FEA6002DC82D /* list.h */; };
+		2BA55AE41207FEA6002DC82D /* program.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A991207FEA6002DC82D /* program.h */; };
+		2BA55AE51207FEA6002DC82D /* s_expression.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA55A9A1207FEA6002DC82D /* s_expression.cpp */; };
+		2BA55AE61207FEA6002DC82D /* s_expression.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA55A9B1207FEA6002DC82D /* s_expression.h */; };
+		2BA7E13F17D0AEB200D5C475 /* builtin_type_macros.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BA7E13817D0AEB200D5C475 /* builtin_type_macros.h */; };
+		2BA7E14017D0AEB200D5C475 /* builtin_types.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA7E13917D0AEB200D5C475 /* builtin_types.cpp */; };
+		2BA7E14217D0AEB200D5C475 /* link_interface_blocks.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA7E13A17D0AEB200D5C475 /* link_interface_blocks.cpp */; };
+		2BA7E14417D0AEB200D5C475 /* lower_named_interface_blocks.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA7E13B17D0AEB200D5C475 /* lower_named_interface_blocks.cpp */; };
+		2BA7E14617D0AEB200D5C475 /* lower_vector_insert.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA7E13C17D0AEB200D5C475 /* lower_vector_insert.cpp */; };
+		2BA7E14817D0AEB200D5C475 /* opt_dead_builtin_varyings.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA7E13D17D0AEB200D5C475 /* opt_dead_builtin_varyings.cpp */; };
+		2BA7E14A17D0AEB200D5C475 /* opt_flip_matrices.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BA7E13E17D0AEB200D5C475 /* opt_flip_matrices.cpp */; };
+		2BB2F5B012B8F1580052C6B0 /* lower_discard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BB2F5AA12B8F1580052C6B0 /* lower_discard.cpp */; };
+		2BB2F5B112B8F1580052C6B0 /* lower_instructions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BB2F5AB12B8F1580052C6B0 /* lower_instructions.cpp */; };
+		2BB2F5B212B8F1580052C6B0 /* lower_vector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BB2F5AC12B8F1580052C6B0 /* lower_vector.cpp */; };
+		2BB2F5B412B8F1580052C6B0 /* strtod.c in Sources */ = {isa = PBXBuildFile; fileRef = 2BB2F5AE12B8F1580052C6B0 /* strtod.c */; };
+		2BB2F5B512B8F1580052C6B0 /* strtod.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB2F5AF12B8F1580052C6B0 /* strtod.h */; };
+		2BB725A9135094BE0057D8B5 /* compiler.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB7259B135094BE0057D8B5 /* compiler.h */; };
+		2BB725AA135094BE0057D8B5 /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB7259C135094BE0057D8B5 /* config.h */; };
+		2BB725AB135094BE0057D8B5 /* context.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB7259D135094BE0057D8B5 /* context.h */; };
+		2BB725AC135094BE0057D8B5 /* core.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB7259E135094BE0057D8B5 /* core.h */; };
+		2BB725AD135094BE0057D8B5 /* dd.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB7259F135094BE0057D8B5 /* dd.h */; };
+		2BB725AF135094BE0057D8B5 /* glheader.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB725A1135094BE0057D8B5 /* glheader.h */; };
+		2BB725B0135094BE0057D8B5 /* imports.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB725A2135094BE0057D8B5 /* imports.h */; };
+		2BB725B1135094BE0057D8B5 /* macros.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB725A3135094BE0057D8B5 /* macros.h */; };
+		2BB725B3135094BE0057D8B5 /* mtypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB725A5135094BE0057D8B5 /* mtypes.h */; };
+		2BB725B5135094BE0057D8B5 /* simple_list.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BB725A7135094BE0057D8B5 /* simple_list.h */; };
+		2BBA49281254706A00D42573 /* glsl_symbol_table.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBA491F1254706A00D42573 /* glsl_symbol_table.cpp */; };
+		2BBA492A1254706A00D42573 /* loop_analysis.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBA49211254706A00D42573 /* loop_analysis.cpp */; };
+		2BBA492B1254706A00D42573 /* loop_analysis.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BBA49221254706A00D42573 /* loop_analysis.h */; };
+		2BBA492C1254706A00D42573 /* loop_controls.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBA49231254706A00D42573 /* loop_controls.cpp */; };
+		2BBA492D1254706A00D42573 /* loop_unroll.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBA49241254706A00D42573 /* loop_unroll.cpp */; };
+		2BBA492E1254706A00D42573 /* lower_noise.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBA49251254706A00D42573 /* lower_noise.cpp */; };
+		2BBA492F1254706A00D42573 /* lower_variable_index_to_cond_assign.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBA49261254706A00D42573 /* lower_variable_index_to_cond_assign.cpp */; };
+		2BBA49301254706A00D42573 /* opt_redundant_jumps.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBA49271254706A00D42573 /* opt_redundant_jumps.cpp */; };
+		2BBD9DAD1719694100515007 /* ast_array_index.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBD9DA91719693E00515007 /* ast_array_index.cpp */; };
+		2BBD9DAF1719694100515007 /* link_uniform_block_active_visitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBD9DAA1719693F00515007 /* link_uniform_block_active_visitor.cpp */; };
+		2BBD9DB11719694100515007 /* link_uniform_block_active_visitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BBD9DAB1719694000515007 /* link_uniform_block_active_visitor.h */; };
+		2BBD9DB21719694100515007 /* link_uniform_blocks.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBD9DAC1719694100515007 /* link_uniform_blocks.cpp */; };
+		2BBD9DB91719698C00515007 /* link_varyings.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBD9DB41719698800515007 /* link_varyings.cpp */; };
+		2BBD9DBB1719698C00515007 /* link_varyings.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BBD9DB51719698900515007 /* link_varyings.h */; };
+		2BBD9DBC1719698C00515007 /* lower_packed_varyings.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBD9DB61719698900515007 /* lower_packed_varyings.cpp */; };
+		2BBD9DBE1719698C00515007 /* lower_packing_builtins.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBD9DB71719698A00515007 /* lower_packing_builtins.cpp */; };
+		2BBD9DC01719698C00515007 /* opt_flatten_nested_if_blocks.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BBD9DB81719698B00515007 /* opt_flatten_nested_if_blocks.cpp */; };
+		2BBD9DC817196A3B00515007 /* imports.c in Sources */ = {isa = PBXBuildFile; fileRef = 2BBD9DC717196A3B00515007 /* imports.c */; };
+		2BCF3A8D19ADE1E50057C395 /* ir_print_metal_visitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BCF3A8B19ADE1E50057C395 /* ir_print_metal_visitor.cpp */; };
+		2BCF3A8E19ADE1E50057C395 /* ir_print_metal_visitor.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BCF3A8C19ADE1E50057C395 /* ir_print_metal_visitor.h */; };
+		2BDCB95D184E182B0075CE6F /* ir_stats.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BDCB95B184E182B0075CE6F /* ir_stats.cpp */; };
+		2BDCB95E184E182B0075CE6F /* ir_stats.h in Headers */ = {isa = PBXBuildFile; fileRef = 2BDCB95C184E182B0075CE6F /* ir_stats.h */; };
+		2BEC22EA1356E98300B5E301 /* opt_copy_propagation_elements.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2BEC22CB1356E94E00B5E301 /* opt_copy_propagation_elements.cpp */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		2B3854481293BE5000F3E692 /* lower_if_to_cond_assign.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_if_to_cond_assign.cpp; path = ../../src/glsl/lower_if_to_cond_assign.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854491293BE5000F3E692 /* lower_jumps.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_jumps.cpp; path = ../../src/glsl/lower_jumps.cpp; sourceTree = SOURCE_ROOT; };
+		2B38544A1293BE5000F3E692 /* lower_mat_op_to_vec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_mat_op_to_vec.cpp; path = ../../src/glsl/lower_mat_op_to_vec.cpp; sourceTree = SOURCE_ROOT; };
+		2B38544D1293BE5000F3E692 /* lower_vec_index_to_cond_assign.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_vec_index_to_cond_assign.cpp; path = ../../src/glsl/lower_vec_index_to_cond_assign.cpp; sourceTree = SOURCE_ROOT; };
+		2B38544E1293BE5000F3E692 /* lower_vec_index_to_swizzle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_vec_index_to_swizzle.cpp; path = ../../src/glsl/lower_vec_index_to_swizzle.cpp; sourceTree = SOURCE_ROOT; };
+		2B38544F1293BE5000F3E692 /* opt_algebraic.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_algebraic.cpp; path = ../../src/glsl/opt_algebraic.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854501293BE5000F3E692 /* opt_constant_folding.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_constant_folding.cpp; path = ../../src/glsl/opt_constant_folding.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854511293BE5000F3E692 /* opt_constant_propagation.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_constant_propagation.cpp; path = ../../src/glsl/opt_constant_propagation.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854521293BE5000F3E692 /* opt_constant_variable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_constant_variable.cpp; path = ../../src/glsl/opt_constant_variable.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854531293BE5000F3E692 /* opt_copy_propagation.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_copy_propagation.cpp; path = ../../src/glsl/opt_copy_propagation.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854541293BE5000F3E692 /* opt_dead_code_local.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_dead_code_local.cpp; path = ../../src/glsl/opt_dead_code_local.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854551293BE5000F3E692 /* opt_dead_code.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_dead_code.cpp; path = ../../src/glsl/opt_dead_code.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854561293BE5000F3E692 /* opt_dead_functions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_dead_functions.cpp; path = ../../src/glsl/opt_dead_functions.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854571293BE5000F3E692 /* opt_function_inlining.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_function_inlining.cpp; path = ../../src/glsl/opt_function_inlining.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854581293BE5000F3E692 /* opt_if_simplification.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_if_simplification.cpp; path = ../../src/glsl/opt_if_simplification.cpp; sourceTree = SOURCE_ROOT; };
+		2B3854591293BE5000F3E692 /* opt_noop_swizzle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_noop_swizzle.cpp; path = ../../src/glsl/opt_noop_swizzle.cpp; sourceTree = SOURCE_ROOT; };
+		2B38545A1293BE5000F3E692 /* opt_structure_splitting.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_structure_splitting.cpp; path = ../../src/glsl/opt_structure_splitting.cpp; sourceTree = SOURCE_ROOT; };
+		2B38545B1293BE5000F3E692 /* opt_swizzle_swizzle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_swizzle_swizzle.cpp; path = ../../src/glsl/opt_swizzle_swizzle.cpp; sourceTree = SOURCE_ROOT; };
+		2B38545C1293BE5000F3E692 /* opt_tree_grafting.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_tree_grafting.cpp; path = ../../src/glsl/opt_tree_grafting.cpp; sourceTree = SOURCE_ROOT; };
+		2B39E41019E959F9001C6A17 /* hash_table.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = hash_table.c; path = ../../src/util/hash_table.c; sourceTree = "<group>"; };
+		2B39E41119E959F9001C6A17 /* hash_table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = hash_table.h; path = ../../src/util/hash_table.h; sourceTree = "<group>"; };
+		2B39E41219E959F9001C6A17 /* macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = macros.h; path = ../../src/util/macros.h; sourceTree = "<group>"; };
+		2B39E41319E959F9001C6A17 /* ralloc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ralloc.c; path = ../../src/util/ralloc.c; sourceTree = "<group>"; };
+		2B39E41419E959F9001C6A17 /* ralloc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ralloc.h; path = ../../src/util/ralloc.h; sourceTree = "<group>"; };
+		2B39E41A19E95FA7001C6A17 /* lower_offset_array.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_offset_array.cpp; path = ../../src/glsl/lower_offset_array.cpp; sourceTree = "<group>"; };
+		2B39E41B19E95FA7001C6A17 /* lower_vertex_id.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_vertex_id.cpp; path = ../../src/glsl/lower_vertex_id.cpp; sourceTree = "<group>"; };
+		2B39E41C19E95FA7001C6A17 /* opt_dead_builtin_variables.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_dead_builtin_variables.cpp; path = ../../src/glsl/opt_dead_builtin_variables.cpp; sourceTree = "<group>"; };
+		2B39E41D19E95FA7001C6A17 /* opt_minmax.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_minmax.cpp; path = ../../src/glsl/opt_minmax.cpp; sourceTree = "<group>"; };
+		2B39E41E19E95FA7001C6A17 /* opt_rebalance_tree.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_rebalance_tree.cpp; path = ../../src/glsl/opt_rebalance_tree.cpp; sourceTree = "<group>"; };
+		2B3A6B8E15FA043D000DCBE1 /* link_uniforms.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = link_uniforms.cpp; path = ../../src/glsl/link_uniforms.cpp; sourceTree = SOURCE_ROOT; };
+		2B3A6B9515FA0468000DCBE1 /* link_uniform_initializers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = link_uniform_initializers.cpp; path = ../../src/glsl/link_uniform_initializers.cpp; sourceTree = SOURCE_ROOT; };
+		2B3A6B9C15FA0494000DCBE1 /* lower_clip_distance.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_clip_distance.cpp; path = ../../src/glsl/lower_clip_distance.cpp; sourceTree = SOURCE_ROOT; };
+		2B3A6B9D15FA0494000DCBE1 /* lower_discard_flow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_discard_flow.cpp; path = ../../src/glsl/lower_discard_flow.cpp; sourceTree = SOURCE_ROOT; };
+		2B3A6B9E15FA0494000DCBE1 /* lower_output_reads.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_output_reads.cpp; path = ../../src/glsl/lower_output_reads.cpp; sourceTree = SOURCE_ROOT; };
+		2B3A6BA015FA0494000DCBE1 /* lower_ubo_reference.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_ubo_reference.cpp; path = ../../src/glsl/lower_ubo_reference.cpp; sourceTree = SOURCE_ROOT; };
+		2B3A6BA115FA0494000DCBE1 /* opt_array_splitting.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_array_splitting.cpp; path = ../../src/glsl/opt_array_splitting.cpp; sourceTree = SOURCE_ROOT; };
+		2B3A6BD715FA08E1000DCBE1 /* ir_builder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_builder.cpp; path = ../../src/glsl/ir_builder.cpp; sourceTree = SOURCE_ROOT; };
+		2B3A6BD815FA08E1000DCBE1 /* ir_builder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_builder.h; path = ../../src/glsl/ir_builder.h; sourceTree = SOURCE_ROOT; };
+		2B47D9FD1209C87B00937F2C /* prog_hash_table.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = prog_hash_table.c; path = ../../src/mesa/program/prog_hash_table.c; sourceTree = SOURCE_ROOT; };
+		2B47D9FE1209C87B00937F2C /* hash_table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = hash_table.h; path = ../../src/mesa/program/hash_table.h; sourceTree = SOURCE_ROOT; };
+		2B47D9FF1209C87B00937F2C /* symbol_table.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = symbol_table.c; path = ../../src/mesa/program/symbol_table.c; sourceTree = SOURCE_ROOT; };
+		2B47DA001209C87B00937F2C /* symbol_table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = symbol_table.h; path = ../../src/mesa/program/symbol_table.h; sourceTree = SOURCE_ROOT; };
+		2B62490D12191339003F6EEE /* ir_rvalue_visitor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_rvalue_visitor.cpp; path = ../../src/glsl/ir_rvalue_visitor.cpp; sourceTree = SOURCE_ROOT; };
+		2B62490E12191339003F6EEE /* ir_rvalue_visitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_rvalue_visitor.h; path = ../../src/glsl/ir_rvalue_visitor.h; sourceTree = SOURCE_ROOT; };
+		2B655A7113E0322E00B5278F /* ir_function_detect_recursion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_function_detect_recursion.cpp; path = ../../src/glsl/ir_function_detect_recursion.cpp; sourceTree = SOURCE_ROOT; };
+		2B655A7613E0324F00B5278F /* standalone_scaffolding.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = standalone_scaffolding.cpp; path = ../../src/glsl/standalone_scaffolding.cpp; sourceTree = SOURCE_ROOT; };
+		2B655A7713E0324F00B5278F /* standalone_scaffolding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = standalone_scaffolding.h; path = ../../src/glsl/standalone_scaffolding.h; sourceTree = SOURCE_ROOT; };
+		2B6A99EC1223B1670059FBED /* glcpp-lex.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = "glcpp-lex.c"; path = "../../src/glsl/glcpp/glcpp-lex.c"; sourceTree = SOURCE_ROOT; };
+		2B6A99ED1223B1670059FBED /* glcpp-lex.l */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.lex; name = "glcpp-lex.l"; path = "../../src/glsl/glcpp/glcpp-lex.l"; sourceTree = SOURCE_ROOT; };
+		2B6A99EE1223B1670059FBED /* glcpp-parse.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = "glcpp-parse.c"; path = "../../src/glsl/glcpp/glcpp-parse.c"; sourceTree = SOURCE_ROOT; };
+		2B6A99EF1223B1670059FBED /* glcpp-parse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "glcpp-parse.h"; path = "../../src/glsl/glcpp/glcpp-parse.h"; sourceTree = SOURCE_ROOT; };
+		2B6A99F01223B1670059FBED /* glcpp-parse.y */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.yacc; name = "glcpp-parse.y"; path = "../../src/glsl/glcpp/glcpp-parse.y"; sourceTree = SOURCE_ROOT; };
+		2B6A99F21223B1670059FBED /* glcpp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = glcpp.h; path = ../../src/glsl/glcpp/glcpp.h; sourceTree = SOURCE_ROOT; };
+		2B6A99F31223B1670059FBED /* pp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pp.c; path = ../../src/glsl/glcpp/pp.c; sourceTree = SOURCE_ROOT; };
+		2B6AC7B5161EC99C0094FD86 /* prog_instruction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = prog_instruction.h; path = ../../src/mesa/program/prog_instruction.h; sourceTree = SOURCE_ROOT; };
+		2B6AC7B6161EC99C0094FD86 /* prog_parameter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = prog_parameter.h; path = ../../src/mesa/program/prog_parameter.h; sourceTree = SOURCE_ROOT; };
+		2B6AC7B7161EC99C0094FD86 /* prog_statevars.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = prog_statevars.h; path = ../../src/mesa/program/prog_statevars.h; sourceTree = SOURCE_ROOT; };
+		2B6AC7BC161EC9D40094FD86 /* ir_uniform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_uniform.h; path = ../../src/glsl/ir_uniform.h; sourceTree = SOURCE_ROOT; };
+		2B6AC8AC161ED9080094FD86 /* glminimal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = glminimal.h; path = ../../src/mesa/main/glminimal.h; sourceTree = SOURCE_ROOT; };
+		2B78C91C1858B052007F5D2A /* ir_equals.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_equals.cpp; path = ../../src/glsl/ir_equals.cpp; sourceTree = "<group>"; };
+		2B8979DD182C0C4700718F8A /* builtin_functions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = builtin_functions.cpp; path = ../../src/glsl/builtin_functions.cpp; sourceTree = "<group>"; };
+		2B8979DF182C195C00718F8A /* opt_cse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_cse.cpp; path = ../../src/glsl/opt_cse.cpp; sourceTree = "<group>"; };
+		2B8979E1182CB62900718F8A /* link_atomics.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = link_atomics.cpp; path = ../../src/glsl/link_atomics.cpp; sourceTree = "<group>"; };
+		2B92A05C15F9FF4700CFED4A /* builtin_variables.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = builtin_variables.cpp; path = ../../src/glsl/builtin_variables.cpp; sourceTree = SOURCE_ROOT; };
+		2B9F0A3C189664F3002FF617 /* opt_vectorize.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_vectorize.cpp; path = ../../src/glsl/opt_vectorize.cpp; sourceTree = "<group>"; };
+		2BA0808A1352EBFB00A1C074 /* main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = main.cpp; path = ../../src/glsl/main.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A511207FEA6002DC82D /* ast_expr.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ast_expr.cpp; path = ../../src/glsl/ast_expr.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A521207FEA6002DC82D /* ast_function.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ast_function.cpp; path = ../../src/glsl/ast_function.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A531207FEA6002DC82D /* ast_to_hir.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ast_to_hir.cpp; path = ../../src/glsl/ast_to_hir.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A541207FEA6002DC82D /* ast_type.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ast_type.cpp; path = ../../src/glsl/ast_type.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A551207FEA6002DC82D /* ast.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ast.h; path = ../../src/glsl/ast.h; sourceTree = SOURCE_ROOT; };
+		2BA55A591207FEA6002DC82D /* glsl_lexer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = glsl_lexer.cpp; path = ../../src/glsl/glsl_lexer.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A5A1207FEA6002DC82D /* glsl_lexer.ll */ = {isa = PBXFileReference; explicitFileType = sourcecode.lex; fileEncoding = 4; name = glsl_lexer.ll; path = ../../src/glsl/glsl_lexer.ll; sourceTree = SOURCE_ROOT; };
+		2BA55A5B1207FEA6002DC82D /* glsl_optimizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = glsl_optimizer.cpp; path = ../../src/glsl/glsl_optimizer.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A5C1207FEA6002DC82D /* glsl_optimizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = glsl_optimizer.h; path = ../../src/glsl/glsl_optimizer.h; sourceTree = SOURCE_ROOT; };
+		2BA55A5D1207FEA6002DC82D /* glsl_parser_extras.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = glsl_parser_extras.cpp; path = ../../src/glsl/glsl_parser_extras.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A5E1207FEA6002DC82D /* glsl_parser_extras.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = glsl_parser_extras.h; path = ../../src/glsl/glsl_parser_extras.h; sourceTree = SOURCE_ROOT; };
+		2BA55A5F1207FEA6002DC82D /* glsl_parser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = glsl_parser.cpp; path = ../../src/glsl/glsl_parser.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A601207FEA6002DC82D /* glsl_parser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = glsl_parser.h; path = ../../src/glsl/glsl_parser.h; sourceTree = SOURCE_ROOT; };
+		2BA55A611207FEA6002DC82D /* glsl_parser.yy */ = {isa = PBXFileReference; explicitFileType = sourcecode.yacc; fileEncoding = 4; name = glsl_parser.yy; path = ../../src/glsl/glsl_parser.yy; sourceTree = SOURCE_ROOT; };
+		2BA55A621207FEA6002DC82D /* glsl_symbol_table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = glsl_symbol_table.h; path = ../../src/glsl/glsl_symbol_table.h; sourceTree = SOURCE_ROOT; };
+		2BA55A631207FEA6002DC82D /* glsl_types.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = glsl_types.cpp; path = ../../src/glsl/glsl_types.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A641207FEA6002DC82D /* glsl_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = glsl_types.h; path = ../../src/glsl/glsl_types.h; sourceTree = SOURCE_ROOT; };
+		2BA55A651207FEA6002DC82D /* hir_field_selection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = hir_field_selection.cpp; path = ../../src/glsl/hir_field_selection.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A671207FEA6002DC82D /* ir_basic_block.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_basic_block.cpp; path = ../../src/glsl/ir_basic_block.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A681207FEA6002DC82D /* ir_basic_block.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_basic_block.h; path = ../../src/glsl/ir_basic_block.h; sourceTree = SOURCE_ROOT; };
+		2BA55A691207FEA6002DC82D /* ir_clone.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_clone.cpp; path = ../../src/glsl/ir_clone.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A6A1207FEA6002DC82D /* ir_constant_expression.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_constant_expression.cpp; path = ../../src/glsl/ir_constant_expression.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A711207FEA6002DC82D /* ir_expression_flattening.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_expression_flattening.cpp; path = ../../src/glsl/ir_expression_flattening.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A721207FEA6002DC82D /* ir_expression_flattening.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_expression_flattening.h; path = ../../src/glsl/ir_expression_flattening.h; sourceTree = SOURCE_ROOT; };
+		2BA55A731207FEA6002DC82D /* ir_function_can_inline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_function_can_inline.cpp; path = ../../src/glsl/ir_function_can_inline.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A751207FEA6002DC82D /* ir_function_inlining.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_function_inlining.h; path = ../../src/glsl/ir_function_inlining.h; sourceTree = SOURCE_ROOT; };
+		2BA55A761207FEA6002DC82D /* ir_function.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_function.cpp; path = ../../src/glsl/ir_function.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A771207FEA6002DC82D /* ir_hierarchical_visitor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_hierarchical_visitor.cpp; path = ../../src/glsl/ir_hierarchical_visitor.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A781207FEA6002DC82D /* ir_hierarchical_visitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_hierarchical_visitor.h; path = ../../src/glsl/ir_hierarchical_visitor.h; sourceTree = SOURCE_ROOT; };
+		2BA55A791207FEA6002DC82D /* ir_hv_accept.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_hv_accept.cpp; path = ../../src/glsl/ir_hv_accept.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A7D1207FEA6002DC82D /* ir_import_prototypes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_import_prototypes.cpp; path = ../../src/glsl/ir_import_prototypes.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A801207FEA6002DC82D /* ir_optimization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_optimization.h; path = ../../src/glsl/ir_optimization.h; sourceTree = SOURCE_ROOT; };
+		2BA55A811207FEA6002DC82D /* ir_print_glsl_visitor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_print_glsl_visitor.cpp; path = ../../src/glsl/ir_print_glsl_visitor.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A821207FEA6002DC82D /* ir_print_glsl_visitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_print_glsl_visitor.h; path = ../../src/glsl/ir_print_glsl_visitor.h; sourceTree = SOURCE_ROOT; };
+		2BA55A831207FEA6002DC82D /* ir_print_visitor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_print_visitor.cpp; path = ../../src/glsl/ir_print_visitor.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A841207FEA6002DC82D /* ir_print_visitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_print_visitor.h; path = ../../src/glsl/ir_print_visitor.h; sourceTree = SOURCE_ROOT; };
+		2BA55A8A1207FEA6002DC82D /* ir_unused_structs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_unused_structs.cpp; path = ../../src/glsl/ir_unused_structs.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A8B1207FEA6002DC82D /* ir_unused_structs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_unused_structs.h; path = ../../src/glsl/ir_unused_structs.h; sourceTree = SOURCE_ROOT; };
+		2BA55A8C1207FEA6002DC82D /* ir_validate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_validate.cpp; path = ../../src/glsl/ir_validate.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A8D1207FEA6002DC82D /* ir_variable_refcount.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_variable_refcount.cpp; path = ../../src/glsl/ir_variable_refcount.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A8E1207FEA6002DC82D /* ir_variable_refcount.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_variable_refcount.h; path = ../../src/glsl/ir_variable_refcount.h; sourceTree = SOURCE_ROOT; };
+		2BA55A921207FEA6002DC82D /* ir_visitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_visitor.h; path = ../../src/glsl/ir_visitor.h; sourceTree = SOURCE_ROOT; };
+		2BA55A931207FEA6002DC82D /* ir.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir.cpp; path = ../../src/glsl/ir.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A941207FEA6002DC82D /* ir.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir.h; path = ../../src/glsl/ir.h; sourceTree = SOURCE_ROOT; };
+		2BA55A951207FEA6002DC82D /* link_functions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = link_functions.cpp; path = ../../src/glsl/link_functions.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A961207FEA6002DC82D /* linker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = linker.cpp; path = ../../src/glsl/linker.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A971207FEA6002DC82D /* linker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = linker.h; path = ../../src/glsl/linker.h; sourceTree = SOURCE_ROOT; };
+		2BA55A981207FEA6002DC82D /* list.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = list.h; path = ../../src/glsl/list.h; sourceTree = SOURCE_ROOT; };
+		2BA55A991207FEA6002DC82D /* program.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = program.h; path = ../../src/glsl/program.h; sourceTree = SOURCE_ROOT; };
+		2BA55A9A1207FEA6002DC82D /* s_expression.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = s_expression.cpp; path = ../../src/glsl/s_expression.cpp; sourceTree = SOURCE_ROOT; };
+		2BA55A9B1207FEA6002DC82D /* s_expression.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = s_expression.h; path = ../../src/glsl/s_expression.h; sourceTree = SOURCE_ROOT; };
+		2BA7E13817D0AEB200D5C475 /* builtin_type_macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = builtin_type_macros.h; path = ../../src/glsl/builtin_type_macros.h; sourceTree = "<group>"; };
+		2BA7E13917D0AEB200D5C475 /* builtin_types.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = builtin_types.cpp; path = ../../src/glsl/builtin_types.cpp; sourceTree = "<group>"; };
+		2BA7E13A17D0AEB200D5C475 /* link_interface_blocks.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = link_interface_blocks.cpp; path = ../../src/glsl/link_interface_blocks.cpp; sourceTree = "<group>"; };
+		2BA7E13B17D0AEB200D5C475 /* lower_named_interface_blocks.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_named_interface_blocks.cpp; path = ../../src/glsl/lower_named_interface_blocks.cpp; sourceTree = "<group>"; };
+		2BA7E13C17D0AEB200D5C475 /* lower_vector_insert.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_vector_insert.cpp; path = ../../src/glsl/lower_vector_insert.cpp; sourceTree = "<group>"; };
+		2BA7E13D17D0AEB200D5C475 /* opt_dead_builtin_varyings.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_dead_builtin_varyings.cpp; path = ../../src/glsl/opt_dead_builtin_varyings.cpp; sourceTree = "<group>"; };
+		2BA7E13E17D0AEB200D5C475 /* opt_flip_matrices.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_flip_matrices.cpp; path = ../../src/glsl/opt_flip_matrices.cpp; sourceTree = "<group>"; };
+		2BB2F5AA12B8F1580052C6B0 /* lower_discard.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_discard.cpp; path = ../../src/glsl/lower_discard.cpp; sourceTree = SOURCE_ROOT; };
+		2BB2F5AB12B8F1580052C6B0 /* lower_instructions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_instructions.cpp; path = ../../src/glsl/lower_instructions.cpp; sourceTree = SOURCE_ROOT; };
+		2BB2F5AC12B8F1580052C6B0 /* lower_vector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_vector.cpp; path = ../../src/glsl/lower_vector.cpp; sourceTree = SOURCE_ROOT; };
+		2BB2F5AE12B8F1580052C6B0 /* strtod.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = strtod.c; path = ../../src/glsl/strtod.c; sourceTree = SOURCE_ROOT; };
+		2BB2F5AF12B8F1580052C6B0 /* strtod.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = strtod.h; path = ../../src/glsl/strtod.h; sourceTree = SOURCE_ROOT; };
+		2BB7259B135094BE0057D8B5 /* compiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = compiler.h; path = ../../src/mesa/main/compiler.h; sourceTree = SOURCE_ROOT; };
+		2BB7259C135094BE0057D8B5 /* config.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = config.h; path = ../../src/mesa/main/config.h; sourceTree = SOURCE_ROOT; };
+		2BB7259D135094BE0057D8B5 /* context.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = context.h; path = ../../src/mesa/main/context.h; sourceTree = SOURCE_ROOT; };
+		2BB7259E135094BE0057D8B5 /* core.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = core.h; path = ../../src/mesa/main/core.h; sourceTree = SOURCE_ROOT; };
+		2BB7259F135094BE0057D8B5 /* dd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = dd.h; path = ../../src/mesa/main/dd.h; sourceTree = SOURCE_ROOT; };
+		2BB725A1135094BE0057D8B5 /* glheader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = glheader.h; path = ../../src/mesa/main/glheader.h; sourceTree = SOURCE_ROOT; };
+		2BB725A2135094BE0057D8B5 /* imports.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = imports.h; path = ../../src/mesa/main/imports.h; sourceTree = SOURCE_ROOT; };
+		2BB725A3135094BE0057D8B5 /* macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = macros.h; path = ../../src/mesa/main/macros.h; sourceTree = SOURCE_ROOT; };
+		2BB725A5135094BE0057D8B5 /* mtypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = mtypes.h; path = ../../src/mesa/main/mtypes.h; sourceTree = SOURCE_ROOT; };
+		2BB725A7135094BE0057D8B5 /* simple_list.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = simple_list.h; path = ../../src/mesa/main/simple_list.h; sourceTree = SOURCE_ROOT; };
+		2BBA491F1254706A00D42573 /* glsl_symbol_table.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = glsl_symbol_table.cpp; path = ../../src/glsl/glsl_symbol_table.cpp; sourceTree = SOURCE_ROOT; };
+		2BBA49211254706A00D42573 /* loop_analysis.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = loop_analysis.cpp; path = ../../src/glsl/loop_analysis.cpp; sourceTree = SOURCE_ROOT; };
+		2BBA49221254706A00D42573 /* loop_analysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = loop_analysis.h; path = ../../src/glsl/loop_analysis.h; sourceTree = SOURCE_ROOT; };
+		2BBA49231254706A00D42573 /* loop_controls.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = loop_controls.cpp; path = ../../src/glsl/loop_controls.cpp; sourceTree = SOURCE_ROOT; };
+		2BBA49241254706A00D42573 /* loop_unroll.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = loop_unroll.cpp; path = ../../src/glsl/loop_unroll.cpp; sourceTree = SOURCE_ROOT; };
+		2BBA49251254706A00D42573 /* lower_noise.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_noise.cpp; path = ../../src/glsl/lower_noise.cpp; sourceTree = SOURCE_ROOT; };
+		2BBA49261254706A00D42573 /* lower_variable_index_to_cond_assign.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_variable_index_to_cond_assign.cpp; path = ../../src/glsl/lower_variable_index_to_cond_assign.cpp; sourceTree = SOURCE_ROOT; };
+		2BBA49271254706A00D42573 /* opt_redundant_jumps.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_redundant_jumps.cpp; path = ../../src/glsl/opt_redundant_jumps.cpp; sourceTree = SOURCE_ROOT; };
+		2BBD9DA717193BEA00515007 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = README.md; path = ../../README.md; sourceTree = "<group>"; };
+		2BBD9DA91719693E00515007 /* ast_array_index.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ast_array_index.cpp; path = ../../src/glsl/ast_array_index.cpp; sourceTree = "<group>"; };
+		2BBD9DAA1719693F00515007 /* link_uniform_block_active_visitor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = link_uniform_block_active_visitor.cpp; path = ../../src/glsl/link_uniform_block_active_visitor.cpp; sourceTree = "<group>"; };
+		2BBD9DAB1719694000515007 /* link_uniform_block_active_visitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = link_uniform_block_active_visitor.h; path = ../../src/glsl/link_uniform_block_active_visitor.h; sourceTree = "<group>"; };
+		2BBD9DAC1719694100515007 /* link_uniform_blocks.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = link_uniform_blocks.cpp; path = ../../src/glsl/link_uniform_blocks.cpp; sourceTree = "<group>"; };
+		2BBD9DB41719698800515007 /* link_varyings.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = link_varyings.cpp; path = ../../src/glsl/link_varyings.cpp; sourceTree = "<group>"; };
+		2BBD9DB51719698900515007 /* link_varyings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = link_varyings.h; path = ../../src/glsl/link_varyings.h; sourceTree = "<group>"; };
+		2BBD9DB61719698900515007 /* lower_packed_varyings.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_packed_varyings.cpp; path = ../../src/glsl/lower_packed_varyings.cpp; sourceTree = "<group>"; };
+		2BBD9DB71719698A00515007 /* lower_packing_builtins.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = lower_packing_builtins.cpp; path = ../../src/glsl/lower_packing_builtins.cpp; sourceTree = "<group>"; };
+		2BBD9DB81719698B00515007 /* opt_flatten_nested_if_blocks.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_flatten_nested_if_blocks.cpp; path = ../../src/glsl/opt_flatten_nested_if_blocks.cpp; sourceTree = "<group>"; };
+		2BBD9DC717196A3B00515007 /* imports.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = imports.c; path = ../../src/mesa/main/imports.c; sourceTree = "<group>"; };
+		2BCF3A8B19ADE1E50057C395 /* ir_print_metal_visitor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_print_metal_visitor.cpp; path = ../../src/glsl/ir_print_metal_visitor.cpp; sourceTree = "<group>"; };
+		2BCF3A8C19ADE1E50057C395 /* ir_print_metal_visitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_print_metal_visitor.h; path = ../../src/glsl/ir_print_metal_visitor.h; sourceTree = "<group>"; };
+		2BDCB95B184E182B0075CE6F /* ir_stats.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ir_stats.cpp; path = ../../src/glsl/ir_stats.cpp; sourceTree = "<group>"; };
+		2BDCB95C184E182B0075CE6F /* ir_stats.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ir_stats.h; path = ../../src/glsl/ir_stats.h; sourceTree = "<group>"; };
+		2BEC22CB1356E94E00B5E301 /* opt_copy_propagation_elements.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = opt_copy_propagation_elements.cpp; path = ../../src/glsl/opt_copy_propagation_elements.cpp; sourceTree = SOURCE_ROOT; };
+		D2AAC046055464E500DB518D /* libglsl_optimizer.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libglsl_optimizer.a; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		D289987405E68DCB004EDB86 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		08FB7794FE84155DC02AAC07 /* mesaglsl2 */ = {
+			isa = PBXGroup;
+			children = (
+				2BBD9DA717193BEA00515007 /* README.md */,
+				08FB7795FE84155DC02AAC07 /* Source */,
+				1AB674ADFE9D54B511CA2CBB /* Products */,
+			);
+			name = mesaglsl2;
+			sourceTree = "<group>";
+		};
+		08FB7795FE84155DC02AAC07 /* Source */ = {
+			isa = PBXGroup;
+			children = (
+				2B39E40F19E959E0001C6A17 /* util */,
+				2BB7259A135094A60057D8B5 /* mesa */,
+				2B47D9FC1209C85400937F2C /* program */,
+				2BA55A501207FE41002DC82D /* glsl */,
+			);
+			name = Source;
+			sourceTree = "<group>";
+		};
+		1AB674ADFE9D54B511CA2CBB /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				D2AAC046055464E500DB518D /* libglsl_optimizer.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		2B39E40F19E959E0001C6A17 /* util */ = {
+			isa = PBXGroup;
+			children = (
+				2B39E41019E959F9001C6A17 /* hash_table.c */,
+				2B39E41119E959F9001C6A17 /* hash_table.h */,
+				2B39E41219E959F9001C6A17 /* macros.h */,
+				2B39E41319E959F9001C6A17 /* ralloc.c */,
+				2B39E41419E959F9001C6A17 /* ralloc.h */,
+			);
+			name = util;
+			sourceTree = "<group>";
+		};
+		2B47D9FC1209C85400937F2C /* program */ = {
+			isa = PBXGroup;
+			children = (
+				2B6AC7B5161EC99C0094FD86 /* prog_instruction.h */,
+				2B6AC7B6161EC99C0094FD86 /* prog_parameter.h */,
+				2B6AC7B7161EC99C0094FD86 /* prog_statevars.h */,
+				2B47D9FD1209C87B00937F2C /* prog_hash_table.c */,
+				2B47D9FE1209C87B00937F2C /* hash_table.h */,
+				2B47D9FF1209C87B00937F2C /* symbol_table.c */,
+				2B47DA001209C87B00937F2C /* symbol_table.h */,
+			);
+			name = program;
+			sourceTree = "<group>";
+		};
+		2B6A99EB1223B1460059FBED /* glcpp */ = {
+			isa = PBXGroup;
+			children = (
+				2B6A99EC1223B1670059FBED /* glcpp-lex.c */,
+				2B6A99ED1223B1670059FBED /* glcpp-lex.l */,
+				2B6A99EE1223B1670059FBED /* glcpp-parse.c */,
+				2B6A99EF1223B1670059FBED /* glcpp-parse.h */,
+				2B6A99F01223B1670059FBED /* glcpp-parse.y */,
+				2B6A99F21223B1670059FBED /* glcpp.h */,
+				2B6A99F31223B1670059FBED /* pp.c */,
+			);
+			name = glcpp;
+			sourceTree = "<group>";
+		};
+		2BA55A501207FE41002DC82D /* glsl */ = {
+			isa = PBXGroup;
+			children = (
+				2BA55A551207FEA6002DC82D /* ast.h */,
+				2BBD9DA91719693E00515007 /* ast_array_index.cpp */,
+				2BA55A511207FEA6002DC82D /* ast_expr.cpp */,
+				2BA55A521207FEA6002DC82D /* ast_function.cpp */,
+				2BA55A531207FEA6002DC82D /* ast_to_hir.cpp */,
+				2BA55A541207FEA6002DC82D /* ast_type.cpp */,
+				2B8979DD182C0C4700718F8A /* builtin_functions.cpp */,
+				2BA7E13817D0AEB200D5C475 /* builtin_type_macros.h */,
+				2BA7E13917D0AEB200D5C475 /* builtin_types.cpp */,
+				2B92A05C15F9FF4700CFED4A /* builtin_variables.cpp */,
+				2B6A99EB1223B1460059FBED /* glcpp */,
+				2BA55A591207FEA6002DC82D /* glsl_lexer.cpp */,
+				2BA55A5A1207FEA6002DC82D /* glsl_lexer.ll */,
+				2BA55A5B1207FEA6002DC82D /* glsl_optimizer.cpp */,
+				2BA55A5C1207FEA6002DC82D /* glsl_optimizer.h */,
+				2BA55A5F1207FEA6002DC82D /* glsl_parser.cpp */,
+				2BA55A601207FEA6002DC82D /* glsl_parser.h */,
+				2BA55A611207FEA6002DC82D /* glsl_parser.yy */,
+				2BA55A5D1207FEA6002DC82D /* glsl_parser_extras.cpp */,
+				2BA55A5E1207FEA6002DC82D /* glsl_parser_extras.h */,
+				2BBA491F1254706A00D42573 /* glsl_symbol_table.cpp */,
+				2BA55A621207FEA6002DC82D /* glsl_symbol_table.h */,
+				2BA55A631207FEA6002DC82D /* glsl_types.cpp */,
+				2BA55A641207FEA6002DC82D /* glsl_types.h */,
+				2BA55A651207FEA6002DC82D /* hir_field_selection.cpp */,
+				2BA55A931207FEA6002DC82D /* ir.cpp */,
+				2BA55A941207FEA6002DC82D /* ir.h */,
+				2BA55A671207FEA6002DC82D /* ir_basic_block.cpp */,
+				2BA55A681207FEA6002DC82D /* ir_basic_block.h */,
+				2B3A6BD715FA08E1000DCBE1 /* ir_builder.cpp */,
+				2B3A6BD815FA08E1000DCBE1 /* ir_builder.h */,
+				2BA55A691207FEA6002DC82D /* ir_clone.cpp */,
+				2BA55A6A1207FEA6002DC82D /* ir_constant_expression.cpp */,
+				2BA55A711207FEA6002DC82D /* ir_expression_flattening.cpp */,
+				2BA55A721207FEA6002DC82D /* ir_expression_flattening.h */,
+				2B78C91C1858B052007F5D2A /* ir_equals.cpp */,
+				2BA55A761207FEA6002DC82D /* ir_function.cpp */,
+				2BA55A731207FEA6002DC82D /* ir_function_can_inline.cpp */,
+				2B655A7113E0322E00B5278F /* ir_function_detect_recursion.cpp */,
+				2BA55A751207FEA6002DC82D /* ir_function_inlining.h */,
+				2BA55A771207FEA6002DC82D /* ir_hierarchical_visitor.cpp */,
+				2BA55A781207FEA6002DC82D /* ir_hierarchical_visitor.h */,
+				2BA55A791207FEA6002DC82D /* ir_hv_accept.cpp */,
+				2BA55A7D1207FEA6002DC82D /* ir_import_prototypes.cpp */,
+				2BA55A801207FEA6002DC82D /* ir_optimization.h */,
+				2BA55A811207FEA6002DC82D /* ir_print_glsl_visitor.cpp */,
+				2BA55A821207FEA6002DC82D /* ir_print_glsl_visitor.h */,
+				2BCF3A8B19ADE1E50057C395 /* ir_print_metal_visitor.cpp */,
+				2BCF3A8C19ADE1E50057C395 /* ir_print_metal_visitor.h */,
+				2BA55A831207FEA6002DC82D /* ir_print_visitor.cpp */,
+				2BA55A841207FEA6002DC82D /* ir_print_visitor.h */,
+				2B62490D12191339003F6EEE /* ir_rvalue_visitor.cpp */,
+				2B62490E12191339003F6EEE /* ir_rvalue_visitor.h */,
+				2BDCB95B184E182B0075CE6F /* ir_stats.cpp */,
+				2BDCB95C184E182B0075CE6F /* ir_stats.h */,
+				2B6AC7BC161EC9D40094FD86 /* ir_uniform.h */,
+				2BA55A8A1207FEA6002DC82D /* ir_unused_structs.cpp */,
+				2BA55A8B1207FEA6002DC82D /* ir_unused_structs.h */,
+				2BA55A8C1207FEA6002DC82D /* ir_validate.cpp */,
+				2BA55A8D1207FEA6002DC82D /* ir_variable_refcount.cpp */,
+				2BA55A8E1207FEA6002DC82D /* ir_variable_refcount.h */,
+				2BA55A921207FEA6002DC82D /* ir_visitor.h */,
+				2B8979E1182CB62900718F8A /* link_atomics.cpp */,
+				2BA55A951207FEA6002DC82D /* link_functions.cpp */,
+				2BA7E13A17D0AEB200D5C475 /* link_interface_blocks.cpp */,
+				2BBD9DAA1719693F00515007 /* link_uniform_block_active_visitor.cpp */,
+				2BBD9DAB1719694000515007 /* link_uniform_block_active_visitor.h */,
+				2BBD9DAC1719694100515007 /* link_uniform_blocks.cpp */,
+				2B3A6B9515FA0468000DCBE1 /* link_uniform_initializers.cpp */,
+				2B3A6B8E15FA043D000DCBE1 /* link_uniforms.cpp */,
+				2BBD9DB41719698800515007 /* link_varyings.cpp */,
+				2BBD9DB51719698900515007 /* link_varyings.h */,
+				2BA55A961207FEA6002DC82D /* linker.cpp */,
+				2BA55A971207FEA6002DC82D /* linker.h */,
+				2BA55A981207FEA6002DC82D /* list.h */,
+				2BBA49211254706A00D42573 /* loop_analysis.cpp */,
+				2BBA49221254706A00D42573 /* loop_analysis.h */,
+				2BBA49231254706A00D42573 /* loop_controls.cpp */,
+				2BBA49241254706A00D42573 /* loop_unroll.cpp */,
+				2B3A6B9C15FA0494000DCBE1 /* lower_clip_distance.cpp */,
+				2BB2F5AA12B8F1580052C6B0 /* lower_discard.cpp */,
+				2B3A6B9D15FA0494000DCBE1 /* lower_discard_flow.cpp */,
+				2B3854481293BE5000F3E692 /* lower_if_to_cond_assign.cpp */,
+				2BB2F5AB12B8F1580052C6B0 /* lower_instructions.cpp */,
+				2B3854491293BE5000F3E692 /* lower_jumps.cpp */,
+				2B38544A1293BE5000F3E692 /* lower_mat_op_to_vec.cpp */,
+				2BA7E13B17D0AEB200D5C475 /* lower_named_interface_blocks.cpp */,
+				2BBA49251254706A00D42573 /* lower_noise.cpp */,
+				2B39E41A19E95FA7001C6A17 /* lower_offset_array.cpp */,
+				2B3A6B9E15FA0494000DCBE1 /* lower_output_reads.cpp */,
+				2BBD9DB61719698900515007 /* lower_packed_varyings.cpp */,
+				2BBD9DB71719698A00515007 /* lower_packing_builtins.cpp */,
+				2B3A6BA015FA0494000DCBE1 /* lower_ubo_reference.cpp */,
+				2BBA49261254706A00D42573 /* lower_variable_index_to_cond_assign.cpp */,
+				2B38544D1293BE5000F3E692 /* lower_vec_index_to_cond_assign.cpp */,
+				2B38544E1293BE5000F3E692 /* lower_vec_index_to_swizzle.cpp */,
+				2BB2F5AC12B8F1580052C6B0 /* lower_vector.cpp */,
+				2BA7E13C17D0AEB200D5C475 /* lower_vector_insert.cpp */,
+				2B39E41B19E95FA7001C6A17 /* lower_vertex_id.cpp */,
+				2BA0808A1352EBFB00A1C074 /* main.cpp */,
+				2B38544F1293BE5000F3E692 /* opt_algebraic.cpp */,
+				2B3A6BA115FA0494000DCBE1 /* opt_array_splitting.cpp */,
+				2B3854501293BE5000F3E692 /* opt_constant_folding.cpp */,
+				2B3854511293BE5000F3E692 /* opt_constant_propagation.cpp */,
+				2B3854521293BE5000F3E692 /* opt_constant_variable.cpp */,
+				2B3854531293BE5000F3E692 /* opt_copy_propagation.cpp */,
+				2BEC22CB1356E94E00B5E301 /* opt_copy_propagation_elements.cpp */,
+				2B8979DF182C195C00718F8A /* opt_cse.cpp */,
+				2B39E41C19E95FA7001C6A17 /* opt_dead_builtin_variables.cpp */,
+				2BA7E13D17D0AEB200D5C475 /* opt_dead_builtin_varyings.cpp */,
+				2B3854551293BE5000F3E692 /* opt_dead_code.cpp */,
+				2B3854541293BE5000F3E692 /* opt_dead_code_local.cpp */,
+				2B3854561293BE5000F3E692 /* opt_dead_functions.cpp */,
+				2BBD9DB81719698B00515007 /* opt_flatten_nested_if_blocks.cpp */,
+				2BA7E13E17D0AEB200D5C475 /* opt_flip_matrices.cpp */,
+				2B3854571293BE5000F3E692 /* opt_function_inlining.cpp */,
+				2B3854581293BE5000F3E692 /* opt_if_simplification.cpp */,
+				2B39E41D19E95FA7001C6A17 /* opt_minmax.cpp */,
+				2B3854591293BE5000F3E692 /* opt_noop_swizzle.cpp */,
+				2B39E41E19E95FA7001C6A17 /* opt_rebalance_tree.cpp */,
+				2BBA49271254706A00D42573 /* opt_redundant_jumps.cpp */,
+				2B38545A1293BE5000F3E692 /* opt_structure_splitting.cpp */,
+				2B38545B1293BE5000F3E692 /* opt_swizzle_swizzle.cpp */,
+				2B38545C1293BE5000F3E692 /* opt_tree_grafting.cpp */,
+				2B9F0A3C189664F3002FF617 /* opt_vectorize.cpp */,
+				2BA55A991207FEA6002DC82D /* program.h */,
+				2BA55A9A1207FEA6002DC82D /* s_expression.cpp */,
+				2BA55A9B1207FEA6002DC82D /* s_expression.h */,
+				2B655A7613E0324F00B5278F /* standalone_scaffolding.cpp */,
+				2B655A7713E0324F00B5278F /* standalone_scaffolding.h */,
+				2BB2F5AE12B8F1580052C6B0 /* strtod.c */,
+				2BB2F5AF12B8F1580052C6B0 /* strtod.h */,
+			);
+			name = glsl;
+			sourceTree = "<group>";
+		};
+		2BB7259A135094A60057D8B5 /* mesa */ = {
+			isa = PBXGroup;
+			children = (
+				2BBD9DC717196A3B00515007 /* imports.c */,
+				2BB7259B135094BE0057D8B5 /* compiler.h */,
+				2BB7259C135094BE0057D8B5 /* config.h */,
+				2BB7259D135094BE0057D8B5 /* context.h */,
+				2BB7259E135094BE0057D8B5 /* core.h */,
+				2BB7259F135094BE0057D8B5 /* dd.h */,
+				2BB725A1135094BE0057D8B5 /* glheader.h */,
+				2B6AC8AC161ED9080094FD86 /* glminimal.h */,
+				2BB725A2135094BE0057D8B5 /* imports.h */,
+				2BB725A3135094BE0057D8B5 /* macros.h */,
+				2BB725A5135094BE0057D8B5 /* mtypes.h */,
+				2BB725A7135094BE0057D8B5 /* simple_list.h */,
+			);
+			name = mesa;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		D2AAC043055464E500DB518D /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				2BA55AA01207FEA6002DC82D /* ast.h in Headers */,
+				2BA55AA71207FEA6002DC82D /* glsl_optimizer.h in Headers */,
+				2BA55AA91207FEA6002DC82D /* glsl_parser_extras.h in Headers */,
+				2B39E41619E959F9001C6A17 /* hash_table.h in Headers */,
+				2BA55AAB1207FEA6002DC82D /* glsl_parser.h in Headers */,
+				2BA55AAD1207FEA6002DC82D /* glsl_symbol_table.h in Headers */,
+				2BA55AAF1207FEA6002DC82D /* glsl_types.h in Headers */,
+				2BA55AB31207FEA6002DC82D /* ir_basic_block.h in Headers */,
+				2BA55ABD1207FEA6002DC82D /* ir_expression_flattening.h in Headers */,
+				2BA55AC01207FEA6002DC82D /* ir_function_inlining.h in Headers */,
+				2BA55AC31207FEA6002DC82D /* ir_hierarchical_visitor.h in Headers */,
+				2BA55ACB1207FEA6002DC82D /* ir_optimization.h in Headers */,
+				2BA55ACD1207FEA6002DC82D /* ir_print_glsl_visitor.h in Headers */,
+				2B39E41919E959F9001C6A17 /* ralloc.h in Headers */,
+				2BA55ACF1207FEA6002DC82D /* ir_print_visitor.h in Headers */,
+				2BA55AD61207FEA6002DC82D /* ir_unused_structs.h in Headers */,
+				2BCF3A8E19ADE1E50057C395 /* ir_print_metal_visitor.h in Headers */,
+				2BA55AD91207FEA6002DC82D /* ir_variable_refcount.h in Headers */,
+				2BA55ADD1207FEA6002DC82D /* ir_visitor.h in Headers */,
+				2BA55ADF1207FEA6002DC82D /* ir.h in Headers */,
+				2BA55AE21207FEA6002DC82D /* linker.h in Headers */,
+				2BA55AE31207FEA6002DC82D /* list.h in Headers */,
+				2BA55AE41207FEA6002DC82D /* program.h in Headers */,
+				2BA55AE61207FEA6002DC82D /* s_expression.h in Headers */,
+				2B39E41719E959F9001C6A17 /* macros.h in Headers */,
+				2B47DA021209C87B00937F2C /* hash_table.h in Headers */,
+				2B47DA041209C87B00937F2C /* symbol_table.h in Headers */,
+				2B62491212191339003F6EEE /* ir_rvalue_visitor.h in Headers */,
+				2B6A99F71223B1670059FBED /* glcpp-parse.h in Headers */,
+				2B6A99FA1223B1670059FBED /* glcpp.h in Headers */,
+				2BBA492B1254706A00D42573 /* loop_analysis.h in Headers */,
+				2BB2F5B512B8F1580052C6B0 /* strtod.h in Headers */,
+				2BB725A9135094BE0057D8B5 /* compiler.h in Headers */,
+				2BB725AA135094BE0057D8B5 /* config.h in Headers */,
+				2BB725AB135094BE0057D8B5 /* context.h in Headers */,
+				2BB725AC135094BE0057D8B5 /* core.h in Headers */,
+				2BB725AD135094BE0057D8B5 /* dd.h in Headers */,
+				2BB725AF135094BE0057D8B5 /* glheader.h in Headers */,
+				2BB725B0135094BE0057D8B5 /* imports.h in Headers */,
+				2BB725B1135094BE0057D8B5 /* macros.h in Headers */,
+				2BB725B3135094BE0057D8B5 /* mtypes.h in Headers */,
+				2BA7E13F17D0AEB200D5C475 /* builtin_type_macros.h in Headers */,
+				2BDCB95E184E182B0075CE6F /* ir_stats.h in Headers */,
+				2BB725B5135094BE0057D8B5 /* simple_list.h in Headers */,
+				2B655A7A13E0324F00B5278F /* standalone_scaffolding.h in Headers */,
+				2B3A6BDB15FA08E1000DCBE1 /* ir_builder.h in Headers */,
+				2B6AC7B9161EC99C0094FD86 /* prog_instruction.h in Headers */,
+				2B6AC7BA161EC99C0094FD86 /* prog_parameter.h in Headers */,
+				2B6AC7BB161EC99C0094FD86 /* prog_statevars.h in Headers */,
+				2B6AC7BD161EC9D40094FD86 /* ir_uniform.h in Headers */,
+				2B6AC8AD161ED9080094FD86 /* glminimal.h in Headers */,
+				2BBD9DB11719694100515007 /* link_uniform_block_active_visitor.h in Headers */,
+				2BBD9DBB1719698C00515007 /* link_varyings.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		D2AAC045055464E500DB518D /* glsl_optimizer */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "glsl_optimizer" */;
+			buildPhases = (
+				D2AAC043055464E500DB518D /* Headers */,
+				D2AAC044055464E500DB518D /* Sources */,
+				D289987405E68DCB004EDB86 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = glsl_optimizer;
+			productName = mesaglsl2;
+			productReference = D2AAC046055464E500DB518D /* libglsl_optimizer.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		08FB7793FE84155DC02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0500;
+			};
+			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "glsl_optimizer_lib" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 1;
+			knownRegions = (
+				English,
+				Japanese,
+				French,
+				German,
+			);
+			mainGroup = 08FB7794FE84155DC02AAC07 /* mesaglsl2 */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				D2AAC045055464E500DB518D /* glsl_optimizer */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		D2AAC044055464E500DB518D /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				2BA55A9C1207FEA6002DC82D /* ast_expr.cpp in Sources */,
+				2BA55A9D1207FEA6002DC82D /* ast_function.cpp in Sources */,
+				2BA55A9E1207FEA6002DC82D /* ast_to_hir.cpp in Sources */,
+				2BA7E14417D0AEB200D5C475 /* lower_named_interface_blocks.cpp in Sources */,
+				2BA55A9F1207FEA6002DC82D /* ast_type.cpp in Sources */,
+				2BA55AA41207FEA6002DC82D /* glsl_lexer.cpp in Sources */,
+				2BDCB95D184E182B0075CE6F /* ir_stats.cpp in Sources */,
+				2BA55AA61207FEA6002DC82D /* glsl_optimizer.cpp in Sources */,
+				2B39E41F19E95FA7001C6A17 /* lower_offset_array.cpp in Sources */,
+				2BA55AA81207FEA6002DC82D /* glsl_parser_extras.cpp in Sources */,
+				2BA55AAA1207FEA6002DC82D /* glsl_parser.cpp in Sources */,
+				2BA55AAE1207FEA6002DC82D /* glsl_types.cpp in Sources */,
+				2BA55AB01207FEA6002DC82D /* hir_field_selection.cpp in Sources */,
+				2BCF3A8D19ADE1E50057C395 /* ir_print_metal_visitor.cpp in Sources */,
+				2BA55AB21207FEA6002DC82D /* ir_basic_block.cpp in Sources */,
+				2BA55AB41207FEA6002DC82D /* ir_clone.cpp in Sources */,
+				2BA55AB51207FEA6002DC82D /* ir_constant_expression.cpp in Sources */,
+				2BA55ABC1207FEA6002DC82D /* ir_expression_flattening.cpp in Sources */,
+				2BA55ABE1207FEA6002DC82D /* ir_function_can_inline.cpp in Sources */,
+				2BA55AC11207FEA6002DC82D /* ir_function.cpp in Sources */,
+				2BA55AC21207FEA6002DC82D /* ir_hierarchical_visitor.cpp in Sources */,
+				2BA55AC41207FEA6002DC82D /* ir_hv_accept.cpp in Sources */,
+				2BA55AC81207FEA6002DC82D /* ir_import_prototypes.cpp in Sources */,
+				2BA55ACC1207FEA6002DC82D /* ir_print_glsl_visitor.cpp in Sources */,
+				2BA55ACE1207FEA6002DC82D /* ir_print_visitor.cpp in Sources */,
+				2BA7E14617D0AEB200D5C475 /* lower_vector_insert.cpp in Sources */,
+				2BA55AD51207FEA6002DC82D /* ir_unused_structs.cpp in Sources */,
+				2BA55AD71207FEA6002DC82D /* ir_validate.cpp in Sources */,
+				2BA7E14817D0AEB200D5C475 /* opt_dead_builtin_varyings.cpp in Sources */,
+				2BA55AD81207FEA6002DC82D /* ir_variable_refcount.cpp in Sources */,
+				2BA55ADE1207FEA6002DC82D /* ir.cpp in Sources */,
+				2BA55AE01207FEA6002DC82D /* link_functions.cpp in Sources */,
+				2BA55AE11207FEA6002DC82D /* linker.cpp in Sources */,
+				2BA55AE51207FEA6002DC82D /* s_expression.cpp in Sources */,
+				2B47DA011209C87B00937F2C /* prog_hash_table.c in Sources */,
+				2B47DA031209C87B00937F2C /* symbol_table.c in Sources */,
+				2B62491112191339003F6EEE /* ir_rvalue_visitor.cpp in Sources */,
+				2B6A99F41223B1670059FBED /* glcpp-lex.c in Sources */,
+				2B78C91D1858B052007F5D2A /* ir_equals.cpp in Sources */,
+				2B6A99F61223B1670059FBED /* glcpp-parse.c in Sources */,
+				2B6A99FB1223B1670059FBED /* pp.c in Sources */,
+				2BBA49281254706A00D42573 /* glsl_symbol_table.cpp in Sources */,
+				2BBA492A1254706A00D42573 /* loop_analysis.cpp in Sources */,
+				2BBA492C1254706A00D42573 /* loop_controls.cpp in Sources */,
+				2BBA492D1254706A00D42573 /* loop_unroll.cpp in Sources */,
+				2B9F0A3D189664F3002FF617 /* opt_vectorize.cpp in Sources */,
+				2BBA492E1254706A00D42573 /* lower_noise.cpp in Sources */,
+				2BBA492F1254706A00D42573 /* lower_variable_index_to_cond_assign.cpp in Sources */,
+				2BBA49301254706A00D42573 /* opt_redundant_jumps.cpp in Sources */,
+				2B38545F1293BE5000F3E692 /* lower_if_to_cond_assign.cpp in Sources */,
+				2B3854601293BE5000F3E692 /* lower_jumps.cpp in Sources */,
+				2B39E42319E95FA7001C6A17 /* opt_rebalance_tree.cpp in Sources */,
+				2B3854611293BE5000F3E692 /* lower_mat_op_to_vec.cpp in Sources */,
+				2B3854641293BE5000F3E692 /* lower_vec_index_to_cond_assign.cpp in Sources */,
+				2B3854651293BE5000F3E692 /* lower_vec_index_to_swizzle.cpp in Sources */,
+				2B3854661293BE5000F3E692 /* opt_algebraic.cpp in Sources */,
+				2B3854671293BE5000F3E692 /* opt_constant_folding.cpp in Sources */,
+				2B3854681293BE5000F3E692 /* opt_constant_propagation.cpp in Sources */,
+				2B3854691293BE5000F3E692 /* opt_constant_variable.cpp in Sources */,
+				2B38546A1293BE5000F3E692 /* opt_copy_propagation.cpp in Sources */,
+				2B39E42019E95FA7001C6A17 /* lower_vertex_id.cpp in Sources */,
+				2B38546B1293BE5000F3E692 /* opt_dead_code_local.cpp in Sources */,
+				2B8979E2182CB62900718F8A /* link_atomics.cpp in Sources */,
+				2B38546C1293BE5000F3E692 /* opt_dead_code.cpp in Sources */,
+				2B38546D1293BE5000F3E692 /* opt_dead_functions.cpp in Sources */,
+				2B38546E1293BE5000F3E692 /* opt_function_inlining.cpp in Sources */,
+				2B38546F1293BE5000F3E692 /* opt_if_simplification.cpp in Sources */,
+				2B3854701293BE5000F3E692 /* opt_noop_swizzle.cpp in Sources */,
+				2B3854711293BE5000F3E692 /* opt_structure_splitting.cpp in Sources */,
+				2B3854721293BE5000F3E692 /* opt_swizzle_swizzle.cpp in Sources */,
+				2B3854731293BE5000F3E692 /* opt_tree_grafting.cpp in Sources */,
+				2B8979DE182C0C4700718F8A /* builtin_functions.cpp in Sources */,
+				2BB2F5B012B8F1580052C6B0 /* lower_discard.cpp in Sources */,
+				2BB2F5B112B8F1580052C6B0 /* lower_instructions.cpp in Sources */,
+				2BB2F5B212B8F1580052C6B0 /* lower_vector.cpp in Sources */,
+				2B39E42219E95FA7001C6A17 /* opt_minmax.cpp in Sources */,
+				2BB2F5B412B8F1580052C6B0 /* strtod.c in Sources */,
+				2BA7E14017D0AEB200D5C475 /* builtin_types.cpp in Sources */,
+				2BEC22EA1356E98300B5E301 /* opt_copy_propagation_elements.cpp in Sources */,
+				2B8979E0182C195C00718F8A /* opt_cse.cpp in Sources */,
+				2B655A7313E0322E00B5278F /* ir_function_detect_recursion.cpp in Sources */,
+				2B39E42119E95FA7001C6A17 /* opt_dead_builtin_variables.cpp in Sources */,
+				2B655A7913E0324F00B5278F /* standalone_scaffolding.cpp in Sources */,
+				2BA7E14A17D0AEB200D5C475 /* opt_flip_matrices.cpp in Sources */,
+				2BA7E14217D0AEB200D5C475 /* link_interface_blocks.cpp in Sources */,
+				2B92A05E15F9FF4700CFED4A /* builtin_variables.cpp in Sources */,
+				2B3A6B9015FA043D000DCBE1 /* link_uniforms.cpp in Sources */,
+				2B3A6B9715FA0468000DCBE1 /* link_uniform_initializers.cpp in Sources */,
+				2B3A6BA815FA0494000DCBE1 /* lower_clip_distance.cpp in Sources */,
+				2B39E41819E959F9001C6A17 /* ralloc.c in Sources */,
+				2B3A6BA915FA0494000DCBE1 /* lower_discard_flow.cpp in Sources */,
+				2B3A6BAA15FA0494000DCBE1 /* lower_output_reads.cpp in Sources */,
+				2B3A6BAC15FA0494000DCBE1 /* lower_ubo_reference.cpp in Sources */,
+				2B3A6BAD15FA0494000DCBE1 /* opt_array_splitting.cpp in Sources */,
+				2B3A6BDA15FA08E1000DCBE1 /* ir_builder.cpp in Sources */,
+				2B39E41519E959F9001C6A17 /* hash_table.c in Sources */,
+				2BBD9DAD1719694100515007 /* ast_array_index.cpp in Sources */,
+				2BBD9DAF1719694100515007 /* link_uniform_block_active_visitor.cpp in Sources */,
+				2BBD9DB21719694100515007 /* link_uniform_blocks.cpp in Sources */,
+				2BBD9DB91719698C00515007 /* link_varyings.cpp in Sources */,
+				2BBD9DBC1719698C00515007 /* lower_packed_varyings.cpp in Sources */,
+				2BBD9DBE1719698C00515007 /* lower_packing_builtins.cpp in Sources */,
+				2BBD9DC01719698C00515007 /* opt_flatten_nested_if_blocks.cpp in Sources */,
+				2BBD9DC817196A3B00515007 /* imports.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		1DEB91EC08733DB70010E9CD /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				COMBINE_HIDPI_IMAGES = YES;
+				COPY_PHASE_STRIP = NO;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_MODEL_TUNING = G5;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				INSTALL_PATH = /usr/local/lib;
+				PRODUCT_NAME = glsl_optimizer;
+			};
+			name = Debug;
+		};
+		1DEB91ED08733DB70010E9CD /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				COMBINE_HIDPI_IMAGES = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_MODEL_TUNING = G5;
+				INSTALL_PATH = /usr/local/lib;
+				PRODUCT_NAME = glsl_optimizer;
+			};
+			name = Release;
+		};
+		1DEB91F008733DB70010E9CD /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../include,
+					../../src/mesa,
+					../../src,
+				);
+				MACOSX_DEPLOYMENT_TARGET = 10.6;
+				ONLY_ACTIVE_ARCH = YES;
+			};
+			name = Debug;
+		};
+		1DEB91F108733DB70010E9CD /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../include,
+					../../src/mesa,
+					../../src,
+				);
+				MACOSX_DEPLOYMENT_TARGET = 10.6;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "glsl_optimizer" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1DEB91EC08733DB70010E9CD /* Debug */,
+				1DEB91ED08733DB70010E9CD /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "glsl_optimizer_lib" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1DEB91F008733DB70010E9CD /* Debug */,
+				1DEB91F108733DB70010E9CD /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/projects/xcode5/glsl_optimizer_tests.xcodeproj/project.pbxproj

@@ -0,0 +1,272 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		2B47D9AB1209C6AC00937F2C /* glsl_optimizer_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B47D9AA1209C6AC00937F2C /* glsl_optimizer_tests.cpp */; };
+		2B88BF721821AEBD007FEFD9 /* OpenGL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 2B88BF711821AEBD007FEFD9 /* OpenGL.framework */; };
+		2BBD9DA217193ABA00515007 /* libglsl_optimizer.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 2BE167B6171937F4006A0537 /* libglsl_optimizer.a */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		2BE167B5171937F4006A0537 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 2B47D9C51209C72F00937F2C /* glsl_optimizer_lib.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = D2AAC046055464E500DB518D;
+			remoteInfo = glsl_optimizer;
+		};
+		2BE167B7171937F4006A0537 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 2B47D9C51209C72F00937F2C /* glsl_optimizer_lib.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 2BA0803D1352EB9300A1C074;
+			remoteInfo = builtin_compiler;
+		};
+		2BE167B91719383D006A0537 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 2B47D9C51209C72F00937F2C /* glsl_optimizer_lib.xcodeproj */;
+			proxyType = 1;
+			remoteGlobalIDString = D2AAC045055464E500DB518D;
+			remoteInfo = glsl_optimizer;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		8DD76FAF0486AB0100D96B5E /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 8;
+			dstPath = /usr/share/man/man1/;
+			dstSubfolderSpec = 0;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 1;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		2B47D9AA1209C6AC00937F2C /* glsl_optimizer_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = glsl_optimizer_tests.cpp; path = ../../tests/glsl_optimizer_tests.cpp; sourceTree = "<group>"; };
+		2B47D9C51209C72F00937F2C /* glsl_optimizer_lib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = glsl_optimizer_lib.xcodeproj; sourceTree = SOURCE_ROOT; };
+		2B88BF711821AEBD007FEFD9 /* OpenGL.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenGL.framework; path = System/Library/Frameworks/OpenGL.framework; sourceTree = SDKROOT; };
+		8DD76FB20486AB0100D96B5E /* glsl_optimizer_tests */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = glsl_optimizer_tests; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		8DD76FAD0486AB0100D96B5E /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				2BBD9DA217193ABA00515007 /* libglsl_optimizer.a in Frameworks */,
+				2B88BF721821AEBD007FEFD9 /* OpenGL.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		08FB7794FE84155DC02AAC07 /* glsl_optimizer_tests */ = {
+			isa = PBXGroup;
+			children = (
+				08FB7795FE84155DC02AAC07 /* Source */,
+				1AB674ADFE9D54B511CA2CBB /* Products */,
+				2B88BF711821AEBD007FEFD9 /* OpenGL.framework */,
+				2B47D9C51209C72F00937F2C /* glsl_optimizer_lib.xcodeproj */,
+			);
+			name = glsl_optimizer_tests;
+			sourceTree = "<group>";
+		};
+		08FB7795FE84155DC02AAC07 /* Source */ = {
+			isa = PBXGroup;
+			children = (
+				2B47D9AA1209C6AC00937F2C /* glsl_optimizer_tests.cpp */,
+			);
+			name = Source;
+			sourceTree = "<group>";
+		};
+		1AB674ADFE9D54B511CA2CBB /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				8DD76FB20486AB0100D96B5E /* glsl_optimizer_tests */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		2BE167B1171937F4006A0537 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				2BE167B6171937F4006A0537 /* libglsl_optimizer.a */,
+				2BE167B8171937F4006A0537 /* builtincompiler */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		8DD76FA90486AB0100D96B5E /* glsl_optimizer_tests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 1DEB928508733DD80010E9CD /* Build configuration list for PBXNativeTarget "glsl_optimizer_tests" */;
+			buildPhases = (
+				8DD76FAB0486AB0100D96B5E /* Sources */,
+				8DD76FAD0486AB0100D96B5E /* Frameworks */,
+				8DD76FAF0486AB0100D96B5E /* CopyFiles */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				2BE167BA1719383D006A0537 /* PBXTargetDependency */,
+			);
+			name = glsl_optimizer_tests;
+			productInstallPath = "$(HOME)/bin";
+			productName = glsl_optimizer_tests;
+			productReference = 8DD76FB20486AB0100D96B5E /* glsl_optimizer_tests */;
+			productType = "com.apple.product-type.tool";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		08FB7793FE84155DC02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0500;
+			};
+			buildConfigurationList = 1DEB928908733DD80010E9CD /* Build configuration list for PBXProject "glsl_optimizer_tests" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 1;
+			knownRegions = (
+				English,
+				Japanese,
+				French,
+				German,
+			);
+			mainGroup = 08FB7794FE84155DC02AAC07 /* glsl_optimizer_tests */;
+			projectDirPath = "";
+			projectReferences = (
+				{
+					ProductGroup = 2BE167B1171937F4006A0537 /* Products */;
+					ProjectRef = 2B47D9C51209C72F00937F2C /* glsl_optimizer_lib.xcodeproj */;
+				},
+			);
+			projectRoot = "";
+			targets = (
+				8DD76FA90486AB0100D96B5E /* glsl_optimizer_tests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXReferenceProxy section */
+		2BE167B6171937F4006A0537 /* libglsl_optimizer.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libglsl_optimizer.a;
+			remoteRef = 2BE167B5171937F4006A0537 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		2BE167B8171937F4006A0537 /* builtincompiler */ = {
+			isa = PBXReferenceProxy;
+			fileType = "compiled.mach-o.executable";
+			path = builtincompiler;
+			remoteRef = 2BE167B7171937F4006A0537 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+/* End PBXReferenceProxy section */
+
+/* Begin PBXSourcesBuildPhase section */
+		8DD76FAB0486AB0100D96B5E /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				2B47D9AB1209C6AC00937F2C /* glsl_optimizer_tests.cpp in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		2BE167BA1719383D006A0537 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			name = glsl_optimizer;
+			targetProxy = 2BE167B91719383D006A0537 /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin XCBuildConfiguration section */
+		1DEB928608733DD80010E9CD /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				COPY_PHASE_STRIP = NO;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_MODEL_TUNING = G5;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				INSTALL_PATH = /usr/local/bin;
+				PRODUCT_NAME = glsl_optimizer_tests;
+			};
+			name = Debug;
+		};
+		1DEB928708733DD80010E9CD /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_MODEL_TUNING = G5;
+				INSTALL_PATH = /usr/local/bin;
+				PRODUCT_NAME = glsl_optimizer_tests;
+			};
+			name = Release;
+		};
+		1DEB928A08733DD80010E9CD /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				MACOSX_DEPLOYMENT_TARGET = 10.6;
+				ONLY_ACTIVE_ARCH = YES;
+			};
+			name = Debug;
+		};
+		1DEB928B08733DD80010E9CD /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				MACOSX_DEPLOYMENT_TARGET = 10.6;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		1DEB928508733DD80010E9CD /* Build configuration list for PBXNativeTarget "glsl_optimizer_tests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1DEB928608733DD80010E9CD /* Debug */,
+				1DEB928708733DD80010E9CD /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		1DEB928908733DD80010E9CD /* Build configuration list for PBXProject "glsl_optimizer_tests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1DEB928A08733DD80010E9CD /* Debug */,
+				1DEB928B08733DD80010E9CD /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/removeDeletedByUs.sh

@@ -0,0 +1,15 @@
+#! /bin/sh
+git rm -rf bin
+git rm -rf docs
+git rm -rf m4
+git rm -rf src/egl
+git rm -rf src/glsl/glcpp/tests
+git rm -rf src/loader
+git rm -rf src/mapi
+git rm -rf src/mesa/drivers
+git rm -rf src/mesa/main/tests
+git rm -rf src/mesa/state_tracker
+git rm -rf src/gallium
+git rm -rf src/glx
+git rm -rf src/gtest
+git rm -rf $(git status --porcelain | awk '/^DU/ {print $NF}')

3rdparty/bgfx/3rdparty/glsl-optimizer/src/getopt/SConscript

@@ -0,0 +1,15 @@
+Import('*')
+
+if not env['msvc']:
+    Return()
+
+env = env.Clone()
+
+env.Prepend(CPPPATH = ['.'])
+
+getopt = env.ConvenienceLibrary(
+    target = 'getopt',
+    source = ['getopt_long.c'],
+)
+
+Export('getopt')

3rdparty/bgfx/3rdparty/glsl-optimizer/src/getopt/getopt.h

@@ -0,0 +1,82 @@
+/*	$OpenBSD: getopt.h,v 1.2 2008/06/26 05:42:04 ray Exp $	*/
+/*	$NetBSD: getopt.h,v 1.4 2000/07/07 10:43:54 ad Exp $	*/
+
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _GETOPT_H_
+#define _GETOPT_H_
+
+/*
+ * GNU-like getopt_long() and 4.4BSD getsubopt()/optreset extensions
+ */
+#define no_argument        0
+#define required_argument  1
+#define optional_argument  2
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct option {
+	/* name of long option */
+	const char *name;
+	/*
+	 * one of no_argument, required_argument, and optional_argument:
+	 * whether option takes an argument
+	 */
+	int has_arg;
+	/* if not NULL, set *flag to val when option found */
+	int *flag;
+	/* if flag not NULL, value to set *flag to; else return value */
+	int val;
+};
+
+int	 getopt_long(int, char * const *, const char *,
+	    const struct option *, int *);
+int	 getopt_long_only(int, char * const *, const char *,
+	    const struct option *, int *);
+#ifndef _GETOPT_DEFINED_
+#define _GETOPT_DEFINED_
+int	 getopt(int, char * const *, const char *);
+int	 getsubopt(char **, char * const *, char **);
+
+extern   char *optarg;                  /* getopt(3) external variables */
+extern   int opterr;
+extern   int optind;
+extern   int optopt;
+extern   int optreset;
+extern   char *suboptarg;               /* getsubopt(3) external variable */
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+ 
+#endif /* !_GETOPT_H_ */

3rdparty/bgfx/3rdparty/glsl-optimizer/src/getopt/getopt_long.c

@@ -0,0 +1,511 @@
+/*	$OpenBSD: getopt_long.c,v 1.24 2010/07/22 19:31:53 blambert Exp $	*/
+/*	$NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $	*/
+
+/*
+ * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F39502-99-1-0512.
+ */
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int	opterr = 1;		/* if error message should be printed */
+int	optind = 1;		/* index into parent argv vector */
+int	optopt = '?';		/* character checked for validity */
+int	optreset;		/* reset getopt */
+char    *optarg;		/* argument associated with option */
+
+#define PRINT_ERROR	((opterr) && (*options != ':'))
+
+#define FLAG_PERMUTE	0x01	/* permute non-options to the end of argv */
+#define FLAG_ALLARGS	0x02	/* treat non-options as args to option "-1" */
+#define FLAG_LONGONLY	0x04	/* operate as getopt_long_only */
+
+/* return values */
+#define	BADCH		(int)'?'
+#define	BADARG		((*options == ':') ? (int)':' : (int)'?')
+#define	INORDER 	(int)1
+
+#define	EMSG		""
+
+static int getopt_internal(int, char * const *, const char *,
+			   const struct option *, int *, int);
+static int parse_long_options(char * const *, const char *,
+			      const struct option *, int *, int);
+static int gcd(int, int);
+static void permute_args(int, int, int, char * const *);
+
+static char *place = EMSG; /* option letter processing */
+
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1;   /* first option after non options (for permute) */
+
+/* Error messages */
+static const char recargchar[] = "option requires an argument -- %c";
+static const char recargstring[] = "option requires an argument -- %s";
+static const char ambig[] = "ambiguous option -- %.*s";
+static const char noarg[] = "option doesn't take an argument -- %.*s";
+static const char illoptchar[] = "unknown option -- %c";
+static const char illoptstring[] = "unknown option -- %s";
+
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int
+gcd(int a, int b)
+{
+	int c;
+
+	c = a % b;
+	while (c != 0) {
+		a = b;
+		b = c;
+		c = a % b;
+	}
+
+	return (b);
+}
+
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(int panonopt_start, int panonopt_end, int opt_end,
+	char * const *nargv)
+{
+	int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+	char *swap;
+
+	/*
+	 * compute lengths of blocks and number and size of cycles
+	 */
+	nnonopts = panonopt_end - panonopt_start;
+	nopts = opt_end - panonopt_end;
+	ncycle = gcd(nnonopts, nopts);
+	cyclelen = (opt_end - panonopt_start) / ncycle;
+
+	for (i = 0; i < ncycle; i++) {
+		cstart = panonopt_end+i;
+		pos = cstart;
+		for (j = 0; j < cyclelen; j++) {
+			if (pos >= panonopt_end)
+				pos -= nnonopts;
+			else
+				pos += nopts;
+			swap = nargv[pos];
+			/* LINTED const cast */
+			((char **) nargv)[pos] = nargv[cstart];
+			/* LINTED const cast */
+			((char **)nargv)[cstart] = swap;
+		}
+	}
+}
+
+/*
+ * parse_long_options --
+ *	Parse long options in argc/argv argument vector.
+ * Returns -1 if short_too is set and the option does not match long_options.
+ */
+static int
+parse_long_options(char * const *nargv, const char *options,
+	const struct option *long_options, int *idx, int short_too)
+{
+	char *current_argv, *has_equal;
+	size_t current_argv_len;
+	int i, match;
+
+	current_argv = place;
+	match = -1;
+
+	optind++;
+
+	if ((has_equal = strchr(current_argv, '=')) != NULL) {
+		/* argument found (--option=arg) */
+		current_argv_len = has_equal - current_argv;
+		has_equal++;
+	} else
+		current_argv_len = strlen(current_argv);
+
+	for (i = 0; long_options[i].name; i++) {
+		/* find matching long option */
+		if (strncmp(current_argv, long_options[i].name,
+		    current_argv_len))
+			continue;
+
+		if (strlen(long_options[i].name) == current_argv_len) {
+			/* exact match */
+			match = i;
+			break;
+		}
+		/*
+		 * If this is a known short option, don't allow
+		 * a partial match of a single character.
+		 */
+		if (short_too && current_argv_len == 1)
+			continue;
+
+		if (match == -1)	/* partial match */
+			match = i;
+		else {
+			/* ambiguous abbreviation */
+			if (PRINT_ERROR)
+				fprintf(stderr, ambig, (int)current_argv_len,
+				     current_argv);
+			optopt = 0;
+			return (BADCH);
+		}
+	}
+	if (match != -1) {		/* option found */
+		if (long_options[match].has_arg == no_argument
+		    && has_equal) {
+			if (PRINT_ERROR)
+				fprintf(stderr, noarg, (int)current_argv_len,
+				     current_argv);
+			/*
+			 * XXX: GNU sets optopt to val regardless of flag
+			 */
+			if (long_options[match].flag == NULL)
+				optopt = long_options[match].val;
+			else
+				optopt = 0;
+			return (BADARG);
+		}
+		if (long_options[match].has_arg == required_argument ||
+		    long_options[match].has_arg == optional_argument) {
+			if (has_equal)
+				optarg = has_equal;
+			else if (long_options[match].has_arg ==
+			    required_argument) {
+				/*
+				 * optional argument doesn't use next nargv
+				 */
+				optarg = nargv[optind++];
+			}
+		}
+		if ((long_options[match].has_arg == required_argument)
+		    && (optarg == NULL)) {
+			/*
+			 * Missing argument; leading ':' indicates no error
+			 * should be generated.
+			 */
+			if (PRINT_ERROR)
+				fprintf(stderr, recargstring,
+				    current_argv);
+			/*
+			 * XXX: GNU sets optopt to val regardless of flag
+			 */
+			if (long_options[match].flag == NULL)
+				optopt = long_options[match].val;
+			else
+				optopt = 0;
+			--optind;
+			return (BADARG);
+		}
+	} else {			/* unknown option */
+		if (short_too) {
+			--optind;
+			return (-1);
+		}
+		if (PRINT_ERROR)
+			fprintf(stderr, illoptstring, current_argv);
+		optopt = 0;
+		return (BADCH);
+	}
+	if (idx)
+		*idx = match;
+	if (long_options[match].flag) {
+		*long_options[match].flag = long_options[match].val;
+		return (0);
+	} else
+		return (long_options[match].val);
+}
+
+/*
+ * getopt_internal --
+ *	Parse argc/argv argument vector.  Called by user level routines.
+ */
+static int
+getopt_internal(int nargc, char * const *nargv, const char *options,
+	const struct option *long_options, int *idx, int flags)
+{
+	char *oli;				/* option letter list index */
+	int optchar, short_too;
+	static int posixly_correct = -1;
+
+	if (options == NULL)
+		return (-1);
+
+	/*
+	 * Disable GNU extensions if POSIXLY_CORRECT is set or options
+	 * string begins with a '+'.
+	 */
+	if (posixly_correct == -1)
+		posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
+	if (posixly_correct || *options == '+')
+		flags &= ~FLAG_PERMUTE;
+	else if (*options == '-')
+		flags |= FLAG_ALLARGS;
+	if (*options == '+' || *options == '-')
+		options++;
+
+	/*
+	 * XXX Some GNU programs (like cvs) set optind to 0 instead of
+	 * XXX using optreset.  Work around this braindamage.
+	 */
+	if (optind == 0)
+		optind = optreset = 1;
+
+	optarg = NULL;
+	if (optreset)
+		nonopt_start = nonopt_end = -1;
+start:
+	if (optreset || !*place) {		/* update scanning pointer */
+		optreset = 0;
+		if (optind >= nargc) {          /* end of argument vector */
+			place = EMSG;
+			if (nonopt_end != -1) {
+				/* do permutation, if we have to */
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				optind -= nonopt_end - nonopt_start;
+			}
+			else if (nonopt_start != -1) {
+				/*
+				 * If we skipped non-options, set optind
+				 * to the first of them.
+				 */
+				optind = nonopt_start;
+			}
+			nonopt_start = nonopt_end = -1;
+			return (-1);
+		}
+		if (*(place = nargv[optind]) != '-' ||
+		    (place[1] == '\0' && strchr(options, '-') == NULL)) {
+			place = EMSG;		/* found non-option */
+			if (flags & FLAG_ALLARGS) {
+				/*
+				 * GNU extension:
+				 * return non-option as argument to option 1
+				 */
+				optarg = nargv[optind++];
+				return (INORDER);
+			}
+			if (!(flags & FLAG_PERMUTE)) {
+				/*
+				 * If no permutation wanted, stop parsing
+				 * at first non-option.
+				 */
+				return (-1);
+			}
+			/* do permutation */
+			if (nonopt_start == -1)
+				nonopt_start = optind;
+			else if (nonopt_end != -1) {
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				nonopt_start = optind -
+				    (nonopt_end - nonopt_start);
+				nonopt_end = -1;
+			}
+			optind++;
+			/* process next argument */
+			goto start;
+		}
+		if (nonopt_start != -1 && nonopt_end == -1)
+			nonopt_end = optind;
+
+		/*
+		 * If we have "-" do nothing, if "--" we are done.
+		 */
+		if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
+			optind++;
+			place = EMSG;
+			/*
+			 * We found an option (--), so if we skipped
+			 * non-options, we have to permute.
+			 */
+			if (nonopt_end != -1) {
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				optind -= nonopt_end - nonopt_start;
+			}
+			nonopt_start = nonopt_end = -1;
+			return (-1);
+		}
+	}
+
+	/*
+	 * Check long options if:
+	 *  1) we were passed some
+	 *  2) the arg is not just "-"
+	 *  3) either the arg starts with -- we are getopt_long_only()
+	 */
+	if (long_options != NULL && place != nargv[optind] &&
+	    (*place == '-' || (flags & FLAG_LONGONLY))) {
+		short_too = 0;
+		if (*place == '-')
+			place++;		/* --foo long option */
+		else if (*place != ':' && strchr(options, *place) != NULL)
+			short_too = 1;		/* could be short option too */
+
+		optchar = parse_long_options(nargv, options, long_options,
+		    idx, short_too);
+		if (optchar != -1) {
+			place = EMSG;
+			return (optchar);
+		}
+	}
+
+	if ((optchar = (int)*place++) == (int)':' ||
+	    (optchar == (int)'-' && *place != '\0') ||
+	    (oli = strchr(options, optchar)) == NULL) {
+		/*
+		 * If the user specified "-" and  '-' isn't listed in
+		 * options, return -1 (non-option) as per POSIX.
+		 * Otherwise, it is an unknown option character (or ':').
+		 */
+		if (optchar == (int)'-' && *place == '\0')
+			return (-1);
+		if (!*place)
+			++optind;
+		if (PRINT_ERROR)
+			fprintf(stderr, illoptchar, optchar);
+		optopt = optchar;
+		return (BADCH);
+	}
+	if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
+		/* -W long-option */
+		if (*place)			/* no space */
+			/* NOTHING */;
+		else if (++optind >= nargc) {	/* no arg */
+			place = EMSG;
+			if (PRINT_ERROR)
+				fprintf(stderr, recargchar, optchar);
+			optopt = optchar;
+			return (BADARG);
+		} else				/* white space */
+			place = nargv[optind];
+		optchar = parse_long_options(nargv, options, long_options,
+		    idx, 0);
+		place = EMSG;
+		return (optchar);
+	}
+	if (*++oli != ':') {			/* doesn't take argument */
+		if (!*place)
+			++optind;
+	} else {				/* takes (optional) argument */
+		optarg = NULL;
+		if (*place)			/* no white space */
+			optarg = place;
+		else if (oli[1] != ':') {	/* arg not optional */
+			if (++optind >= nargc) {	/* no arg */
+				place = EMSG;
+				if (PRINT_ERROR)
+					fprintf(stderr, recargchar, optchar);
+				optopt = optchar;
+				return (BADARG);
+			} else
+				optarg = nargv[optind];
+		}
+		place = EMSG;
+		++optind;
+	}
+	/* dump back option letter */
+	return (optchar);
+}
+
+/*
+ * getopt --
+ *	Parse argc/argv argument vector.
+ *
+ * [eventually this will replace the BSD getopt]
+ */
+int
+getopt(int nargc, char * const *nargv, const char *options)
+{
+
+	/*
+	 * We don't pass FLAG_PERMUTE to getopt_internal() since
+	 * the BSD getopt(3) (unlike GNU) has never done this.
+	 *
+	 * Furthermore, since many privileged programs call getopt()
+	 * before dropping privileges it makes sense to keep things
+	 * as simple (and bug-free) as possible.
+	 */
+	return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
+}
+
+/*
+ * getopt_long --
+ *	Parse argc/argv argument vector.
+ */
+int
+getopt_long(int nargc, char * const *nargv, const char *options,
+    const struct option *long_options, int *idx)
+{
+
+	return (getopt_internal(nargc, nargv, options, long_options, idx,
+	    FLAG_PERMUTE));
+}
+
+/*
+ * getopt_long_only --
+ *	Parse argc/argv argument vector.
+ */
+int
+getopt_long_only(int nargc, char * const *nargv, const char *options,
+    const struct option *long_options, int *idx)
+{
+
+	return (getopt_internal(nargc, nargv, options, long_options, idx,
+	    FLAG_PERMUTE|FLAG_LONGONLY));
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/.gitignore

@@ -0,0 +1,8 @@
+glsl_compiler
+glsl_parser.output
+builtincompiler
+glsl_test
+subtest-cr/
+subtest-lf/
+subtest-cr-lf/
+subtest-lf-cr/

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/README

@@ -0,0 +1,228 @@
+Welcome to Mesa's GLSL compiler.  A brief overview of how things flow:
+
+1) lex and yacc-based preprocessor takes the incoming shader string
+and produces a new string containing the preprocessed shader.  This
+takes care of things like #if, #ifdef, #define, and preprocessor macro
+invocations.  Note that #version, #extension, and some others are
+passed straight through.  See glcpp/*
+
+2) lex and yacc-based parser takes the preprocessed string and
+generates the AST (abstract syntax tree).  Almost no checking is
+performed in this stage.  See glsl_lexer.lpp and glsl_parser.ypp.
+
+3) The AST is converted to "HIR".  This is the intermediate
+representation of the compiler.  Constructors are generated, function
+calls are resolved to particular function signatures, and all the
+semantic checking is performed.  See ast_*.cpp for the conversion, and
+ir.h for the IR structures.
+
+4) The driver (Mesa, or main.cpp for the standalone binary) performs
+optimizations.  These include copy propagation, dead code elimination,
+constant folding, and others.  Generally the driver will call
+optimizations in a loop, as each may open up opportunities for other
+optimizations to do additional work.  See most files called ir_*.cpp
+
+5) linking is performed.  This does checking to ensure that the
+outputs of the vertex shader match the inputs of the fragment shader,
+and assigns locations to uniforms, attributes, and varyings.  See
+linker.cpp.
+
+6) The driver may perform additional optimization at this point, as
+for example dead code elimination previously couldn't remove functions
+or global variable usage when we didn't know what other code would be
+linked in.
+
+7) The driver performs code generation out of the IR, taking a linked
+shader program and producing a compiled program for each stage.  See
+ir_to_mesa.cpp for Mesa IR code generation.
+
+FAQ:
+
+Q: What is HIR versus IR versus LIR?
+
+A: The idea behind the naming was that ast_to_hir would produce a
+high-level IR ("HIR"), with things like matrix operations, structure
+assignments, etc., present.  A series of lowering passes would occur
+that do things like break matrix multiplication into a series of dot
+products/MADs, make structure assignment be a series of assignment of
+components, flatten if statements into conditional moves, and such,
+producing a low level IR ("LIR").
+
+However, it now appears that each driver will have different
+requirements from a LIR.  A 915-generation chipset wants all functions
+inlined, all loops unrolled, all ifs flattened, no variable array
+accesses, and matrix multiplication broken down.  The Mesa IR backend
+for swrast would like matrices and structure assignment broken down,
+but it can support function calls and dynamic branching.  A 965 vertex
+shader IR backend could potentially even handle some matrix operations
+without breaking them down, but the 965 fragment shader IR backend
+would want to break to have (almost) all operations down channel-wise
+and perform optimization on that.  As a result, there's no single
+low-level IR that will make everyone happy.  So that usage has fallen
+out of favor, and each driver will perform a series of lowering passes
+to take the HIR down to whatever restrictions it wants to impose
+before doing codegen.
+
+Q: How is the IR structured?
+
+A: The best way to get started seeing it would be to run the
+standalone compiler against a shader:
+
+./glsl_compiler --dump-lir \
+	~/src/piglit/tests/shaders/glsl-orangebook-ch06-bump.frag
+
+So for example one of the ir_instructions in main() contains:
+
+(assign (constant bool (1)) (var_ref litColor)  (expression vec3 * (var_ref Surf
+aceColor) (var_ref __retval) ) )
+
+Or more visually:
+                     (assign)
+                 /       |        \
+        (var_ref)  (expression *)  (constant bool 1)
+         /          /           \
+(litColor)      (var_ref)    (var_ref)
+                  /                  \
+           (SurfaceColor)          (__retval)
+
+which came from:
+
+litColor = SurfaceColor * max(dot(normDelta, LightDir), 0.0);
+
+(the max call is not represented in this expression tree, as it was a
+function call that got inlined but not brought into this expression
+tree)
+
+Each of those nodes is a subclass of ir_instruction.  A particular
+ir_instruction instance may only appear once in the whole IR tree with
+the exception of ir_variables, which appear once as variable
+declarations:
+
+(declare () vec3 normDelta)
+
+and multiple times as the targets of variable dereferences:
+...
+(assign (constant bool (1)) (var_ref __retval) (expression float dot
+ (var_ref normDelta) (var_ref LightDir) ) )
+...
+(assign (constant bool (1)) (var_ref __retval) (expression vec3 -
+ (var_ref LightDir) (expression vec3 * (constant float (2.000000))
+ (expression vec3 * (expression float dot (var_ref normDelta) (var_ref
+ LightDir) ) (var_ref normDelta) ) ) ) )
+...
+
+Each node has a type.  Expressions may involve several different types:
+(declare (uniform ) mat4 gl_ModelViewMatrix)
+((assign (constant bool (1)) (var_ref constructor_tmp) (expression
+ vec4 * (var_ref gl_ModelViewMatrix) (var_ref gl_Vertex) ) )
+
+An expression tree can be arbitrarily deep, and the compiler tries to
+keep them structured like that so that things like algebraic
+optimizations ((color * 1.0 == color) and ((mat1 * mat2) * vec == mat1
+* (mat2 * vec))) or recognizing operation patterns for code generation
+(vec1 * vec2 + vec3 == mad(vec1, vec2, vec3)) are easier.  This comes
+at the expense of additional trickery in implementing some
+optimizations like CSE where one must navigate an expression tree.
+
+Q: Why no SSA representation?
+
+A: Converting an IR tree to SSA form makes dead code elmimination,
+common subexpression elimination, and many other optimizations much
+easier.  However, in our primarily vector-based language, there's some
+major questions as to how it would work.  Do we do SSA on the scalar
+or vector level?  If we do it at the vector level, we're going to end
+up with many different versions of the variable when encountering code
+like:
+
+(assign (constant bool (1)) (swiz x (var_ref __retval) ) (var_ref a) ) 
+(assign (constant bool (1)) (swiz y (var_ref __retval) ) (var_ref b) ) 
+(assign (constant bool (1)) (swiz z (var_ref __retval) ) (var_ref c) ) 
+
+If every masked update of a component relies on the previous value of
+the variable, then we're probably going to be quite limited in our
+dead code elimination wins, and recognizing common expressions may
+just not happen.  On the other hand, if we operate channel-wise, then
+we'll be prone to optimizing the operation on one of the channels at
+the expense of making its instruction flow different from the other
+channels, and a vector-based GPU would end up with worse code than if
+we didn't optimize operations on that channel!
+
+Once again, it appears that our optimization requirements are driven
+significantly by the target architecture.  For now, targeting the Mesa
+IR backend, SSA does not appear to be that important to producing
+excellent code, but we do expect to do some SSA-based optimizations
+for the 965 fragment shader backend when that is developed.
+
+Q: How should I expand instructions that take multiple backend instructions?
+
+Sometimes you'll have to do the expansion in your code generation --
+see, for example, ir_to_mesa.cpp's handling of ir_unop_sqrt.  However,
+in many cases you'll want to do a pass over the IR to convert
+non-native instructions to a series of native instructions.  For
+example, for the Mesa backend we have ir_div_to_mul_rcp.cpp because
+Mesa IR (and many hardware backends) only have a reciprocal
+instruction, not a divide.  Implementing non-native instructions this
+way gives the chance for constant folding to occur, so (a / 2.0)
+becomes (a * 0.5) after codegen instead of (a * (1.0 / 2.0))
+
+Q: How shoud I handle my special hardware instructions with respect to IR?
+
+Our current theory is that if multiple targets have an instruction for
+some operation, then we should probably be able to represent that in
+the IR.  Generally this is in the form of an ir_{bin,un}op expression
+type.  For example, we initially implemented fract() using (a -
+floor(a)), but both 945 and 965 have instructions to give that result,
+and it would also simplify the implementation of mod(), so
+ir_unop_fract was added.  The following areas need updating to add a
+new expression type:
+
+ir.h (new enum)
+ir.cpp:operator_strs (used for ir_reader)
+ir_constant_expression.cpp (you probably want to be able to constant fold)
+ir_validate.cpp (check users have the right types)
+
+You may also need to update the backends if they will see the new expr type:
+
+../mesa/shaders/ir_to_mesa.cpp
+
+You can then use the new expression from builtins (if all backends
+would rather see it), or scan the IR and convert to use your new
+expression type (see ir_mod_to_fract, for example).
+
+Q: How is memory management handled in the compiler?
+
+The hierarchical memory allocator "talloc" developed for the Samba
+project is used, so that things like optimization passes don't have to
+worry about their garbage collection so much.  It has a few nice
+features, including low performance overhead and good debugging
+support that's trivially available.
+
+Generally, each stage of the compile creates a talloc context and
+allocates its memory out of that or children of it.  At the end of the
+stage, the pieces still live are stolen to a new context and the old
+one freed, or the whole context is kept for use by the next stage.
+
+For IR transformations, a temporary context is used, then at the end
+of all transformations, reparent_ir reparents all live nodes under the
+shader's IR list, and the old context full of dead nodes is freed.
+When developing a single IR transformation pass, this means that you
+want to allocate instruction nodes out of the temporary context, so if
+it becomes dead it doesn't live on as the child of a live node.  At
+the moment, optimization passes aren't passed that temporary context,
+so they find it by calling talloc_parent() on a nearby IR node.  The
+talloc_parent() call is expensive, so many passes will cache the
+result of the first talloc_parent().  Cleaning up all the optimization
+passes to take a context argument and not call talloc_parent() is left
+as an exercise.
+
+Q: What is the file naming convention in this directory?
+
+Initially, there really wasn't one.  We have since adopted one:
+
+ - Files that implement code lowering passes should be named lower_*
+   (e.g., lower_noise.cpp).
+ - Files that implement optimization passes should be named opt_*.
+ - Files that implement a class that is used throught the code should
+   take the name of that class (e.g., ir_hierarchical_visitor.cpp).
+ - Files that contain code not fitting in one of the previous
+   categories should have a sensible name (e.g., glsl_parser.ypp).

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/SConscript

@@ -0,0 +1,112 @@
+import common
+
+Import('*')
+
+from sys import executable as python_cmd
+
+env = env.Clone()
+
+env.Prepend(CPPPATH = [
+    '#include',
+    '#src',
+    '#src/mapi',
+    '#src/mesa',
+    '#src/glsl',
+    '#src/glsl/glcpp',
+])
+
+env.Prepend(LIBS = [mesautil])
+
+# Make glcpp-parse.h and glsl_parser.h reachable from the include path.
+env.Append(CPPPATH = [Dir('.').abspath, Dir('glcpp').abspath])
+
+env.Append(YACCFLAGS = '-d -p "glcpp_parser_"')
+
+parser_env = env.Clone()
+parser_env.Append(YACCFLAGS = [
+    '--defines=%s' % File('glsl_parser.h').abspath,
+    '-p', '_mesa_glsl_',
+])
+
+# without this line scons will expect "glsl_parser.hpp" instead of
+# "glsl_parser.h", causing glsl_parser.cpp to be regenerated every time
+parser_env['YACCHXXFILESUFFIX'] = '.h'
+
+glcpp_lexer = env.CFile('glcpp/glcpp-lex.c', 'glcpp/glcpp-lex.l')
+glcpp_parser = env.CFile('glcpp/glcpp-parse.c', 'glcpp/glcpp-parse.y')
+glsl_lexer = parser_env.CXXFile('glsl_lexer.cpp', 'glsl_lexer.ll')
+glsl_parser = parser_env.CXXFile('glsl_parser.cpp', 'glsl_parser.yy')
+
+# common generated sources
+glsl_sources = [
+    glcpp_lexer,
+    glcpp_parser[0],
+    glsl_lexer,
+    glsl_parser[0],
+] 
+
+# parse Makefile.sources
+source_lists = env.ParseSourceList('Makefile.sources')
+
+# add non-generated sources
+for l in ('LIBGLCPP_FILES', 'LIBGLSL_FILES'):
+    glsl_sources += source_lists[l]
+
+if env['msvc']:
+    env.Prepend(CPPPATH = ['#/src/getopt'])
+    env.PrependUnique(LIBS = [getopt])
+
+# Copy these files to avoid generation object files into src/mesa/program
+env.Prepend(CPPPATH = ['#src/mesa/main'])
+env.Command('imports.c', '#src/mesa/main/imports.c', Copy('$TARGET', '$SOURCE'))
+# Copy these files to avoid generation object files into src/mesa/program
+env.Prepend(CPPPATH = ['#src/mesa/program'])
+env.Command('prog_hash_table.c', '#src/mesa/program/prog_hash_table.c', Copy('$TARGET', '$SOURCE'))
+env.Command('symbol_table.c', '#src/mesa/program/symbol_table.c', Copy('$TARGET', '$SOURCE'))
+
+compiler_objs = env.StaticObject(source_lists['GLSL_COMPILER_CXX_FILES'])
+
+mesa_objs = env.StaticObject([
+    'imports.c',
+    'prog_hash_table.c',
+    'symbol_table.c',
+])
+
+compiler_objs += mesa_objs
+
+glsl = env.ConvenienceLibrary(
+    target = 'glsl',
+    source = glsl_sources,
+)
+
+# SCons builtin dependency scanner doesn't detect that glsl_lexer.ll depends on
+# glsl_parser.h
+env.Depends(glsl, glsl_parser)
+
+Export('glsl')
+
+# Skip building these programs as they will cause SCons error "Two environments
+# with different actions were specified for the same target"
+if env['crosscompile'] or env['embedded']:
+    Return()
+
+env = env.Clone()
+
+if env['platform'] == 'windows':
+    env.PrependUnique(LIBS = [
+        'user32',
+    ])
+
+env.Prepend(LIBS = [glsl])
+
+glsl_compiler = env.Program(
+    target = 'glsl_compiler',
+    source = compiler_objs,
+)
+env.Alias('glsl_compiler', glsl_compiler)
+
+glcpp = env.Program(
+    target = 'glcpp/glcpp',
+    source = ['glcpp/glcpp.c', 'tests/common.c'] + mesa_objs,
+)
+env.Alias('glcpp', glcpp)

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/TODO

@@ -0,0 +1,12 @@
+- Detect code paths in non-void functions that don't reach a return statement
+
+- Improve handling of constants and their initializers.  Constant initializers
+  should never generate any code.  This is trival for scalar constants.  It is
+  also trivial for arrays, matrices, and vectors that are accessed with
+  constant index values.  For others it is more complicated.  Perhaps these
+  cases should be silently converted to uniforms?
+
+- Track source locations throughout the IR.  There are currently several
+  places where we cannot emit line numbers for errors (and currently emit 0:0)
+  because we've "lost" the line number information.  This is particularly
+  noticeable at link time.

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/ast_array_index.cpp

@@ -0,0 +1,268 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "ast.h"
+#include "glsl_types.h"
+#include "ir.h"
+
+void
+ast_array_specifier::print(void) const
+{
+   if (this->is_unsized_array) {
+      printf("[ ] ");
+   }
+
+   foreach_list_typed (ast_node, array_dimension, link, &this->array_dimensions) {
+      printf("[ ");
+      array_dimension->print();
+      printf("] ");
+   }
+}
+
+/**
+ * If \c ir is a reference to an array for which we are tracking the max array
+ * element accessed, track that the given element has been accessed.
+ * Otherwise do nothing.
+ *
+ * This function also checks whether the array is a built-in array whose
+ * maximum size is too small to accommodate the given index, and if so uses
+ * loc and state to report the error.
+ */
+static void
+update_max_array_access(ir_rvalue *ir, unsigned idx, YYLTYPE *loc,
+                        struct _mesa_glsl_parse_state *state)
+{
+   if (ir_dereference_variable *deref_var = ir->as_dereference_variable()) {
+      ir_variable *var = deref_var->var;
+      if (idx > var->data.max_array_access) {
+         var->data.max_array_access = idx;
+
+         /* Check whether this access will, as a side effect, implicitly cause
+          * the size of a built-in array to be too large.
+          */
+         check_builtin_array_max_size(var->name, idx+1, *loc, state);
+      }
+   } else if (ir_dereference_record *deref_record =
+              ir->as_dereference_record()) {
+      /* There are two possibilities we need to consider:
+       *
+       * - Accessing an element of an array that is a member of a named
+       *   interface block (e.g. ifc.foo[i])
+       *
+       * - Accessing an element of an array that is a member of a named
+       *   interface block array (e.g. ifc[j].foo[i]).
+       */
+      ir_dereference_variable *deref_var =
+         deref_record->record->as_dereference_variable();
+      if (deref_var == NULL) {
+         if (ir_dereference_array *deref_array =
+             deref_record->record->as_dereference_array()) {
+            deref_var = deref_array->array->as_dereference_variable();
+         }
+      }
+
+      if (deref_var != NULL) {
+         if (deref_var->var->is_interface_instance()) {
+            const glsl_type *interface_type =
+               deref_var->var->get_interface_type();
+            unsigned field_index =
+               deref_record->record->type->field_index(deref_record->field);
+            assert(field_index < interface_type->length);
+
+            unsigned *const max_ifc_array_access =
+               deref_var->var->get_max_ifc_array_access();
+
+            assert(max_ifc_array_access != NULL);
+
+            if (idx > max_ifc_array_access[field_index]) {
+               max_ifc_array_access[field_index] = idx;
+
+               /* Check whether this access will, as a side effect, implicitly
+                * cause the size of a built-in array to be too large.
+                */
+               check_builtin_array_max_size(deref_record->field, idx+1, *loc,
+                                            state);
+            }
+         }
+      }
+   }
+}
+
+
+ir_rvalue *
+_mesa_ast_array_index_to_hir(void *mem_ctx,
+			     struct _mesa_glsl_parse_state *state,
+			     ir_rvalue *array, ir_rvalue *idx,
+			     YYLTYPE &loc, YYLTYPE &idx_loc)
+{
+   if (!array->type->is_error()
+       && !array->type->is_array()
+       && !array->type->is_matrix()
+       && !array->type->is_vector()) {
+      _mesa_glsl_error(& idx_loc, state,
+		       "cannot dereference non-array / non-matrix / "
+		       "non-vector");
+   }
+
+   if (!idx->type->is_error()) {
+      if (!idx->type->is_integer()) {
+	 _mesa_glsl_error(& idx_loc, state, "array index must be integer type");
+      } else if (!idx->type->is_scalar()) {
+	 _mesa_glsl_error(& idx_loc, state, "array index must be scalar");
+      }
+   }
+
+   /* If the array index is a constant expression and the array has a
+    * declared size, ensure that the access is in-bounds.  If the array
+    * index is not a constant expression, ensure that the array has a
+    * declared size.
+    */
+   ir_constant *const const_index = idx->constant_expression_value();
+   if (const_index != NULL && idx->type->is_integer()) {
+      const int idx = const_index->value.i[0];
+      const char *type_name = "error";
+      unsigned bound = 0;
+
+      /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec:
+       *
+       *    "It is illegal to declare an array with a size, and then
+       *    later (in the same shader) index the same array with an
+       *    integral constant expression greater than or equal to the
+       *    declared size. It is also illegal to index an array with a
+       *    negative constant expression."
+       */
+      if (array->type->is_matrix()) {
+	 if (array->type->row_type()->vector_elements <= (unsigned)idx) {
+	    type_name = "matrix";
+	    bound = array->type->row_type()->vector_elements;
+	 }
+      } else if (array->type->is_vector()) {
+	 if (array->type->vector_elements <= (unsigned)idx) {
+	    type_name = "vector";
+	    bound = array->type->vector_elements;
+	 }
+      } else {
+	 /* glsl_type::array_size() returns -1 for non-array types.  This means
+	  * that we don't need to verify that the type is an array before
+	  * doing the bounds checking.
+	  */
+	 if ((array->type->array_size() > 0)
+	     && (array->type->array_size() <= idx)) {
+	    type_name = "array";
+	    bound = array->type->array_size();
+	 }
+      }
+
+      if (bound > 0) {
+	 _mesa_glsl_error(& loc, state, "%s index must be < %u",
+			  type_name, bound);
+      } else if (idx < 0) {
+	 _mesa_glsl_error(& loc, state, "%s index must be >= 0",
+			  type_name);
+      }
+
+      if (array->type->is_array())
+         update_max_array_access(array, idx, &loc, state);
+   } else if (const_index == NULL && array->type->is_array()) {
+      if (array->type->is_unsized_array()) {
+	 _mesa_glsl_error(&loc, state, "unsized array index must be constant");
+      } else if (array->type->fields.array->is_interface()
+                 && array->variable_referenced()->data.mode == ir_var_uniform
+                 && !state->is_version(400, 0) && !state->ARB_gpu_shader5_enable) {
+	 /* Page 46 in section 4.3.7 of the OpenGL ES 3.00 spec says:
+	  *
+	  *     "All indexes used to index a uniform block array must be
+	  *     constant integral expressions."
+	  */
+	 _mesa_glsl_error(&loc, state,
+			  "uniform block array index must be constant");
+      } else {
+	 /* whole_variable_referenced can return NULL if the array is a
+	  * member of a structure.  In this case it is safe to not update
+	  * the max_array_access field because it is never used for fields
+	  * of structures.
+	  */
+	 ir_variable *v = array->whole_variable_referenced();
+	 if (v != NULL)
+	    v->data.max_array_access = array->type->array_size() - 1;
+      }
+
+      /* From page 23 (29 of the PDF) of the GLSL 1.30 spec:
+       *
+       *    "Samplers aggregated into arrays within a shader (using square
+       *    brackets [ ]) can only be indexed with integral constant
+       *    expressions [...]."
+       *
+       * This restriction was added in GLSL 1.30.  Shaders using earlier
+       * version of the language should not be rejected by the compiler
+       * front-end for using this construct.  This allows useful things such
+       * as using a loop counter as the index to an array of samplers.  If the
+       * loop in unrolled, the code should compile correctly.  Instead, emit a
+       * warning.
+       *
+       * In GLSL 4.00 / ARB_gpu_shader5, this requirement is relaxed again to allow
+       * indexing with dynamically uniform expressions. Note that these are not
+       * required to be uniforms or expressions based on them, but merely that the
+       * values must not diverge between shader invocations run together. If the
+       * values *do* diverge, then the behavior of the operation requiring a
+       * dynamically uniform expression is undefined.
+       */
+      if (array->type->element_type()->is_sampler()) {
+	 if (!state->is_version(130, 100)) {
+	    if (state->es_shader) {
+	       _mesa_glsl_warning(&loc, state,
+				  "sampler arrays indexed with non-constant "
+				  "expressions is optional in %s",
+				  state->get_version_string());
+	    } else {
+	       _mesa_glsl_warning(&loc, state,
+				  "sampler arrays indexed with non-constant "
+				  "expressions will be forbidden in GLSL 1.30 "
+				  "and later");
+	    }
+	 } else if (!state->is_version(400, 0) && !state->ARB_gpu_shader5_enable) {
+	    _mesa_glsl_error(&loc, state,
+			     "sampler arrays indexed with non-constant "
+			     "expressions is forbidden in GLSL 1.30 and "
+			     "later");
+	 }
+      }
+   }
+
+   /* After performing all of the error checking, generate the IR for the
+    * expression.
+    */
+   if (array->type->is_array()
+       || array->type->is_matrix()) {
+      return new(mem_ctx) ir_dereference_array(array, idx);
+   } else if (array->type->is_vector()) {
+      return new(mem_ctx) ir_expression(ir_binop_vector_extract, array, idx);
+   } else if (array->type->is_error()) {
+      return array;
+   } else {
+      ir_rvalue *result = new(mem_ctx) ir_dereference_array(array, idx);
+      result->type = glsl_type::error_type;
+
+      return result;
+   }
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/ast_expr.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <assert.h>
+#include "ast.h"
+
+const char *
+ast_expression::operator_string(enum ast_operators op)
+{
+   static const char *const operators[] = {
+      "=",
+      "+",
+      "-",
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "<<",
+      ">>",
+      "<",
+      ">",
+      "<=",
+      ">=",
+      "==",
+      "!=",
+      "&",
+      "^",
+      "|",
+      "~",
+      "&&",
+      "^^",
+      "||",
+      "!",
+
+      "*=",
+      "/=",
+      "%=",
+      "+=",
+      "-=",
+      "<<=",
+      ">>=",
+      "&=",
+      "^=",
+      "|=",
+
+      "?:",
+
+      "++",
+      "--",
+      "++",
+      "--",
+      ".",
+   };
+
+   assert((unsigned int)op < sizeof(operators) / sizeof(operators[0]));
+
+   return operators[op];
+}
+
+
+ast_expression_bin::ast_expression_bin(int oper, ast_expression *ex0,
+				       ast_expression *ex1) :
+   ast_expression(oper, ex0, ex1, NULL)
+{
+   assert((oper >= ast_plus) && (oper <= ast_logic_not));
+}
+
+
+void
+ast_expression_bin::print(void) const
+{
+   subexpressions[0]->print();
+   printf("%s ", operator_string(oper));
+   subexpressions[1]->print();
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/ast_type.cpp

@@ -0,0 +1,363 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "ast.h"
+
+void
+ast_type_specifier::print(void) const
+{
+   if (structure) {
+      structure->print();
+   } else {
+      printf("%s ", type_name);
+   }
+
+   if (array_specifier) {
+      array_specifier->print();
+   }
+}
+
+bool
+ast_fully_specified_type::has_qualifiers() const
+{
+   return this->qualifier.flags.i != 0;
+}
+
+bool ast_type_qualifier::has_interpolation() const
+{
+   return this->flags.q.smooth
+          || this->flags.q.flat
+          || this->flags.q.noperspective;
+}
+
+bool
+ast_type_qualifier::has_layout() const
+{
+   return this->flags.q.origin_upper_left
+          || this->flags.q.pixel_center_integer
+          || this->flags.q.depth_any
+          || this->flags.q.depth_greater
+          || this->flags.q.depth_less
+          || this->flags.q.depth_unchanged
+          || this->flags.q.std140
+          || this->flags.q.shared
+          || this->flags.q.column_major
+          || this->flags.q.row_major
+          || this->flags.q.packed
+          || this->flags.q.explicit_location
+          || this->flags.q.explicit_index
+          || this->flags.q.explicit_binding
+          || this->flags.q.explicit_offset;
+}
+
+bool
+ast_type_qualifier::has_storage() const
+{
+   return this->flags.q.constant
+          || this->flags.q.attribute
+          || this->flags.q.varying
+          || this->flags.q.in
+          || this->flags.q.out
+          || this->flags.q.uniform;
+}
+
+bool
+ast_type_qualifier::has_auxiliary_storage() const
+{
+   return this->flags.q.centroid
+          || this->flags.q.sample;
+}
+
+const char*
+ast_type_qualifier::interpolation_string() const
+{
+   if (this->flags.q.smooth)
+      return "smooth";
+   else if (this->flags.q.flat)
+      return "flat";
+   else if (this->flags.q.noperspective)
+      return "noperspective";
+   else
+      return NULL;
+}
+
+bool
+ast_type_qualifier::merge_qualifier(YYLTYPE *loc,
+				    _mesa_glsl_parse_state *state,
+				    ast_type_qualifier q)
+{
+   ast_type_qualifier ubo_mat_mask;
+   ubo_mat_mask.flags.i = 0;
+   ubo_mat_mask.flags.q.row_major = 1;
+   ubo_mat_mask.flags.q.column_major = 1;
+
+   ast_type_qualifier ubo_layout_mask;
+   ubo_layout_mask.flags.i = 0;
+   ubo_layout_mask.flags.q.std140 = 1;
+   ubo_layout_mask.flags.q.packed = 1;
+   ubo_layout_mask.flags.q.shared = 1;
+
+   ast_type_qualifier ubo_binding_mask;
+   ubo_binding_mask.flags.i = 0;
+   ubo_binding_mask.flags.q.explicit_binding = 1;
+   ubo_binding_mask.flags.q.explicit_offset = 1;
+
+   ast_type_qualifier stream_layout_mask;
+   stream_layout_mask.flags.i = 0;
+   stream_layout_mask.flags.q.stream = 1;
+
+   /* Uniform block layout qualifiers get to overwrite each
+    * other (rightmost having priority), while all other
+    * qualifiers currently don't allow duplicates.
+    */
+   ast_type_qualifier allowed_duplicates_mask;
+   allowed_duplicates_mask.flags.i =
+      ubo_mat_mask.flags.i |
+      ubo_layout_mask.flags.i |
+      ubo_binding_mask.flags.i;
+
+   /* Geometry shaders can have several layout qualifiers
+    * assigning different stream values.
+    */
+   if (state->stage == MESA_SHADER_GEOMETRY)
+      allowed_duplicates_mask.flags.i |=
+         stream_layout_mask.flags.i;
+
+   if ((this->flags.i & q.flags.i & ~allowed_duplicates_mask.flags.i) != 0) {
+      _mesa_glsl_error(loc, state,
+		       "duplicate layout qualifiers used");
+      return false;
+   }
+
+   if (q.flags.q.prim_type) {
+      if (this->flags.q.prim_type && this->prim_type != q.prim_type) {
+	 _mesa_glsl_error(loc, state,
+			  "conflicting primitive type qualifiers used");
+	 return false;
+      }
+      this->prim_type = q.prim_type;
+   }
+
+   if (q.flags.q.max_vertices) {
+      if (this->flags.q.max_vertices && this->max_vertices != q.max_vertices) {
+	 _mesa_glsl_error(loc, state,
+			  "geometry shader set conflicting max_vertices "
+			  "(%d and %d)", this->max_vertices, q.max_vertices);
+	 return false;
+      }
+      this->max_vertices = q.max_vertices;
+   }
+
+   if (q.flags.q.invocations) {
+      if (this->flags.q.invocations && this->invocations != q.invocations) {
+         _mesa_glsl_error(loc, state,
+                          "geometry shader set conflicting invocations "
+                          "(%d and %d)", this->invocations, q.invocations);
+         return false;
+      }
+      this->invocations = q.invocations;
+   }
+
+   if (state->stage == MESA_SHADER_GEOMETRY &&
+       state->has_explicit_attrib_stream()) {
+      if (q.flags.q.stream && q.stream >= state->ctx->Const.MaxVertexStreams) {
+         _mesa_glsl_error(loc, state,
+                          "`stream' value is larger than MAX_VERTEX_STREAMS - 1 "
+                          "(%d > %d)",
+                          q.stream, state->ctx->Const.MaxVertexStreams - 1);
+      }
+      if (this->flags.q.explicit_stream &&
+          this->stream >= state->ctx->Const.MaxVertexStreams) {
+         _mesa_glsl_error(loc, state,
+                          "`stream' value is larger than MAX_VERTEX_STREAMS - 1 "
+                          "(%d > %d)",
+                          this->stream, state->ctx->Const.MaxVertexStreams - 1);
+      }
+
+      if (!this->flags.q.explicit_stream) {
+         if (q.flags.q.stream) {
+            this->flags.q.stream = 1;
+            this->stream = q.stream;
+         } else if (!this->flags.q.stream && this->flags.q.out) {
+            /* Assign default global stream value */
+            this->flags.q.stream = 1;
+            this->stream = state->out_qualifier->stream;
+         }
+      } else {
+         if (q.flags.q.explicit_stream) {
+            _mesa_glsl_error(loc, state,
+                             "duplicate layout `stream' qualifier");
+         }
+      }
+   }
+
+   if ((q.flags.i & ubo_mat_mask.flags.i) != 0)
+      this->flags.i &= ~ubo_mat_mask.flags.i;
+   if ((q.flags.i & ubo_layout_mask.flags.i) != 0)
+      this->flags.i &= ~ubo_layout_mask.flags.i;
+
+   for (int i = 0; i < 3; i++) {
+      if (q.flags.q.local_size & (1 << i)) {
+         if ((this->flags.q.local_size & (1 << i)) &&
+             this->local_size[i] != q.local_size[i]) {
+            _mesa_glsl_error(loc, state,
+                             "compute shader set conflicting values for "
+                             "local_size_%c (%d and %d)", 'x' + i,
+                             this->local_size[i], q.local_size[i]);
+            return false;
+         }
+         this->local_size[i] = q.local_size[i];
+      }
+   }
+
+   this->flags.i |= q.flags.i;
+
+   if (q.flags.q.explicit_location)
+      this->location = q.location;
+
+   if (q.flags.q.explicit_index)
+      this->index = q.index;
+
+   if (q.flags.q.explicit_binding)
+      this->binding = q.binding;
+
+   if (q.flags.q.explicit_offset)
+      this->offset = q.offset;
+
+   if (q.precision != ast_precision_none)
+      this->precision = q.precision;
+
+   if (q.flags.q.explicit_image_format) {
+      this->image_format = q.image_format;
+      this->image_base_type = q.image_base_type;
+   }
+
+   return true;
+}
+
+bool
+ast_type_qualifier::merge_in_qualifier(YYLTYPE *loc,
+                                       _mesa_glsl_parse_state *state,
+                                       ast_type_qualifier q,
+                                       ast_node* &node)
+{
+   void *mem_ctx = state;
+   bool create_gs_ast = false;
+   bool create_cs_ast = false;
+   ast_type_qualifier valid_in_mask;
+   valid_in_mask.flags.i = 0;
+
+   switch (state->stage) {
+   case MESA_SHADER_GEOMETRY:
+      if (q.flags.q.prim_type) {
+         /* Make sure this is a valid input primitive type. */
+         switch (q.prim_type) {
+         case GL_POINTS:
+         case GL_LINES:
+         case GL_LINES_ADJACENCY:
+         case GL_TRIANGLES:
+         case GL_TRIANGLES_ADJACENCY:
+            break;
+         default:
+            _mesa_glsl_error(loc, state,
+                             "invalid geometry shader input primitive type");
+            break;
+         }
+      }
+
+      create_gs_ast |=
+         q.flags.q.prim_type &&
+         !state->in_qualifier->flags.q.prim_type;
+
+      valid_in_mask.flags.q.prim_type = 1;
+      valid_in_mask.flags.q.invocations = 1;
+      break;
+   case MESA_SHADER_FRAGMENT:
+      if (q.flags.q.early_fragment_tests) {
+         state->early_fragment_tests = true;
+      } else {
+         _mesa_glsl_error(loc, state, "invalid input layout qualifier");
+      }
+      break;
+   case MESA_SHADER_COMPUTE:
+      create_cs_ast |=
+         q.flags.q.local_size != 0 &&
+         state->in_qualifier->flags.q.local_size == 0;
+
+      valid_in_mask.flags.q.local_size = 7;
+      break;
+   default:
+      _mesa_glsl_error(loc, state,
+                       "input layout qualifiers only valid in "
+                       "geometry, fragment and compute shaders");
+      break;
+   }
+
+   /* Generate an error when invalid input layout qualifiers are used. */
+   if ((q.flags.i & ~valid_in_mask.flags.i) != 0) {
+      _mesa_glsl_error(loc, state,
+		       "invalid input layout qualifiers used");
+      return false;
+   }
+
+   /* Input layout qualifiers can be specified multiple
+    * times in separate declarations, as long as they match.
+    */
+   if (this->flags.q.prim_type) {
+      if (q.flags.q.prim_type &&
+          this->prim_type != q.prim_type) {
+         _mesa_glsl_error(loc, state,
+                          "conflicting input primitive types specified");
+      }
+   } else if (q.flags.q.prim_type) {
+      state->in_qualifier->flags.q.prim_type = 1;
+      state->in_qualifier->prim_type = q.prim_type;
+   }
+
+   if (this->flags.q.invocations &&
+       q.flags.q.invocations &&
+       this->invocations != q.invocations) {
+      _mesa_glsl_error(loc, state,
+                       "conflicting invocations counts specified");
+      return false;
+   } else if (q.flags.q.invocations) {
+      this->flags.q.invocations = 1;
+      this->invocations = q.invocations;
+   }
+
+   if (create_gs_ast) {
+      node = new(mem_ctx) ast_gs_input_layout(*loc, q.prim_type);
+   } else if (create_cs_ast) {
+      /* Infer a local_size of 1 for every unspecified dimension */
+      unsigned local_size[3];
+      for (int i = 0; i < 3; i++) {
+         if (q.flags.q.local_size & (1 << i))
+            local_size[i] = q.local_size[i];
+         else
+            local_size[i] = 1;
+      }
+      node = new(mem_ctx) ast_cs_input_layout(*loc, local_size);
+   }
+
+   return true;
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/builtin_type_macros.h

@@ -0,0 +1,156 @@
+/*
+ * Copyright © 2013 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file builtin_type_macros.h
+ *
+ * This contains definitions for all GLSL built-in types, regardless of what
+ * language version or extension might provide them.
+ */
+
+#include "glsl_types.h"
+
+DECL_TYPE(error,  GL_INVALID_ENUM, GLSL_TYPE_ERROR, 0, 0)
+DECL_TYPE(void,   GL_INVALID_ENUM, GLSL_TYPE_VOID,  0, 0)
+
+DECL_TYPE(bool,   GL_BOOL,         GLSL_TYPE_BOOL,  1, 1)
+DECL_TYPE(bvec2,  GL_BOOL_VEC2,    GLSL_TYPE_BOOL,  2, 1)
+DECL_TYPE(bvec3,  GL_BOOL_VEC3,    GLSL_TYPE_BOOL,  3, 1)
+DECL_TYPE(bvec4,  GL_BOOL_VEC4,    GLSL_TYPE_BOOL,  4, 1)
+
+DECL_TYPE(int,    GL_INT,          GLSL_TYPE_INT,   1, 1)
+DECL_TYPE(ivec2,  GL_INT_VEC2,     GLSL_TYPE_INT,   2, 1)
+DECL_TYPE(ivec3,  GL_INT_VEC3,     GLSL_TYPE_INT,   3, 1)
+DECL_TYPE(ivec4,  GL_INT_VEC4,     GLSL_TYPE_INT,   4, 1)
+
+DECL_TYPE(uint,   GL_UNSIGNED_INT,      GLSL_TYPE_UINT, 1, 1)
+DECL_TYPE(uvec2,  GL_UNSIGNED_INT_VEC2, GLSL_TYPE_UINT, 2, 1)
+DECL_TYPE(uvec3,  GL_UNSIGNED_INT_VEC3, GLSL_TYPE_UINT, 3, 1)
+DECL_TYPE(uvec4,  GL_UNSIGNED_INT_VEC4, GLSL_TYPE_UINT, 4, 1)
+
+DECL_TYPE(float,  GL_FLOAT,        GLSL_TYPE_FLOAT, 1, 1)
+DECL_TYPE(vec2,   GL_FLOAT_VEC2,   GLSL_TYPE_FLOAT, 2, 1)
+DECL_TYPE(vec3,   GL_FLOAT_VEC3,   GLSL_TYPE_FLOAT, 3, 1)
+DECL_TYPE(vec4,   GL_FLOAT_VEC4,   GLSL_TYPE_FLOAT, 4, 1)
+
+DECL_TYPE(mat2,   GL_FLOAT_MAT2,   GLSL_TYPE_FLOAT, 2, 2)
+DECL_TYPE(mat3,   GL_FLOAT_MAT3,   GLSL_TYPE_FLOAT, 3, 3)
+DECL_TYPE(mat4,   GL_FLOAT_MAT4,   GLSL_TYPE_FLOAT, 4, 4)
+
+DECL_TYPE(mat2x3, GL_FLOAT_MAT2x3, GLSL_TYPE_FLOAT, 3, 2)
+DECL_TYPE(mat2x4, GL_FLOAT_MAT2x4, GLSL_TYPE_FLOAT, 4, 2)
+DECL_TYPE(mat3x2, GL_FLOAT_MAT3x2, GLSL_TYPE_FLOAT, 2, 3)
+DECL_TYPE(mat3x4, GL_FLOAT_MAT3x4, GLSL_TYPE_FLOAT, 4, 3)
+DECL_TYPE(mat4x2, GL_FLOAT_MAT4x2, GLSL_TYPE_FLOAT, 2, 4)
+DECL_TYPE(mat4x3, GL_FLOAT_MAT4x3, GLSL_TYPE_FLOAT, 3, 4)
+
+DECL_TYPE(sampler1D,         GL_SAMPLER_1D,                   GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D,   0, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler2D,         GL_SAMPLER_2D,                   GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D,   0, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler3D,         GL_SAMPLER_3D,                   GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_3D,   0, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(samplerCube,       GL_SAMPLER_CUBE,                 GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler1DArray,    GL_SAMPLER_1D_ARRAY,             GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D,   0, 1, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler2DArray,    GL_SAMPLER_2D_ARRAY,             GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D,   0, 1, GLSL_TYPE_FLOAT)
+DECL_TYPE(samplerCubeArray,  GL_SAMPLER_CUBE_MAP_ARRAY,       GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 1, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler2DRect,     GL_SAMPLER_2D_RECT,              GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_RECT, 0, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(samplerBuffer,     GL_SAMPLER_BUFFER,               GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_BUF,  0, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler2DMS,       GL_SAMPLER_2D_MULTISAMPLE,       GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS,   0, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler2DMSArray,  GL_SAMPLER_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS,   0, 1, GLSL_TYPE_FLOAT)
+
+DECL_TYPE(isampler1D,        GL_INT_SAMPLER_1D,                   GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D,   0, 0, GLSL_TYPE_INT)
+DECL_TYPE(isampler2D,        GL_INT_SAMPLER_2D,                   GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D,   0, 0, GLSL_TYPE_INT)
+DECL_TYPE(isampler3D,        GL_INT_SAMPLER_3D,                   GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_3D,   0, 0, GLSL_TYPE_INT)
+DECL_TYPE(isamplerCube,      GL_INT_SAMPLER_CUBE,                 GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 0, GLSL_TYPE_INT)
+DECL_TYPE(isampler1DArray,   GL_INT_SAMPLER_1D_ARRAY,             GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D,   0, 1, GLSL_TYPE_INT)
+DECL_TYPE(isampler2DArray,   GL_INT_SAMPLER_2D_ARRAY,             GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D,   0, 1, GLSL_TYPE_INT)
+DECL_TYPE(isamplerCubeArray, GL_INT_SAMPLER_CUBE_MAP_ARRAY,       GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 1, GLSL_TYPE_INT)
+DECL_TYPE(isampler2DRect,    GL_INT_SAMPLER_2D_RECT,              GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_RECT, 0, 0, GLSL_TYPE_INT)
+DECL_TYPE(isamplerBuffer,    GL_INT_SAMPLER_BUFFER,               GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_BUF,  0, 0, GLSL_TYPE_INT)
+DECL_TYPE(isampler2DMS,      GL_INT_SAMPLER_2D_MULTISAMPLE,       GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS,   0, 0, GLSL_TYPE_INT)
+DECL_TYPE(isampler2DMSArray, GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS,   0, 1, GLSL_TYPE_INT)
+
+DECL_TYPE(usampler1D,        GL_UNSIGNED_INT_SAMPLER_1D,                   GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D,   0, 0, GLSL_TYPE_UINT)
+DECL_TYPE(usampler2D,        GL_UNSIGNED_INT_SAMPLER_2D,                   GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D,   0, 0, GLSL_TYPE_UINT)
+DECL_TYPE(usampler3D,        GL_UNSIGNED_INT_SAMPLER_3D,                   GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_3D,   0, 0, GLSL_TYPE_UINT)
+DECL_TYPE(usamplerCube,      GL_UNSIGNED_INT_SAMPLER_CUBE,                 GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 0, GLSL_TYPE_UINT)
+DECL_TYPE(usampler1DArray,   GL_UNSIGNED_INT_SAMPLER_1D_ARRAY,             GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D,   0, 1, GLSL_TYPE_UINT)
+DECL_TYPE(usampler2DArray,   GL_UNSIGNED_INT_SAMPLER_2D_ARRAY,             GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D,   0, 1, GLSL_TYPE_UINT)
+DECL_TYPE(usamplerCubeArray, GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY,       GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 1, GLSL_TYPE_UINT)
+DECL_TYPE(usampler2DRect,    GL_UNSIGNED_INT_SAMPLER_2D_RECT,              GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_RECT, 0, 0, GLSL_TYPE_UINT)
+DECL_TYPE(usamplerBuffer,    GL_UNSIGNED_INT_SAMPLER_BUFFER,               GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_BUF,  0, 0, GLSL_TYPE_UINT)
+DECL_TYPE(usampler2DMS,      GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE,       GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS,   0, 0, GLSL_TYPE_UINT)
+DECL_TYPE(usampler2DMSArray, GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS,   0, 1, GLSL_TYPE_UINT)
+
+DECL_TYPE(sampler1DShadow,        GL_SAMPLER_1D_SHADOW,             GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D,       1, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler2DShadow,        GL_SAMPLER_2D_SHADOW,             GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D,       1, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(samplerCubeShadow,      GL_SAMPLER_CUBE_SHADOW,           GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE,     1, 0, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler1DArrayShadow,   GL_SAMPLER_1D_ARRAY_SHADOW,       GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D,       1, 1, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler2DArrayShadow,   GL_SAMPLER_2D_ARRAY_SHADOW,       GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D,       1, 1, GLSL_TYPE_FLOAT)
+DECL_TYPE(samplerCubeArrayShadow, GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE,     1, 1, GLSL_TYPE_FLOAT)
+DECL_TYPE(sampler2DRectShadow,    GL_SAMPLER_2D_RECT_SHADOW,        GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_RECT,     1, 0, GLSL_TYPE_FLOAT)
+
+DECL_TYPE(samplerExternalOES,     GL_SAMPLER_EXTERNAL_OES,          GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_EXTERNAL, 0, 0, GLSL_TYPE_FLOAT)
+
+DECL_TYPE(image1D,         GL_IMAGE_1D,                                GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D,     0, 0, GLSL_TYPE_FLOAT);
+DECL_TYPE(image2D,         GL_IMAGE_2D,                                GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D,     0, 0, GLSL_TYPE_FLOAT);
+DECL_TYPE(image3D,         GL_IMAGE_3D,                                GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_3D,     0, 0, GLSL_TYPE_FLOAT);
+DECL_TYPE(image2DRect,     GL_IMAGE_2D_RECT,                           GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_RECT,   0, 0, GLSL_TYPE_FLOAT);
+DECL_TYPE(imageCube,       GL_IMAGE_CUBE,                              GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE,   0, 0, GLSL_TYPE_FLOAT);
+DECL_TYPE(imageBuffer,     GL_IMAGE_BUFFER,                            GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_BUF,    0, 0, GLSL_TYPE_FLOAT);
+DECL_TYPE(image1DArray,    GL_IMAGE_1D_ARRAY,                          GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D,     0, 1, GLSL_TYPE_FLOAT);
+DECL_TYPE(image2DArray,    GL_IMAGE_2D_ARRAY,                          GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D,     0, 1, GLSL_TYPE_FLOAT);
+DECL_TYPE(imageCubeArray,  GL_IMAGE_CUBE_MAP_ARRAY,                    GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE,   0, 1, GLSL_TYPE_FLOAT);
+DECL_TYPE(image2DMS,       GL_IMAGE_2D_MULTISAMPLE,                    GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS,     0, 0, GLSL_TYPE_FLOAT);
+DECL_TYPE(image2DMSArray,  GL_IMAGE_2D_MULTISAMPLE_ARRAY,              GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS,     0, 1, GLSL_TYPE_FLOAT);
+DECL_TYPE(iimage1D,        GL_INT_IMAGE_1D,                            GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D,     0, 0, GLSL_TYPE_INT);
+DECL_TYPE(iimage2D,        GL_INT_IMAGE_2D,                            GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D,     0, 0, GLSL_TYPE_INT);
+DECL_TYPE(iimage3D,        GL_INT_IMAGE_3D,                            GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_3D,     0, 0, GLSL_TYPE_INT);
+DECL_TYPE(iimage2DRect,    GL_INT_IMAGE_2D_RECT,                       GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_RECT,   0, 0, GLSL_TYPE_INT);
+DECL_TYPE(iimageCube,      GL_INT_IMAGE_CUBE,                          GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE,   0, 0, GLSL_TYPE_INT);
+DECL_TYPE(iimageBuffer,    GL_INT_IMAGE_BUFFER,                        GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_BUF,    0, 0, GLSL_TYPE_INT);
+DECL_TYPE(iimage1DArray,   GL_INT_IMAGE_1D_ARRAY,                      GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D,     0, 1, GLSL_TYPE_INT);
+DECL_TYPE(iimage2DArray,   GL_INT_IMAGE_2D_ARRAY,                      GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D,     0, 1, GLSL_TYPE_INT);
+DECL_TYPE(iimageCubeArray, GL_INT_IMAGE_CUBE_MAP_ARRAY,                GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE,   0, 1, GLSL_TYPE_INT);
+DECL_TYPE(iimage2DMS,      GL_INT_IMAGE_2D_MULTISAMPLE,                GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS,     0, 0, GLSL_TYPE_INT);
+DECL_TYPE(iimage2DMSArray, GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY,          GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS,     0, 1, GLSL_TYPE_INT);
+DECL_TYPE(uimage1D,        GL_UNSIGNED_INT_IMAGE_1D,                   GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D,     0, 0, GLSL_TYPE_UINT);
+DECL_TYPE(uimage2D,        GL_UNSIGNED_INT_IMAGE_2D,                   GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D,     0, 0, GLSL_TYPE_UINT);
+DECL_TYPE(uimage3D,        GL_UNSIGNED_INT_IMAGE_3D,                   GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_3D,     0, 0, GLSL_TYPE_UINT);
+DECL_TYPE(uimage2DRect,    GL_UNSIGNED_INT_IMAGE_2D_RECT,              GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_RECT,   0, 0, GLSL_TYPE_UINT);
+DECL_TYPE(uimageCube,      GL_UNSIGNED_INT_IMAGE_CUBE,                 GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE,   0, 0, GLSL_TYPE_UINT);
+DECL_TYPE(uimageBuffer,    GL_UNSIGNED_INT_IMAGE_BUFFER,               GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_BUF,    0, 0, GLSL_TYPE_UINT);
+DECL_TYPE(uimage1DArray,   GL_UNSIGNED_INT_IMAGE_1D_ARRAY,             GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D,     0, 1, GLSL_TYPE_UINT);
+DECL_TYPE(uimage2DArray,   GL_UNSIGNED_INT_IMAGE_2D_ARRAY,             GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D,     0, 1, GLSL_TYPE_UINT);
+DECL_TYPE(uimageCubeArray, GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY,       GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE,   0, 1, GLSL_TYPE_UINT);
+DECL_TYPE(uimage2DMS,      GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE,       GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS,     0, 0, GLSL_TYPE_UINT);
+DECL_TYPE(uimage2DMSArray, GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS,     0, 1, GLSL_TYPE_UINT);
+
+DECL_TYPE(atomic_uint, GL_UNSIGNED_INT_ATOMIC_COUNTER, GLSL_TYPE_ATOMIC_UINT, 1, 1)
+
+STRUCT_TYPE(gl_DepthRangeParameters)
+STRUCT_TYPE(gl_PointParameters)
+STRUCT_TYPE(gl_MaterialParameters)
+STRUCT_TYPE(gl_LightSourceParameters)
+STRUCT_TYPE(gl_LightModelParameters)
+STRUCT_TYPE(gl_LightModelProducts)
+STRUCT_TYPE(gl_LightProducts)
+STRUCT_TYPE(gl_FogParameters)

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/builtin_types.cpp

@@ -0,0 +1,369 @@
+/*
+ * Copyright © 2013 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file builtin_types.cpp
+ *
+ * The glsl_type class has static members to represent all the built-in types
+ * (such as the glsl_type::_float_type flyweight) as well as convenience pointer
+ * accessors (such as glsl_type::float_type).  Those global variables are
+ * declared and initialized in this file.
+ *
+ * This also contains _mesa_glsl_initialize_types(), a function which populates
+ * a symbol table with the available built-in types for a particular language
+ * version and set of enabled extensions.
+ */
+
+#include "glsl_types.h"
+#include "glsl_parser_extras.h"
+#include "util/macros.h"
+
+/**
+ * Declarations of type flyweights (glsl_type::_foo_type) and
+ * convenience pointers (glsl_type::foo_type).
+ * @{
+ */
+#define DECL_TYPE(NAME, ...)                                    \
+   const glsl_type glsl_type::_##NAME##_type = glsl_type(__VA_ARGS__, #NAME); \
+   const glsl_type *const glsl_type::NAME##_type = &glsl_type::_##NAME##_type;
+
+#define STRUCT_TYPE(NAME)                                       \
+   const glsl_type glsl_type::_struct_##NAME##_type =           \
+      glsl_type(NAME##_fields, ARRAY_SIZE(NAME##_fields), #NAME); \
+   const glsl_type *const glsl_type::struct_##NAME##_type =     \
+      &glsl_type::_struct_##NAME##_type;
+
+static const struct glsl_struct_field gl_DepthRangeParameters_fields[] = {
+   { glsl_type::float_type, "near", glsl_precision_high, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "far",  glsl_precision_high, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "diff", glsl_precision_high, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+};
+
+static const struct glsl_struct_field gl_PointParameters_fields[] = {
+   { glsl_type::float_type, "size", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "sizeMin", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "sizeMax", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "fadeThresholdSize", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "distanceConstantAttenuation", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "distanceLinearAttenuation", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "distanceQuadraticAttenuation", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+};
+
+static const struct glsl_struct_field gl_MaterialParameters_fields[] = {
+   { glsl_type::vec4_type, "emission", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec4_type, "ambient", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec4_type, "diffuse", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec4_type, "specular", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "shininess", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+};
+
+static const struct glsl_struct_field gl_LightSourceParameters_fields[] = {
+   { glsl_type::vec4_type, "ambient", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec4_type, "diffuse", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec4_type, "specular", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec4_type, "position", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec4_type, "halfVector", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec3_type, "spotDirection", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "spotExponent", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "spotCutoff", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "spotCosCutoff", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "constantAttenuation", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "linearAttenuation", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "quadraticAttenuation", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+};
+
+static const struct glsl_struct_field gl_LightModelParameters_fields[] = {
+   { glsl_type::vec4_type, "ambient", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+};
+
+static const struct glsl_struct_field gl_LightModelProducts_fields[] = {
+   { glsl_type::vec4_type, "sceneColor", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+};
+
+static const struct glsl_struct_field gl_LightProducts_fields[] = {
+   { glsl_type::vec4_type, "ambient", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec4_type, "diffuse", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::vec4_type, "specular", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+};
+
+static const struct glsl_struct_field gl_FogParameters_fields[] = {
+   { glsl_type::vec4_type, "color", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "density", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "start", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "end", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+   { glsl_type::float_type, "scale", glsl_precision_undefined, -1, 0, 0, 0, GLSL_MATRIX_LAYOUT_INHERITED, 0 },
+};
+
+#include "builtin_type_macros.h"
+/** @} */
+
+/**
+ * Code to populate a symbol table with the built-in types available in a
+ * particular shading language version.  The table below contains tags every
+ * type with the GLSL/GLSL ES versions where it was introduced.
+ *
+ * @{
+ */
+#define T(TYPE, MIN_GL, MIN_ES) \
+   { glsl_type::TYPE##_type, MIN_GL, MIN_ES },
+
+const static struct builtin_type_versions {
+   const glsl_type *const type;
+   int min_gl;
+   int min_es;
+} builtin_type_versions[] = {
+   T(void,                            110, 100)
+   T(bool,                            110, 100)
+   T(bvec2,                           110, 100)
+   T(bvec3,                           110, 100)
+   T(bvec4,                           110, 100)
+   T(int,                             110, 100)
+   T(ivec2,                           110, 100)
+   T(ivec3,                           110, 100)
+   T(ivec4,                           110, 100)
+   T(uint,                            130, 300)
+   T(uvec2,                           130, 300)
+   T(uvec3,                           130, 300)
+   T(uvec4,                           130, 300)
+   T(float,                           110, 100)
+   T(vec2,                            110, 100)
+   T(vec3,                            110, 100)
+   T(vec4,                            110, 100)
+   T(mat2,                            110, 100)
+   T(mat3,                            110, 100)
+   T(mat4,                            110, 100)
+   T(mat2x3,                          120, 300)
+   T(mat2x4,                          120, 300)
+   T(mat3x2,                          120, 300)
+   T(mat3x4,                          120, 300)
+   T(mat4x2,                          120, 300)
+   T(mat4x3,                          120, 300)
+
+   T(sampler1D,                       110, 999)
+   T(sampler2D,                       110, 100)
+   T(sampler3D,                       110, 300)
+   T(samplerCube,                     110, 100)
+   T(sampler1DArray,                  130, 999)
+   T(sampler2DArray,                  130, 300)
+   T(samplerCubeArray,                400, 999)
+   T(sampler2DRect,                   140, 999)
+   T(samplerBuffer,                   140, 999)
+   T(sampler2DMS,                     150, 999)
+   T(sampler2DMSArray,                150, 999)
+
+   T(isampler1D,                      130, 999)
+   T(isampler2D,                      130, 300)
+   T(isampler3D,                      130, 300)
+   T(isamplerCube,                    130, 300)
+   T(isampler1DArray,                 130, 999)
+   T(isampler2DArray,                 130, 300)
+   T(isamplerCubeArray,               400, 999)
+   T(isampler2DRect,                  140, 999)
+   T(isamplerBuffer,                  140, 999)
+   T(isampler2DMS,                    150, 999)
+   T(isampler2DMSArray,               150, 999)
+
+   T(usampler1D,                      130, 999)
+   T(usampler2D,                      130, 300)
+   T(usampler3D,                      130, 300)
+   T(usamplerCube,                    130, 300)
+   T(usampler1DArray,                 130, 999)
+   T(usampler2DArray,                 130, 300)
+   T(usamplerCubeArray,               400, 999)
+   T(usampler2DRect,                  140, 999)
+   T(usamplerBuffer,                  140, 999)
+   T(usampler2DMS,                    150, 999)
+   T(usampler2DMSArray,               150, 999)
+
+   T(sampler1DShadow,                 110, 999)
+   T(sampler2DShadow,                 110, 300)
+   T(samplerCubeShadow,               130, 300)
+   T(sampler1DArrayShadow,            130, 999)
+   T(sampler2DArrayShadow,            130, 300)
+   T(samplerCubeArrayShadow,          400, 999)
+   T(sampler2DRectShadow,             140, 999)
+
+   T(struct_gl_DepthRangeParameters,  110, 100)
+
+   T(image1D,                         420, 999)
+   T(image2D,                         420, 999)
+   T(image3D,                         420, 999)
+   T(image2DRect,                     420, 999)
+   T(imageCube,                       420, 999)
+   T(imageBuffer,                     420, 999)
+   T(image1DArray,                    420, 999)
+   T(image2DArray,                    420, 999)
+   T(imageCubeArray,                  420, 999)
+   T(image2DMS,                       420, 999)
+   T(image2DMSArray,                  420, 999)
+   T(iimage1D,                        420, 999)
+   T(iimage2D,                        420, 999)
+   T(iimage3D,                        420, 999)
+   T(iimage2DRect,                    420, 999)
+   T(iimageCube,                      420, 999)
+   T(iimageBuffer,                    420, 999)
+   T(iimage1DArray,                   420, 999)
+   T(iimage2DArray,                   420, 999)
+   T(iimageCubeArray,                 420, 999)
+   T(iimage2DMS,                      420, 999)
+   T(iimage2DMSArray,                 420, 999)
+   T(uimage1D,                        420, 999)
+   T(uimage2D,                        420, 999)
+   T(uimage3D,                        420, 999)
+   T(uimage2DRect,                    420, 999)
+   T(uimageCube,                      420, 999)
+   T(uimageBuffer,                    420, 999)
+   T(uimage1DArray,                   420, 999)
+   T(uimage2DArray,                   420, 999)
+   T(uimageCubeArray,                 420, 999)
+   T(uimage2DMS,                      420, 999)
+   T(uimage2DMSArray,                 420, 999)
+
+   T(atomic_uint,                     420, 999)
+};
+
+static const glsl_type *const deprecated_types[] = {
+   glsl_type::struct_gl_PointParameters_type,
+   glsl_type::struct_gl_MaterialParameters_type,
+   glsl_type::struct_gl_LightSourceParameters_type,
+   glsl_type::struct_gl_LightModelParameters_type,
+   glsl_type::struct_gl_LightModelProducts_type,
+   glsl_type::struct_gl_LightProducts_type,
+   glsl_type::struct_gl_FogParameters_type,
+};
+
+static inline void
+add_type(glsl_symbol_table *symbols, const glsl_type *const type)
+{
+   symbols->add_type(type->name, type);
+}
+
+/**
+ * Populate the symbol table with available built-in types.
+ */
+void
+_mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state)
+{
+   struct glsl_symbol_table *symbols = state->symbols;
+
+   for (unsigned i = 0; i < ARRAY_SIZE(builtin_type_versions); i++) {
+      const struct builtin_type_versions *const t = &builtin_type_versions[i];
+      if (state->is_version(t->min_gl, t->min_es)) {
+         add_type(symbols, t->type);
+      }
+   }
+
+   /* Add deprecated structure types.  While these were deprecated in 1.30,
+    * they're still present.  We've removed them in 1.40+ (OpenGL 3.1+).
+    */
+   if (!state->es_shader && state->language_version < 140) {
+      for (unsigned i = 0; i < ARRAY_SIZE(deprecated_types); i++) {
+         add_type(symbols, deprecated_types[i]);
+      }
+   }
+
+   /* Add types for enabled extensions.  They may have already been added
+    * by the version-based loop, but attempting to add them a second time
+    * is harmless.
+    */
+   if (state->ARB_texture_cube_map_array_enable) {
+      add_type(symbols, glsl_type::samplerCubeArray_type);
+      add_type(symbols, glsl_type::samplerCubeArrayShadow_type);
+      add_type(symbols, glsl_type::isamplerCubeArray_type);
+      add_type(symbols, glsl_type::usamplerCubeArray_type);
+   }
+
+   if (state->ARB_texture_multisample_enable) {
+      add_type(symbols, glsl_type::sampler2DMS_type);
+      add_type(symbols, glsl_type::isampler2DMS_type);
+      add_type(symbols, glsl_type::usampler2DMS_type);
+      add_type(symbols, glsl_type::sampler2DMSArray_type);
+      add_type(symbols, glsl_type::isampler2DMSArray_type);
+      add_type(symbols, glsl_type::usampler2DMSArray_type);
+   }
+
+   if (state->ARB_texture_rectangle_enable) {
+      add_type(symbols, glsl_type::sampler2DRect_type);
+      add_type(symbols, glsl_type::sampler2DRectShadow_type);
+   }
+
+   if (state->EXT_texture_array_enable) {
+      add_type(symbols, glsl_type::sampler1DArray_type);
+      add_type(symbols, glsl_type::sampler2DArray_type);
+      add_type(symbols, glsl_type::sampler1DArrayShadow_type);
+      add_type(symbols, glsl_type::sampler2DArrayShadow_type);
+   }
+
+   if (state->OES_EGL_image_external_enable) {
+      add_type(symbols, glsl_type::samplerExternalOES_type);
+   }
+
+   if (state->EXT_shadow_samplers_enable) {
+      add_type(symbols, glsl_type::sampler2DShadow_type);
+   }
+
+   if (state->OES_texture_3D_enable) {
+      add_type(symbols, glsl_type::sampler3D_type);
+   }
+
+   if (state->ARB_shader_image_load_store_enable) {
+      add_type(symbols, glsl_type::image1D_type);
+      add_type(symbols, glsl_type::image2D_type);
+      add_type(symbols, glsl_type::image3D_type);
+      add_type(symbols, glsl_type::image2DRect_type);
+      add_type(symbols, glsl_type::imageCube_type);
+      add_type(symbols, glsl_type::imageBuffer_type);
+      add_type(symbols, glsl_type::image1DArray_type);
+      add_type(symbols, glsl_type::image2DArray_type);
+      add_type(symbols, glsl_type::imageCubeArray_type);
+      add_type(symbols, glsl_type::image2DMS_type);
+      add_type(symbols, glsl_type::image2DMSArray_type);
+      add_type(symbols, glsl_type::iimage1D_type);
+      add_type(symbols, glsl_type::iimage2D_type);
+      add_type(symbols, glsl_type::iimage3D_type);
+      add_type(symbols, glsl_type::iimage2DRect_type);
+      add_type(symbols, glsl_type::iimageCube_type);
+      add_type(symbols, glsl_type::iimageBuffer_type);
+      add_type(symbols, glsl_type::iimage1DArray_type);
+      add_type(symbols, glsl_type::iimage2DArray_type);
+      add_type(symbols, glsl_type::iimageCubeArray_type);
+      add_type(symbols, glsl_type::iimage2DMS_type);
+      add_type(symbols, glsl_type::iimage2DMSArray_type);
+      add_type(symbols, glsl_type::uimage1D_type);
+      add_type(symbols, glsl_type::uimage2D_type);
+      add_type(symbols, glsl_type::uimage3D_type);
+      add_type(symbols, glsl_type::uimage2DRect_type);
+      add_type(symbols, glsl_type::uimageCube_type);
+      add_type(symbols, glsl_type::uimageBuffer_type);
+      add_type(symbols, glsl_type::uimage1DArray_type);
+      add_type(symbols, glsl_type::uimage2DArray_type);
+      add_type(symbols, glsl_type::uimageCubeArray_type);
+      add_type(symbols, glsl_type::uimage2DMS_type);
+      add_type(symbols, glsl_type::uimage2DMSArray_type);
+   }
+
+   if (state->ARB_shader_atomic_counters_enable) {
+      add_type(symbols, glsl_type::atomic_uint_type);
+   }
+}
+/** @} */

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glcpp/.gitignore

@@ -0,0 +1,10 @@
+glcpp
+glcpp-parse.output
+
+*.o
+*.lo
+*.la
+.libs
+*~
+
+tests/*.out

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glcpp/README

@@ -0,0 +1,30 @@
+glcpp -- GLSL "C" preprocessor
+
+This is a simple preprocessor designed to provide the preprocessing
+needs of the GLSL language. The requirements for this preprocessor are
+specified in the GLSL 1.30 specification availble from:
+
+http://www.opengl.org/registry/doc/GLSLangSpec.Full.1.30.10.pdf
+
+This specification is not precise on some semantics, (for example,
+#define and #if), defining these merely "as is standard for C++
+preprocessors". To fill in these details, I've been using a draft of
+the C99 standard as available from:
+
+http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf
+
+Any downstream compiler accepting output from glcpp should be prepared
+to encounter and deal with the following preprocessor macros:
+
+	#line
+	#pragma
+	#extension
+
+All other macros will be handled according to the GLSL specification
+and will not appear in the output.
+
+Known limitations
+-----------------
+A file that ends with a function-like macro name as the last
+non-whitespace token will result in a parse error, (where it should be
+passed through as is).

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glcpp/glcpp-lex.l

@@ -0,0 +1,578 @@
+%{
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "glcpp.h"
+#include "glcpp-parse.h"
+
+/* Flex annoyingly generates some functions without making them
+ * static. Let's declare them here. */
+int glcpp_get_column  (yyscan_t yyscanner);
+void glcpp_set_column (int  column_no , yyscan_t yyscanner);
+
+#ifdef _MSC_VER
+#define YY_NO_UNISTD_H
+#pragma warning(disable: 4267) // warning C4267: '=' : conversion from 'size_t' to 'int', possible loss of data
+#endif
+
+#define YY_NO_INPUT
+
+#define YY_USER_ACTION							\
+	do {								\
+		if (parser->has_new_line_number)			\
+			yylineno = parser->new_line_number;		\
+		if (parser->has_new_source_number)			\
+			yylloc->source = parser->new_source_number;	\
+		yylloc->first_column = yycolumn + 1;			\
+		yylloc->first_line = yylloc->last_line = yylineno;	\
+		yycolumn += yyleng;					\
+		yylloc->last_column = yycolumn + 1;			\
+		parser->has_new_line_number = 0;			\
+		parser->has_new_source_number = 0;			\
+	} while(0);
+
+#define YY_USER_INIT			\
+	do {				\
+		yylineno = 1;		\
+		yycolumn = 0;		\
+		yylloc->source = 0;	\
+	} while(0)
+
+/* It's ugly to have macros that have return statements inside of
+ * them, but flex-based lexer generation is all built around the
+ * return statement.
+ *
+ * To mitigate the ugliness, we defer as much of the logic as possible
+ * to an actual function, not a macro (see
+ * glcpplex_update_state_per_token) and we make the word RETURN
+ * prominent in all of the macros which may return.
+ *
+ * The most-commonly-used macro is RETURN_TOKEN which will perform all
+ * necessary state updates based on the provided token,, then
+ * conditionally return the token. It will not return a token if the
+ * parser is currently skipping tokens, (such as within #if
+ * 0...#else).
+ *
+ * The RETURN_TOKEN_NEVER_SKIP macro is a lower-level variant that
+ * makes the token returning unconditional. This is needed for things
+ * like #if and the tokens of its condition, (since these must be
+ * evaluated by the parser even when otherwise skipping).
+ *
+ * Finally, RETURN_STRING_TOKEN is a simple convenience wrapper on top
+ * of RETURN_TOKEN that performs a string copy of yytext before the
+ * return.
+ */
+#define RETURN_TOKEN_NEVER_SKIP(token)					\
+	do {								\
+		if (glcpp_lex_update_state_per_token (parser, token))	\
+			return token;					\
+	} while (0)
+
+#define RETURN_TOKEN(token)						\
+	do {								\
+		if (! parser->skipping) {				\
+			RETURN_TOKEN_NEVER_SKIP(token);			\
+		}							\
+	} while(0)
+
+#define RETURN_STRING_TOKEN(token)					\
+	do {								\
+		if (! parser->skipping) {				\
+			yylval->str = ralloc_strdup (yyextra, yytext);	\
+			RETURN_TOKEN_NEVER_SKIP (token);		\
+		}							\
+	} while(0)
+
+
+/* Update all state necessary for each token being returned.
+ *
+ * Here we'll be tracking newlines and spaces so that the lexer can
+ * alter its behavior as necessary, (for example, '#' has special
+ * significance if it is the first non-whitespace, non-comment token
+ * in a line, but does not otherwise).
+ *
+ * NOTE: If this function returns FALSE, then no token should be
+ * returned at all. This is used to suprress duplicate SPACE tokens.
+ */
+static int
+glcpp_lex_update_state_per_token (glcpp_parser_t *parser, int token)
+{
+	/* After the first non-space token in a line, we won't
+	 * allow any '#' to introduce a directive. */
+	if (token == NEWLINE) {
+		parser->first_non_space_token_this_line = 1;
+	} else if (token != SPACE) {
+		parser->first_non_space_token_this_line = 0;
+	}
+
+	/* Track newlines just to know whether a newline needs
+	 * to be inserted if end-of-file comes early. */
+	if (token == NEWLINE) {
+		parser->last_token_was_newline = 1;
+	} else {
+		parser->last_token_was_newline = 0;
+	}
+
+	/* Track spaces to avoid emitting multiple SPACE
+	 * tokens in a row. */
+	if (token == SPACE) {
+		if (! parser->last_token_was_space) {
+			parser->last_token_was_space = 1;
+			return 1;
+		} else {
+			parser->last_token_was_space = 1;
+			return 0;
+		}
+	} else {
+		parser->last_token_was_space = 0;
+		return 1;
+	}
+}
+
+
+%}
+
+%option bison-bridge bison-locations reentrant noyywrap
+%option extra-type="glcpp_parser_t *"
+%option prefix="glcpp_"
+%option stack
+%option never-interactive
+%option warn nodefault
+
+	/* Note: When adding any start conditions to this list, you must also
+	 * update the "Internal compiler error" catch-all rule near the end of
+	 * this file. */
+
+%x COMMENT DEFINE DONE HASH NEWLINE_CATCHUP UNREACHABLE
+
+SPACE		[[:space:]]
+NONSPACE	[^[:space:]]
+HSPACE		[ \t]
+HASH		#
+NEWLINE		(\r\n|\n\r|\r|\n)
+IDENTIFIER	[_a-zA-Z][_a-zA-Z0-9]*
+PP_NUMBER	[.]?[0-9]([._a-zA-Z0-9]|[eEpP][-+])*
+PUNCTUATION	[][(){}.&*~!/%<>^|;,=+-]
+
+/* The OTHER class is simply a catch-all for things that the CPP
+parser just doesn't care about. Since flex regular expressions that
+match longer strings take priority over those matching shorter
+strings, we have to be careful to avoid OTHER matching and hiding
+something that CPP does care about. So we simply exclude all
+characters that appear in any other expressions. */
+
+OTHER		[^][_#[:space:]#a-zA-Z0-9(){}.&*~!/%<>^|;,=+-]
+
+DIGITS			[0-9][0-9]*
+DECIMAL_INTEGER		[1-9][0-9]*[uU]?
+OCTAL_INTEGER		0[0-7]*[uU]?
+HEXADECIMAL_INTEGER	0[xX][0-9a-fA-F]+[uU]?
+
+%%
+
+	glcpp_parser_t *parser = yyextra;
+
+	/* When we lex a multi-line comment, we replace it (as
+	 * specified) with a single space. But if the comment spanned
+	 * multiple lines, then subsequent parsing stages will not
+	 * count correct line numbers. To avoid this problem we keep
+	 * track of all newlines that were commented out by a
+	 * multi-line comment, and we emit a NEWLINE token for each at
+	 * the next legal opportunity, (which is when the lexer would
+	 * be emitting a NEWLINE token anyway).
+	 */
+	if (YY_START == NEWLINE_CATCHUP) {
+		if (parser->commented_newlines)
+			parser->commented_newlines--;
+		if (parser->commented_newlines == 0)
+			BEGIN INITIAL;
+		RETURN_TOKEN_NEVER_SKIP (NEWLINE);
+	}
+
+	/* Set up the parser->skipping bit here before doing any lexing.
+	 *
+	 * This bit controls whether tokens are skipped, (as implemented by
+         * RETURN_TOKEN), such as between "#if 0" and "#endif".
+	 *
+	 * The parser maintains a skip_stack indicating whether we should be
+         * skipping, (and nested levels of #if/#ifdef/#ifndef/#endif) will
+         * push and pop items from the stack.
+	 *
+	 * Here are the rules for determining whether we are skipping:
+	 *
+	 *	1. If the skip stack is NULL, we are outside of all #if blocks
+	 *         and we are not skipping.
+	 *
+	 *	2. If the skip stack is non-NULL, the type of the top node in
+	 *	   the stack determines whether to skip. A type of
+	 *	   SKIP_NO_SKIP is used for blocks wheere we are emitting
+	 *	   tokens, (such as between #if 1 and #endif, or after the
+	 *	   #else of an #if 0, etc.).
+	 *
+	 *	3. The lexing_directive bit overrides the skip stack. This bit
+	 *	   is set when we are actively lexing the expression for a
+	 *	   pre-processor condition, (such as #if, #elif, or #else). In
+	 *	   this case, even if otherwise skipping, we need to emit the
+	 *	   tokens for this condition so that the parser can evaluate
+	 *	   the expression. (For, #else, there's no expression, but we
+	 *	   emit tokens so the parser can generate a nice error message
+	 *	   if there are any tokens here).
+	 */
+	if (parser->skip_stack &&
+	    parser->skip_stack->type != SKIP_NO_SKIP &&
+	    ! parser->lexing_directive)
+	{
+		parser->skipping = 1;
+	} else {
+		parser->skipping = 0;
+	}
+
+	/* Single-line comments */
+<INITIAL,DEFINE,HASH>"//"[^\r\n]* {
+}
+
+	/* Multi-line comments */
+<INITIAL,DEFINE,HASH>"/*"   { yy_push_state(COMMENT, yyscanner); }
+<COMMENT>[^*\r\n]*
+<COMMENT>[^*\r\n]*{NEWLINE} { yylineno++; yycolumn = 0; parser->commented_newlines++; }
+<COMMENT>"*"+[^*/\r\n]*
+<COMMENT>"*"+[^*/\r\n]*{NEWLINE} { yylineno++; yycolumn = 0; parser->commented_newlines++; }
+<COMMENT>"*"+"/"        {
+	yy_pop_state(yyscanner);
+	/* In the <HASH> start condition, we don't want any SPACE token. */
+	if (yyextra->space_tokens && YY_START != HASH)
+		RETURN_TOKEN (SPACE);
+}
+
+{HASH} {
+
+	/* If the '#' is the first non-whitespace, non-comment token on this
+	 * line, then it introduces a directive, switch to the <HASH> start
+	 * condition.
+	 *
+	 * Otherwise, this is just punctuation, so return the HASH_TOKEN
+         * token. */
+	if (parser->first_non_space_token_this_line) {
+		BEGIN HASH;
+	}
+
+	RETURN_TOKEN_NEVER_SKIP (HASH_TOKEN);
+}
+
+<HASH>version{HSPACE}+ {
+	BEGIN INITIAL;
+	yyextra->space_tokens = 0;
+	RETURN_STRING_TOKEN (VERSION_TOKEN);
+}
+
+	/* Swallow empty #pragma directives, (to avoid confusing the
+	 * downstream compiler).
+	 *
+	 * Note: We use a simple regular expression for the lookahead
+	 * here. Specifically, we cannot use the complete {NEWLINE} expression
+	 * since it uses alternation and we've found that there's a flex bug
+	 * where using alternation in the lookahead portion of a pattern
+	 * triggers a buffer overrun. */
+<HASH>pragma{HSPACE}*/[\r\n] {
+	BEGIN INITIAL;
+}
+
+	/* glcpp doesn't handle #extension, #version, or #pragma directives.
+	 * Simply pass them through to the main compiler's lexer/parser. */
+<HASH>(extension|pragma)[^\r\n]* {
+	BEGIN INITIAL;
+	RETURN_STRING_TOKEN (PRAGMA);
+}
+
+<HASH>line{HSPACE}+ {
+	BEGIN INITIAL;
+	RETURN_TOKEN (LINE);
+}
+
+<HASH>{NEWLINE} {
+	BEGIN INITIAL;
+	RETURN_TOKEN_NEVER_SKIP (NEWLINE);
+}
+
+	/* For the pre-processor directives, we return these tokens
+	 * even when we are otherwise skipping. */
+<HASH>ifdef {
+	BEGIN INITIAL;
+	yyextra->lexing_directive = 1;
+	yyextra->space_tokens = 0;
+	RETURN_TOKEN_NEVER_SKIP (IFDEF);
+}
+
+<HASH>ifndef {
+	BEGIN INITIAL;
+	yyextra->lexing_directive = 1;
+	yyextra->space_tokens = 0;
+	RETURN_TOKEN_NEVER_SKIP (IFNDEF);
+}
+
+<HASH>if/[^_a-zA-Z0-9] {
+	BEGIN INITIAL;
+	yyextra->lexing_directive = 1;
+	yyextra->space_tokens = 0;
+	RETURN_TOKEN_NEVER_SKIP (IF);
+}
+
+<HASH>elif/[^_a-zA-Z0-9] {
+	BEGIN INITIAL;
+	yyextra->lexing_directive = 1;
+	yyextra->space_tokens = 0;
+	RETURN_TOKEN_NEVER_SKIP (ELIF);
+}
+
+<HASH>else {
+	BEGIN INITIAL;
+	yyextra->space_tokens = 0;
+	RETURN_TOKEN_NEVER_SKIP (ELSE);
+}
+
+<HASH>endif {
+	BEGIN INITIAL;
+	yyextra->space_tokens = 0;
+	RETURN_TOKEN_NEVER_SKIP (ENDIF);
+}
+
+<HASH>error[^\r\n]* {
+	BEGIN INITIAL;
+	RETURN_STRING_TOKEN (ERROR_TOKEN);
+}
+
+	/* After we see a "#define" we enter the <DEFINE> start state
+	 * for the lexer. Within <DEFINE> we are looking for the first
+	 * identifier and specifically checking whether the identifier
+	 * is followed by a '(' or not, (to lex either a
+	 * FUNC_IDENTIFIER or an OBJ_IDENITIFIER token).
+	 *
+	 * While in the <DEFINE> state we also need to explicitly
+	 * handle a few other things that may appear before the
+	 * identifier:
+	 * 
+	 * 	* Comments, (handled above with the main support for
+	 * 	  comments).
+	 *
+	 *	* Whitespace (simply ignored)
+	 *
+	 *	* Anything else, (not an identifier, not a comment,
+	 *	  and not whitespace). This will generate an error.
+	 */
+<HASH>define{HSPACE}* {
+	if (! parser->skipping) {
+		BEGIN DEFINE;
+		yyextra->space_tokens = 0;
+		RETURN_TOKEN (DEFINE_TOKEN);
+	}
+}
+
+<HASH>undef {
+	BEGIN INITIAL;
+	yyextra->space_tokens = 0;
+	RETURN_TOKEN (UNDEF);
+}
+
+<HASH>{HSPACE}+ {
+	/* Nothing to do here. Importantly, don't leave the <HASH>
+	 * start condition, since it's legal to have space between the
+	 * '#' and the directive.. */
+}
+
+	/* This will catch any non-directive garbage after a HASH */
+<HASH>{NONSPACE} {
+	BEGIN INITIAL;
+	RETURN_TOKEN (GARBAGE);
+}
+
+	/* An identifier immediately followed by '(' */
+<DEFINE>{IDENTIFIER}/"(" {
+	BEGIN INITIAL;
+	RETURN_STRING_TOKEN (FUNC_IDENTIFIER);
+}
+
+	/* An identifier not immediately followed by '(' */
+<DEFINE>{IDENTIFIER} {
+	BEGIN INITIAL;
+	RETURN_STRING_TOKEN (OBJ_IDENTIFIER);
+}
+
+	/* Whitespace */
+<DEFINE>{HSPACE}+ {
+	/* Just ignore it. Nothing to do here. */
+}
+
+	/* '/' not followed by '*', so not a comment. This is an error. */
+<DEFINE>[/][^*]{NONSPACE}* {
+	BEGIN INITIAL;
+	glcpp_error(yylloc, yyextra, "#define followed by a non-identifier: %s", yytext);
+	RETURN_STRING_TOKEN (INTEGER_STRING);
+}
+
+	/* A character that can't start an identifier, comment, or
+	 * space. This is an error. */
+<DEFINE>[^_a-zA-Z/[:space:]]{NONSPACE}* {
+	BEGIN INITIAL;
+	glcpp_error(yylloc, yyextra, "#define followed by a non-identifier: %s", yytext);
+	RETURN_STRING_TOKEN (INTEGER_STRING);
+}
+
+{DECIMAL_INTEGER} {
+	RETURN_STRING_TOKEN (INTEGER_STRING);
+}
+
+{OCTAL_INTEGER} {
+	RETURN_STRING_TOKEN (INTEGER_STRING);
+}
+
+{HEXADECIMAL_INTEGER} {
+	RETURN_STRING_TOKEN (INTEGER_STRING);
+}
+
+"<<"  {
+	RETURN_TOKEN (LEFT_SHIFT);
+}
+
+">>" {
+	RETURN_TOKEN (RIGHT_SHIFT);
+}
+
+"<=" {
+	RETURN_TOKEN (LESS_OR_EQUAL);
+}
+
+">=" {
+	RETURN_TOKEN (GREATER_OR_EQUAL);
+}
+
+"==" {
+	RETURN_TOKEN (EQUAL);
+}
+
+"!=" {
+	RETURN_TOKEN (NOT_EQUAL);
+}
+
+"&&" {
+	RETURN_TOKEN (AND);
+}
+
+"||" {
+	RETURN_TOKEN (OR);
+}
+
+"++" {
+	RETURN_TOKEN (PLUS_PLUS);
+}
+
+"--" {
+	RETURN_TOKEN (MINUS_MINUS);
+}
+
+"##" {
+	if (! parser->skipping) {
+		if (parser->is_gles)
+			glcpp_error(yylloc, yyextra, "Token pasting (##) is illegal in GLES");
+		RETURN_TOKEN (PASTE);
+	}
+}
+
+"defined" {
+	RETURN_TOKEN (DEFINED);
+}
+
+{IDENTIFIER} {
+	RETURN_STRING_TOKEN (IDENTIFIER);
+}
+
+{PP_NUMBER} {
+	RETURN_STRING_TOKEN (OTHER);
+}
+
+{PUNCTUATION} {
+	RETURN_TOKEN (yytext[0]);
+}
+
+{OTHER}+ {
+	RETURN_STRING_TOKEN (OTHER);
+}
+
+{HSPACE} {
+	if (yyextra->space_tokens) {
+		RETURN_TOKEN (SPACE);
+	}
+}
+
+	/* We preserve all newlines, even between #if 0..#endif, so no
+	skipping.. */
+<*>{NEWLINE} {
+	if (parser->commented_newlines) {
+		BEGIN NEWLINE_CATCHUP;
+	} else {
+		BEGIN INITIAL;
+	}
+	yyextra->space_tokens = 1;
+	yyextra->lexing_directive = 0;
+	yylineno++;
+	yycolumn = 0;
+	RETURN_TOKEN_NEVER_SKIP (NEWLINE);
+}
+
+<INITIAL,COMMENT,DEFINE,HASH><<EOF>> {
+	if (YY_START == COMMENT)
+		glcpp_error(yylloc, yyextra, "Unterminated comment");
+	BEGIN DONE; /* Don't keep matching this rule forever. */
+	yyextra->lexing_directive = 0;
+	if (! parser->last_token_was_newline)
+		RETURN_TOKEN (NEWLINE);
+}
+
+	/* This is a catch-all to avoid the annoying default flex action which
+	 * matches any character and prints it. If any input ever matches this
+	 * rule, then we have made a mistake above and need to fix one or more
+	 * of the preceding patterns to match that input. */
+
+<*>. {
+	glcpp_error(yylloc, yyextra, "Internal compiler error: Unexpected character: %s", yytext);
+
+	/* We don't actually use the UNREACHABLE start condition. We
+	only have this block here so that we can pretend to call some
+	generated functions, (to avoid "defined but not used"
+	warnings. */
+        if (YY_START == UNREACHABLE) {
+		unput('.');
+		yy_top_state(yyextra);
+	}
+}
+
+%%
+
+void
+glcpp_lex_set_source_string(glcpp_parser_t *parser, const char *shader)
+{
+	yy_scan_string(shader, parser->scanner);
+}

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glcpp/glcpp-parse.h

@@ -0,0 +1,110 @@
+/* A Bison parser, made by GNU Bison 3.0.2.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2013 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 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, 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
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   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.  */
+
+#ifndef YY_GLCPP_PARSER_SRC_GLSL_GLCPP_GLCPP_PARSE_H_INCLUDED
+# define YY_GLCPP_PARSER_SRC_GLSL_GLCPP_GLCPP_PARSE_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 1
+#endif
+#if YYDEBUG
+extern int glcpp_parser_debug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    DEFINED = 258,
+    ELIF_EXPANDED = 259,
+    HASH_TOKEN = 260,
+    DEFINE_TOKEN = 261,
+    FUNC_IDENTIFIER = 262,
+    OBJ_IDENTIFIER = 263,
+    ELIF = 264,
+    ELSE = 265,
+    ENDIF = 266,
+    ERROR_TOKEN = 267,
+    IF = 268,
+    IFDEF = 269,
+    IFNDEF = 270,
+    LINE = 271,
+    PRAGMA = 272,
+    UNDEF = 273,
+    VERSION_TOKEN = 274,
+    GARBAGE = 275,
+    IDENTIFIER = 276,
+    IF_EXPANDED = 277,
+    INTEGER = 278,
+    INTEGER_STRING = 279,
+    LINE_EXPANDED = 280,
+    NEWLINE = 281,
+    OTHER = 282,
+    PLACEHOLDER = 283,
+    SPACE = 284,
+    PLUS_PLUS = 285,
+    MINUS_MINUS = 286,
+    PASTE = 287,
+    OR = 288,
+    AND = 289,
+    EQUAL = 290,
+    NOT_EQUAL = 291,
+    LESS_OR_EQUAL = 292,
+    GREATER_OR_EQUAL = 293,
+    LEFT_SHIFT = 294,
+    RIGHT_SHIFT = 295,
+    UNARY = 296
+  };
+#endif
+
+/* Value type.  */
+
+/* Location type.  */
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE YYLTYPE;
+struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+};
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+int glcpp_parser_parse (glcpp_parser_t *parser);
+
+#endif /* !YY_GLCPP_PARSER_SRC_GLSL_GLCPP_GLCPP_PARSE_H_INCLUDED  */

3rdparty/bgfx/3rdparty/glsl-optimizer/src/glsl/glcpp/glcpp.h

@@ -0,0 +1,253 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef GLCPP_H
+#define GLCPP_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "main/mtypes.h"
+
+#include "util/ralloc.h"
+
+#include "program/hash_table.h"
+
+#define yyscan_t void*
+
+/* Some data types used for parser values. */
+
+typedef struct expression_value {
+	intmax_t value;
+	char *undefined_macro;
+} expression_value_t;
+   
+
+typedef struct string_node {
+	const char *str;
+	struct string_node *next;
+} string_node_t;
+
+typedef struct string_list {
+	string_node_t *head;
+	string_node_t *tail;
+} string_list_t;
+
+typedef struct token token_t;
+typedef struct token_list token_list_t;
+
+typedef union YYSTYPE
+{
+	// Could be int, but results in some bugs with parsing of #version directives
+	// in Apple LLVM Compiler 4.2 when building for 32 bit.
+	intmax_t ival;
+	expression_value_t expression_value;
+	char *str;
+	string_list_t *string_list;
+	token_t *token;
+	token_list_t *token_list;
+} YYSTYPE;
+
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+
+typedef struct YYLTYPE {
+   int first_line;
+   int first_column;
+   int last_line;
+   int last_column;
+   unsigned source;
+} YYLTYPE;
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+
+# define YYLLOC_DEFAULT(Current, Rhs, N)			\
+do {								\
+   if (N)							\
+   {								\
+      (Current).first_line   = YYRHSLOC(Rhs, 1).first_line;	\
+      (Current).first_column = YYRHSLOC(Rhs, 1).first_column;	\
+      (Current).last_line    = YYRHSLOC(Rhs, N).last_line;	\
+      (Current).last_column  = YYRHSLOC(Rhs, N).last_column;	\
+   }								\
+   else								\
+   {								\
+      (Current).first_line   = (Current).last_line =		\
+	 YYRHSLOC(Rhs, 0).last_line;				\
+      (Current).first_column = (Current).last_column =		\
+	 YYRHSLOC(Rhs, 0).last_column;				\
+   }								\
+   (Current).source = 0;					\
+} while (0)
+
+struct token {
+	int type;
+	YYSTYPE value;
+	YYLTYPE location;
+};
+
+typedef struct token_node {
+	token_t *token;
+	struct token_node *next;
+} token_node_t;
+
+struct token_list {
+	token_node_t *head;
+	token_node_t *tail;
+	token_node_t *non_space_tail;
+};
+
+typedef struct argument_node {
+	token_list_t *argument;
+	struct argument_node *next;
+} argument_node_t;
+
+typedef struct argument_list {
+	argument_node_t *head;
+	argument_node_t *tail;
+} argument_list_t;
+
+typedef struct glcpp_parser glcpp_parser_t;
+
+typedef enum {
+	TOKEN_CLASS_IDENTIFIER,
+	TOKEN_CLASS_IDENTIFIER_FINALIZED,
+	TOKEN_CLASS_FUNC_MACRO,
+	TOKEN_CLASS_OBJ_MACRO
+} token_class_t;
+
+token_class_t
+glcpp_parser_classify_token (glcpp_parser_t *parser,
+			     const char *identifier,
+			     int *parameter_index);
+
+typedef struct {
+	int is_function;
+	string_list_t *parameters;
+	const char *identifier;
+	token_list_t *replacements;
+} macro_t;
+
+typedef struct expansion_node {
+	macro_t *macro;
+	token_node_t *replacements;
+	struct expansion_node *next;
+} expansion_node_t;
+
+typedef enum skip_type {
+	SKIP_NO_SKIP,
+	SKIP_TO_ELSE,
+	SKIP_TO_ENDIF
+} skip_type_t;
+
+typedef struct skip_node {
+	skip_type_t type;
+	bool has_else;
+	YYLTYPE loc; /* location of the initial #if/#elif/... */
+	struct skip_node *next;
+} skip_node_t;
+
+typedef struct active_list {
+	const char *identifier;
+	token_node_t *marker;
+	struct active_list *next;
+} active_list_t;
+
+struct glcpp_parser {
+	yyscan_t scanner;
+	struct hash_table *defines;
+	active_list_t *active;
+	int lexing_directive;
+	int space_tokens;
+	int last_token_was_newline;
+	int last_token_was_space;
+	int first_non_space_token_this_line;
+	int newline_as_space;
+	int in_control_line;
+	int paren_count;
+	int commented_newlines;
+	skip_node_t *skip_stack;
+	int skipping;
+	token_list_t *lex_from_list;
+	token_node_t *lex_from_node;
+	char *output;
+	char *info_log;
+	size_t output_length;
+	size_t info_log_length;
+	int error;
+	const struct gl_extensions *extensions;
+	gl_api api;
+	bool version_resolved;
+	bool has_new_line_number;
+	int new_line_number;
+	bool has_new_source_number;
+	int new_source_number;
+	bool is_gles;
+};
+
+struct gl_extensions;
+
+glcpp_parser_t *
+glcpp_parser_create (const struct gl_extensions *extensions, gl_api api);
+
+int
+glcpp_parser_parse (glcpp_parser_t *parser);
+
+void
+glcpp_parser_destroy (glcpp_parser_t *parser);
+
+void
+glcpp_parser_resolve_implicit_version(glcpp_parser_t *parser);
+
+int
+glcpp_preprocess(void *ralloc_ctx, const char **shader, char **info_log,
+	   const struct gl_extensions *extensions, struct gl_context *g_ctx);
+
+/* Functions for writing to the info log */
+
+void
+glcpp_error (YYLTYPE *locp, glcpp_parser_t *parser, const char *fmt, ...);
+
+void
+glcpp_warning (YYLTYPE *locp, glcpp_parser_t *parser, const char *fmt, ...);
+
+/* Generated by glcpp-lex.l to glcpp-lex.c */
+
+int
+glcpp_lex_init_extra (glcpp_parser_t *parser, yyscan_t* scanner);
+
+void
+glcpp_lex_set_source_string(glcpp_parser_t *parser, const char *shader);
+
+int
+glcpp_lex (YYSTYPE *lvalp, YYLTYPE *llocp, yyscan_t scanner);
+
+int
+glcpp_lex_destroy (yyscan_t scanner);
+
+/* Generated by glcpp-parse.y to glcpp-parse.c */
+
+int
+yyparse (glcpp_parser_t *parser);
+
+#endif