# encoding=utf-8
# Copyright © 2019 Google

# 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.

from __future__ import print_function
import sys
import subprocess
import tempfile
import re
from collections import namedtuple


Test = namedtuple("Test", "name source match_re")


TESTS = [
    Test("f32 simple division",
         """
         uniform mediump float a, b;

         void main()
         {
                 gl_FragColor.rgba = vec4(a / b);
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 simple division",
         """
         #version 300 es
         precision mediump float;
         precision mediump int;
         uniform mediump int a, b;

         out vec4 color;

         void main()
         {
                 color = vec4(a / b);
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 simple division",
         """
         #version 300 es
         precision mediump float;
         precision mediump int;
         uniform mediump uint a, b;

         out vec4 color;

         void main()
         {
                 color = vec4(a / b);
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("dot",
         """
         uniform mediump vec2 a, b;

         void main()
         {
                 gl_FragColor.rgba = vec4(dot(a, b));
         }
         """,
         r'\(expression +float16_t +dot\b'),
    Test("f32 array with const index",
         """
         precision mediump float;

         uniform float in_simple[2];

         void main()
         {
                 gl_FragColor = vec4(in_simple[0] / in_simple[1]);
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 array with const index",
         """
         #version 300 es
         precision mediump float;
         precision mediump int;

         uniform int in_simple[2];

         out vec4 color;

         void main()
         {
                 color = vec4(in_simple[0] / in_simple[1]);
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 array with const index",
         """
         #version 300 es
         precision mediump float;
         precision mediump int;

         uniform uint in_simple[2];

         out vec4 color;

         void main()
         {
                 color = vec4(in_simple[0] / in_simple[1]);
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 array with uniform index",
         """
         precision mediump float;

         uniform float in_simple[2];
         uniform int i0, i1;

         void main()
         {
                 gl_FragColor = vec4(in_simple[i0] / in_simple[i1]);
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 array with uniform index",
         """
         #version 300 es
         precision mediump float;
         precision mediump int;

         uniform int in_simple[2];
         uniform int i0, i1;

         out vec4 color;

         void main()
         {
                 color = vec4(in_simple[i0] / in_simple[i1]);
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 array with uniform index",
         """
         #version 300 es
         precision mediump float;
         precision mediump int;

         uniform uint in_simple[2];
         uniform int i0, i1;

         out vec4 color;

         void main()
         {
                 color = vec4(in_simple[i0] / in_simple[i1]);
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 array-of-array with const index",
         """
         #version 310 es
         precision mediump float;

         uniform float in_aoa[2][2];

         layout(location = 0) out float out_color;

         void main()
         {
                 out_color = in_aoa[0][0] / in_aoa[1][1];
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 array-of-array with const index",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int in_aoa[2][2];

         layout(location = 0) out highp int out_color;

         void main()
         {
                 out_color = in_aoa[0][0] / in_aoa[1][1];
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 array-of-array with const index",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint in_aoa[2][2];

         layout(location = 0) out highp uint out_color;

         void main()
         {
                 out_color = in_aoa[0][0] / in_aoa[1][1];
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 array-of-array with uniform index",
         """
         #version 310 es
         precision mediump float;

         uniform float in_aoa[2][2];
         uniform int i0, i1;

         layout(location = 0) out float out_color;

         void main()
         {
                 out_color = in_aoa[i0][i0] / in_aoa[i1][i1];
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 array-of-array with uniform index",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int in_aoa[2][2];
         uniform int i0, i1;

         layout(location = 0) out highp int out_color;

         void main()
         {
                 out_color = in_aoa[i0][i0] / in_aoa[i1][i1];
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 array-of-array with uniform index",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint in_aoa[2][2];
         uniform int i0, i1;

         layout(location = 0) out highp uint out_color;

         void main()
         {
                 out_color = in_aoa[i0][i0] / in_aoa[i1][i1];
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 array index",
         """
         uniform mediump float a, b;
         uniform mediump float values[2];

         void main()
         {
                 gl_FragColor.rgba = vec4(values[int(a / b)]);
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 array index",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform mediump int a, b;
         uniform mediump int values[2];

         out highp int color;

         void main()
         {
                 color = values[a / b];
         }
         """,
         r'\(expression +int16_t +/'),
    Test("f32 function",
         """
         precision mediump float;

         uniform float a, b;

         mediump float
         get_a()
         {
                 return a;
         }

         float
         get_b()
         {
                 return b;
         }

         void main()
         {
                 gl_FragColor = vec4(get_a() / get_b());
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 function",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int a, b;

         mediump int
         get_a()
         {
                 return a;
         }

         int
         get_b()
         {
                 return b;
         }

         out highp int color;

         void main()
         {
                 color = get_a() / get_b();
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 function",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint a, b;

         mediump uint
         get_a()
         {
                 return a;
         }

         uint
         get_b()
         {
                 return b;
         }

         out highp uint color;

         void main()
         {
                 color = get_a() / get_b();
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 function mediump args",
         """
         precision mediump float;

         uniform float a, b;

         mediump float
         do_div(float x, float y)
         {
                 return x / y;
         }

         void main()
         {
                 gl_FragColor = vec4(do_div(a, b));
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 function mediump args",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int a, b;

         mediump int
         do_div(int x, int y)
         {
                 return x / y;
         }

         out highp int color;

         void main()
         {
                 color = do_div(a, b);
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 function mediump args",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint a, b;

         mediump uint
         do_div(uint x, uint y)
         {
                 return x / y;
         }

         out highp uint color;

         void main()
         {
                 color = do_div(a, b);
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 function highp args",
         """
         precision mediump float;

         uniform float a, b;

         mediump float
         do_div(highp float x, highp float y)
         {
                 return x / y;
         }

         void main()
         {
                 gl_FragColor = vec4(do_div(a, b));
         }
         """,
         r'\(expression +float +/'),
    Test("i32 function highp args",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int a, b;

         mediump int
         do_div(highp int x, highp int y)
         {
                 return x / y;
         }

         out highp int color;

         void main()
         {
                  color = do_div(a, b);
         }
         """,
         r'\(expression +int +/'),
    Test("u32 function highp args",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint a, b;

         mediump uint
         do_div(highp uint x, highp uint y)
         {
                 return x / y;
         }

         out highp uint color;

         void main()
         {
                  color = do_div(a, b);
         }
         """,
         r'\(expression +uint +/'),
    Test("f32 function inout different precision highp",
         """
         uniform mediump float a, b;

         void
         do_div(inout highp float x, highp float y)
         {
                 x = x / y;
         }

         void main()
         {
                 mediump float temp = a;
                 do_div(temp, b);
                 gl_FragColor = vec4(temp);
         }
         """,
         r'\(expression +float +/'),
    Test("i32 function inout different precision highp",
         """
         #version 310 es
         uniform mediump int a, b;

         void
         do_div(inout highp int x, highp int y)
         {
                 x = x / y;
         }

         out mediump int color;

         void main()
         {
                 mediump int temp = a;
                 do_div(temp, b);
                 color = temp;
         }
         """,
         r'\(expression +int +/'),
    Test("u32 function inout different precision highp",
         """
         #version 310 es
         uniform mediump uint a, b;

         void
         do_div(inout highp uint x, highp uint y)
         {
                 x = x / y;
         }

         out mediump uint color;

         void main()
         {
                 mediump uint temp = a;
                 do_div(temp, b);
                 color = temp;
         }
         """,
         r'\(expression +uint +/'),
    Test("f32 function inout different precision mediump",
         """
         uniform highp float a, b;

         void
         do_div(inout mediump float x, mediump float y)
         {
                 x = x / y;
         }

         void main()
         {
                 highp float temp = a;
                 do_div(temp, b);
                 gl_FragColor = vec4(temp);
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 function inout different precision mediump",
         """
         #version 310 es
         uniform highp int a, b;

         out highp int color;

         void
         do_div(inout mediump int x, mediump int y)
         {
                 x = x / y;
         }

         void main()
         {
                 highp int temp = a;
                 do_div(temp, b);
                 color = temp;
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 function inout different precision mediump",
         """
         #version 310 es
         uniform highp uint a, b;

         out highp uint color;

         void
         do_div(inout mediump uint x, mediump uint y)
         {
                 x = x / y;
         }

         void main()
         {
                 highp uint temp = a;
                 do_div(temp, b);
                 color = temp;
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 if",
         """
         precision mediump float;

         uniform float a, b;

         void
         main()
         {
                 if (a / b < 0.31)
                         gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
                 else
                         gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 if",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int a, b;

         out vec4 color;

         void
         main()
         {
                 if (a / b < 10)
                         color = vec4(0.0, 1.0, 0.0, 1.0);
                 else
                         color = vec4(1.0, 0.0, 0.0, 1.0);
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 if",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint a, b;

         out vec4 color;

         void
         main()
         {
                 if (a / b < 10u)
                         color = vec4(0.0, 1.0, 0.0, 1.0);
                 else
                         color = vec4(1.0, 0.0, 0.0, 1.0);
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("matrix",
         """
         precision mediump float;

         uniform vec2 a;
         uniform mat2 b;

         void main()
         {
             gl_FragColor = vec4(b * a, 0.0, 0.0);
         }
         """,
         r'\(expression +f16vec2 \* \(var_ref b\) \(var_ref a\)'),
    Test("f32 simple struct deref",
         """
         precision mediump float;

         struct simple {
                 float a, b;
         };

         uniform simple in_simple;

         void main()
         {
                 gl_FragColor = vec4(in_simple.a / in_simple.b);
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 simple struct deref",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         struct simple {
                 int a, b;
         };

         uniform simple in_simple;

         out highp int color;

         void main()
         {
                 color = in_simple.a / in_simple.b;
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 simple struct deref",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         struct simple {
                 uint a, b;
         };

         uniform simple in_simple;

         out highp uint color;

         void main()
         {
                 color = in_simple.a / in_simple.b;
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 embedded struct deref",
         """
         precision mediump float;

         struct simple {
                 float a, b;
         };

         struct embedded {
                 simple a, b;
         };

         uniform embedded in_embedded;

         void main()
         {
                 gl_FragColor = vec4(in_embedded.a.a / in_embedded.b.b);
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 embedded struct deref",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         struct simple {
                 int a, b;
         };

         struct embedded {
                 simple a, b;
         };

         uniform embedded in_embedded;

         out highp int color;

         void main()
         {
                 color = in_embedded.a.a / in_embedded.b.b;
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 embedded struct deref",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         struct simple {
                 uint a, b;
         };

         struct embedded {
                 simple a, b;
         };

         uniform embedded in_embedded;

         out highp uint color;

         void main()
         {
                 color = in_embedded.a.a / in_embedded.b.b;
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 arrayed struct deref",
         """
         precision mediump float;

         struct simple {
                 float a, b;
         };

         struct arrayed {
                 simple a[2];
         };

         uniform arrayed in_arrayed;

         void main()
         {
                 gl_FragColor = vec4(in_arrayed.a[0].a / in_arrayed.a[1].b);
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 arrayed struct deref",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         struct simple {
                 int a, b;
         };

         struct arrayed {
                 simple a[2];
         };

         uniform arrayed in_arrayed;

         out highp int color;

         void main()
         {
                 color = in_arrayed.a[0].a / in_arrayed.a[1].b;
         }
         """,
         r'\(expression +int16_t +/'),
    Test("u32 arrayed struct deref",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         struct simple {
                 uint a, b;
         };

         struct arrayed {
                 simple a[2];
         };

         uniform arrayed in_arrayed;

         out highp uint color;

         void main()
         {
                 color = in_arrayed.a[0].a / in_arrayed.a[1].b;
         }
         """,
         r'\(expression +uint16_t +/'),
    Test("f32 mixed precision not lowered",
         """
         uniform mediump float a;
         uniform highp float b;

         void main()
         {
                 gl_FragColor = vec4(a / b);
         }
         """,
         r'\(expression +float +/'),
    Test("i32 mixed precision not lowered",
         """
         #version 310 es
         uniform mediump int a;
         uniform highp int b;

         out mediump int color;

         void main()
         {
                 color = a / b;
         }
         """,
         r'\(expression +int +/'),
    Test("u32 mixed precision not lowered",
         """
         #version 310 es
         uniform mediump uint a;
         uniform highp uint b;

         out mediump uint color;

         void main()
         {
                 color = a / b;
         }
         """,
         r'\(expression +uint +/'),
    Test("f32 sampler array",
         """
         #version 320 es
         precision mediump float;
         precision mediump int;

         uniform sampler2D tex[2];
         // highp shouldn't affect the return value of texture2D
         uniform highp vec2 coord;
         uniform float divisor;
         uniform int index;

         out highp vec4 color;

         void main()
         {
                 color = texture2D(tex[index], coord) / divisor;
         }
         """,
         r'\(expression +f16vec4 +/.*\(tex +f16vec4 +'),
    Test("f32 texture sample",
         """
         precision mediump float;

         uniform sampler2D tex;
         // highp shouldn't affect the return value of texture2D
         uniform highp vec2 coord;
         uniform float divisor;

         void main()
         {
                 gl_FragColor = texture2D(tex, coord) / divisor;
         }
         """,
         r'\(expression +f16vec4 +/.*\(tex +f16vec4 +'),
    Test("i32 texture sample",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform mediump isampler2D tex;
         // highp shouldn't affect the return value of texture
         uniform highp vec2 coord;
         uniform int divisor;

         out highp ivec4 color;

         void main()
         {
                 color = texture(tex, coord) / divisor;
         }
         """,
         r'\(expression +i16vec4 +/.*\(tex +i16vec4 +'),
    Test("u32 texture sample",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform mediump usampler2D tex;
         // highp shouldn't affect the return value of texture
         uniform highp vec2 coord;
         uniform uint divisor;

         out highp uvec4 color;

         void main()
         {
                 color = texture(tex, coord) / divisor;
         }
         """,
         r'\(expression +u16vec4 +/.*\(tex +u16vec4 +'),
    Test("f32 image array",
         """
         #version 320 es
         precision mediump float;

         layout(rgba16f) readonly uniform mediump image2D img[2];
         // highp shouldn't affect the return value of imageLoad
         uniform highp ivec2 coord;
         uniform float divisor;

         out highp vec4 color;

         void main()
         {
                 color = imageLoad(img[1], coord) / divisor;
         }
         """,
         r'\(expression +f16vec4 +/'),
    Test("f32 image load",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         layout(rgba16f) readonly uniform mediump image2D img;
         // highp shouldn't affect the return value of imageLoad
         uniform highp ivec2 coord;
         uniform float divisor;

         out highp vec4 color;

         void main()
         {
                 color = imageLoad(img, coord) / divisor;
         }
         """,
         r'\(expression +f16vec4 +/'),
    Test("i32 image load",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         layout(rgba16i) readonly uniform mediump iimage2D img;
         // highp shouldn't affect the return value of imageLoad
         uniform highp ivec2 coord;
         uniform int divisor;

         out highp ivec4 color;

         void main()
         {
                 color = imageLoad(img, coord) / divisor;
         }
         """,
         r'\(expression +i16vec4 +/'),
    Test("u32 image load",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         layout(rgba16ui) readonly uniform mediump uimage2D img;
         // highp shouldn't affect the return value of imageLoad
         uniform highp ivec2 coord;
         uniform uint divisor;

         out highp uvec4 color;

         void main()
         {
                 color = imageLoad(img, coord) / divisor;
         }
         """,
         r'\(expression +u16vec4 +/'),
    Test("f32 expression in lvalue",
         """
         uniform mediump float a, b;

         void main()
         {
                 gl_FragColor = vec4(1.0);
                 gl_FragColor[int(a / b)] = 0.5;
         }
         """,
         r'\(expression +float16_t +/'),
    Test("i32 expression in lvalue",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform mediump int a, b;

         out vec4 color;

         void main()
         {
                 color = vec4(1.0);
                 color[a / b] = 0.5;
         }
         """,
         r'\(expression +int16_t +/'),
    Test("f32 builtin with const arg",
         """
         uniform mediump float a;

         void main()
         {
                 gl_FragColor = vec4(min(a, 3.0));
         }
         """,
         r'\(expression +float16_t min'),
    Test("i32 builtin with const arg",
         """
         #version 310 es
         uniform mediump int a;

         out highp int color;

         void main()
         {
                 color = min(a, 3);
         }
         """,
         r'\(expression +int16_t min'),
    Test("u32 builtin with const arg",
         """
         #version 310 es
         uniform mediump uint a;

         out highp uint color;

         void main()
         {
                 color = min(a, 3u);
         }
         """,
         r'\(expression +uint16_t min'),
    Test("dFdx",
         """
         #version 300 es
         precision mediump float;

         in vec4 var;
         out vec4 color;

         void main()
         {
                 color = dFdx(var);
         }
         """,
         r'\(expression +f16vec4 +dFdx +\(expression +f16vec4'),
    Test("dFdy",
         """
         #version 300 es
         precision mediump float;

         in vec4 var;
         out vec4 color;

         void main()
         {
                 color = dFdy(var);
         }
         """,
         r'\(expression +f16vec4 +dFdy +\(expression +f16vec4'),
    Test("textureSize",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform mediump sampler2D tex;
         out ivec2 color;

         void main()
         {
                 color = textureSize(tex, 0) * ivec2(2);
         }
         """,
         r'expression ivec2 \* \(txs ivec2 \(var_ref tex'),
    Test("floatBitsToInt",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform float val;
         out int color;

         void main()
         {
                 color = floatBitsToInt(val + 1.0) + 1;
         }
         """,
         r'expression int bitcast_f2i \(expression float'),
    Test("floatBitsToUint",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform float val;
         out uint color;

         void main()
         {
                 color = floatBitsToUint(val + 1.0) + 1u;
         }
         """,
         r'expression uint bitcast_f2u \(expression float'),
    Test("intBitsToFloat",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int val;
         out float color;

         void main()
         {
                 color = intBitsToFloat(val + 1) + 1.0;
         }
         """,
         r'expression float bitcast_i2f \(expression int'),
    Test("uintBitsToFloat",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint val;
         out float color;

         void main()
         {
                 color = uintBitsToFloat(val + 1u) + 1.0;
         }
         """,
         r'expression float bitcast_u2f \(expression uint'),
    Test("bitfieldReverse",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int val;
         out int color;

         void main()
         {
                 color = bitfieldReverse(val + 1) + 1;
         }
         """,
         r'expression int bitfield_reverse \(expression int'),
    Test("frexp",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform float val;
         out float color;
         out int color2;

         void main()
         {
                 int y;
                 float x = frexp(val + 1.0, y);
                 color = x + 1.0;
                 color2 = y + 1;
         }
         """,
         r'assign  \(x\) \(var_ref x\)  \(expression float f162f'),
    Test("ldexp",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform float val;
         uniform int exp;
         out float color;

         void main()
         {
                 color = ldexp(val + 1.0, exp + 1) + 1.0;
         }
         """,
         r'expression float ldexp \(expression float'),
    Test("uaddCarry",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint x, y;
         out uint color;

         void main()
         {
                 lowp uint carry;
                 color = uaddCarry(x * 2u, y * 2u, carry) * 2u;
                 color *= carry;
         }
         """,
         r'expression uint \+ \(var_ref x\) \(var_ref y'),
    Test("usubBorrow",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint x, y;
         out uint color;

         void main()
         {
                 lowp uint borrow;
                 color = usubBorrow(x * 2u, y * 2u, borrow) * 2u;
                 color *= borrow;
         }
         """,
         r'expression uint \+ \(var_ref x\) \(expression uint neg'),
    Test("imulExtended",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int x, y;
         out int color;

         void main()
         {
                 int msb, lsb;
                 imulExtended(x + 2, y + 2, msb, lsb);
                 color = msb + lsb;
         }
         """,
         r'expression int64_t \* \(expression int'),
    Test("umulExtended",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint x, y;
         out uint color;

         void main()
         {
                 uint msb, lsb;
                 umulExtended(x + 2u, y + 2u, msb, lsb);
                 color = msb + lsb;
         }
         """,
         r'expression uint64_t \* \(expression uint'),
    Test("unpackUnorm2x16",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint val;
         out vec2 color;

         void main()
         {
                 color = unpackUnorm2x16(val + 1u) + vec2(1.0);
         }
         """,
         r'expression vec2 unpackUnorm2x16 \(expression uint'),
    Test("unpackSnorm2x16",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint val;
         out vec2 color;

         void main()
         {
                 color = unpackSnorm2x16(val + 1u) + vec2(1.0);
         }
         """,
         r'expression vec2 unpackSnorm2x16 \(expression uint'),
    Test("packUnorm2x16",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform vec2 val;
         out uint color;

         void main()
         {
                 color = packUnorm2x16(val + vec2(1.0)) + 1u;
         }
         """,
         r'expression uint packUnorm2x16 \(expression vec2'),
    Test("packSnorm2x16",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform vec2 val;
         out uint color;

         void main()
         {
                 color = packSnorm2x16(val + vec2(1.0)) + 1u;
         }
         """,
         r'expression uint packSnorm2x16 \(expression vec2'),
    Test("packHalf2x16",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform vec2 val;
         out uint color;

         void main()
         {
                 color = packHalf2x16(val + vec2(1.0)) + 1u;
         }
         """,
         r'expression uint packHalf2x16 \(expression vec2'),
    Test("packUnorm4x8",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform vec4 val;
         out uint color;

         void main()
         {
                 color = packUnorm4x8(val + vec4(1.0)) + 1u;
         }
         """,
         r'expression uint packUnorm4x8 \(expression vec4'),
    Test("packSnorm4x8",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform vec4 val;
         out uint color;

         void main()
         {
                 color = packSnorm4x8(val + vec4(1.0)) + 1u;
         }
         """,
         r'expression uint packSnorm4x8 \(expression vec4'),
    Test("interpolateAtCentroid",
         """
         #version 320 es
         precision mediump float;
         precision mediump int;

         in float val;
         out float color;

         void main()
         {
                 color = interpolateAtCentroid(val) + 1.0;
         }
         """,
         r'expression float16_t interpolate_at_centroid \(expression float16_t'),
    Test("interpolateAtOffset",
         """
         #version 320 es
         precision mediump float;
         precision mediump int;

         uniform highp vec2 offset;
         in float val;
         out float color;

         void main()
         {
                 color = interpolateAtOffset(val, offset) + 1.0;
         }
         """,
         r'expression float16_t interpolate_at_offset \(expression float16_t'),
    Test("interpolateAtSample",
         """
         #version 320 es
         precision mediump float;
         precision mediump int;

         uniform highp int sample_index;
         in float val;
         out float color;

         void main()
         {
                 color = interpolateAtSample(val, sample_index) + 1.0;
         }
         """,
         r'expression float16_t interpolate_at_sample \(expression float16_t'),
    Test("bitfieldExtract",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform highp int offset, bits;
         uniform int val;
         out int color;

         void main()
         {
                 color = bitfieldExtract(val, offset, bits) + 1;
         }
         """,
         r'expression int16_t bitfield_extract \(expression int16_t'),
    Test("bitfieldInsert",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform highp int offset, bits;
         uniform int val, val2;
         out int color;

         void main()
         {
                 color = bitfieldInsert(val, val2, offset, bits) + 1;
         }
         """,
         r'expression int16_t bitfield_insert \(expression int16_t'),
    Test("bitCount",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform highp int val;
         out int color;

         void main()
         {
                 color = bitCount(val) + 1;
         }
         """,
         r'expression int16_t \+ \(expression int16_t i2imp \(expression int bit_count \(var_ref val'),
    Test("findLSB",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform highp int val;
         out int color;

         void main()
         {
                 color = findLSB(val) + 1;
         }
         """,
         r'expression int16_t \+ \(expression int16_t i2imp \(expression int find_lsb \(var_ref val'),
    Test("findMSB",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform highp int val;
         out int color;

         void main()
         {
                 color = findMSB(val) + 1;
         }
         """,
         r'expression int16_t \+ \(expression int16_t i2imp \(expression int find_msb \(var_ref val'),
    Test("unpackHalf2x16",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform highp uint val;
         out vec2 color;

         void main()
         {
                 color = unpackHalf2x16(val) + vec2(1.0);
         }
         """,
         r'expression f16vec2 \+ \(expression f16vec2 f2fmp \(expression vec2 unpackHalf2x16 \(var_ref val'),
    Test("unpackUnorm4x8",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform highp uint val;
         out vec4 color;

         void main()
         {
                 color = unpackUnorm4x8(val) + vec4(1.0);
         }
         """,
         r'expression f16vec4 \+ \(expression f16vec4 f2fmp \(expression vec4 unpackUnorm4x8 \(var_ref val'),
    Test("unpackSnorm4x8",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform highp uint val;
         out vec4 color;

         void main()
         {
                 color = unpackSnorm4x8(val) + vec4(1.0);
         }
         """,
         r'expression f16vec4 \+ \(expression f16vec4 f2fmp \(expression vec4 unpackSnorm4x8 \(var_ref val'),
    Test("f32 csel",
         """
         #version 300 es
         precision mediump float;

         in vec4 var;
         out vec4 color;

         void main()
         {
                 color = (var.x > var.y) ? var : vec4(10.0);
         }
         """,
         r'\(constant +f16vec4 \(10'),
    Test("i32 csel",
         """
         #version 310 es
         precision mediump int;

         in flat ivec4 var;
         out ivec4 color;

         void main()
         {
                 color = (var.x > var.y) ? var : ivec4(10);
         }
         """,
         r'\(constant +i16vec4 \(10'),
    Test("u32 csel",
         """
         #version 310 es
         precision mediump int;

         in flat uvec4 var;
         out uvec4 color;

         void main()
         {
                 color = (var.x > var.y) ? var : uvec4(10);
         }
         """,
         r'\(constant +u16vec4 \(10'),
    Test("f32 loop counter",
         """
         #version 300 es
         precision mediump float;

         uniform float n, incr;
         out float color;

         void main()
         {
                 color = 0.0;
                 for (float x = 0.0; x < n; x += incr)
                    color += x;
         }
         """,
         r'\(assign  \(x\) \(var_ref x\)  \(expression float16_t \+ \(var_ref x\) \(var_ref incr'),
    Test("i32 loop counter",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform int n, incr;
         out int color;

         void main()
         {
                 color = 0;
                 for (int x = 0; x < n; x += incr)
                    color += x;
         }
         """,
         r'\(assign  \(x\) \(var_ref x\)  \(expression int16_t \+ \(var_ref x\) \(expression int16_t i2imp \(var_ref incr'),
    Test("u32 loop counter",
         """
         #version 310 es
         precision mediump float;
         precision mediump int;

         uniform uint n, incr;
         out uint color;

         void main()
         {
                 color = 0u;
                 for (uint x = 0u; x < n; x += incr)
                    color += x;
         }
         """,
         r'\(assign  \(x\) \(var_ref x\)  \(expression uint16_t \+ \(var_ref x\) \(expression uint16_t u2ump \(var_ref incr'),
    Test("f32 temp array",
         """
         #version 300 es
         precision mediump float;

         uniform float x,y;
         out float color;

         void main()
         {
                 float a[2] = float[2](x, y);
                 if (x > 0.0)
                     a[1] = 3.0;
                 color = a[0] + a[1];
         }
         """,
         r'\(constant float16_t \(3'),
    Test("i32 temp array",
         """
         #version 310 es
         precision mediump int;

         uniform int x,y;
         out int color;

         void main()
         {
                 int a[2] = int[2](x, y);
                 if (x > 0)
                     a[1] = 3;
                 color = a[0] + a[1];
         }
         """,
         r'\(constant int16_t \(3'),
    Test("u32 temp array",
         """
         #version 310 es
         precision mediump int;

         uniform uint x,y;
         out uint color;

         void main()
         {
                 uint a[2] = uint[2](x, y);
                 if (x > 0u)
                     a[1] = 3u;
                 color = a[0] + a[1];
         }
         """,
         r'\(constant uint16_t \(3'),
    Test("f32 temp array of array",
         """
         #version 310 es
         precision mediump float;

         uniform float x,y;
         out float color;

         void main()
         {
                 float a[2][2] = float[2][2](float[2](x, y), float[2](x, y));
                 if (x > 0.0)
                     a[1][1] = 3.0;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant float16_t \(3'),
    Test("i32 temp array of array",
         """
         #version 310 es
         precision mediump int;

         uniform int x,y;
         out int color;

         void main()
         {
                 int a[2][2] = int[2][2](int[2](x, y), int[2](x, y));
                 if (x > 0)
                     a[1][1] = 3;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant int16_t \(3'),
    Test("u32 temp array of array",
         """
         #version 310 es
         precision mediump int;

         uniform uint x,y;
         out uint color;

         void main()
         {
                 uint a[2][2] = uint[2][2](uint[2](x, y), uint[2](x, y));
                 if (x > 0u)
                     a[1][1] = 3u;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant uint16_t \(3'),
    Test("f32 temp array of array assigned from highp",
         """
         #version 310 es
         precision mediump float;

         uniform float x,y;
         out float color;

         void main()
         {
                 highp float b[2][2] = float[2][2](float[2](x, y), float[2](x, y));
                 float a[2][2];
                 a = b;
                 if (x > 0.0)
                     a[1][1] = 3.0;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant float16_t \(3'),
    Test("i32 temp array of array assigned from highp",
         """
         #version 310 es
         precision mediump int;

         uniform int x,y;
         out int color;

         void main()
         {
                 highp int b[2][2] = int[2][2](int[2](x, y), int[2](x, y));
                 int a[2][2];
                 a = b;
                 if (x > 0)
                     a[1][1] = 3;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant int16_t \(3'),
    Test("u32 temp array of array assigned from highp",
         """
         #version 310 es
         precision mediump int;

         uniform uint x,y;
         out uint color;

         void main()
         {
                 highp uint b[2][2] = uint[2][2](uint[2](x, y), uint[2](x, y));
                 uint a[2][2];
                 a = b;
                 if (x > 0u)
                     a[1][1] = 3u;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant uint16_t \(3'),
    Test("f32 temp array of array assigned to highp",
         """
         #version 310 es
         precision mediump float;

         uniform float x,y;
         out float color;

         void main()
         {
                 float a[2][2] = float[2][2](float[2](x, y), float[2](x, y));
                 highp float b[2][2];
                 b = a;
                 a = b;
                 if (x > 0.0)
                     a[1][1] = 3.0;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant float16_t \(3'),
    Test("i32 temp array of array assigned to highp",
         """
         #version 310 es
         precision mediump int;

         uniform int x,y;
         out int color;

         void main()
         {
                 int a[2][2] = int[2][2](int[2](x, y), int[2](x, y));
                 highp int b[2][2];
                 b = a;
                 a = b;
                 if (x > 0)
                     a[1][1] = 3;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant int16_t \(3'),
    Test("u32 temp array of array assigned to highp",
         """
         #version 310 es
         precision mediump int;

         uniform uint x,y;
         out uint color;

         void main()
         {
                 uint a[2][2] = uint[2][2](uint[2](x, y), uint[2](x, y));
                 highp uint b[2][2];
                 b = a;
                 a = b;
                 if (x > 0u)
                     a[1][1] = 3u;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant uint16_t \(3'),
    Test("f32 temp array of array returned by function",
         """
         #version 310 es
         precision mediump float;

         uniform float x,y;
         out float color;

         float[2][2] f(void)
         {
            return float[2][2](float[2](x, y), float[2](x, y));
         }

         void main()
         {
                 float a[2][2] = f();
                 if (x > 0.0)
                     a[1][1] = 3.0;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant float16_t \(3'),
    Test("i32 temp array of array returned by function",
         """
         #version 310 es
         precision mediump int;

         uniform int x,y;
         out int color;

         int[2][2] f(void)
         {
            return int[2][2](int[2](x, y), int[2](x, y));
         }

         void main()
         {
                 int a[2][2] = f();
                 if (x > 0)
                     a[1][1] = 3;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant int16_t \(3'),
    Test("u32 temp array of array returned by function",
         """
         #version 310 es
         precision mediump int;

         uniform uint x,y;
         out uint color;

         uint[2][2] f(void)
         {
            return uint[2][2](uint[2](x, y), uint[2](x, y));
         }

         void main()
         {
                 uint a[2][2] = f();
                 if (x > 0u)
                     a[1][1] = 3u;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant uint16_t \(3'),
    Test("f32 temp array of array as function out",
         """
         #version 310 es
         precision mediump float;

         uniform float x,y;
         out float color;

         void f(out float[2][2] v)
         {
            v = float[2][2](float[2](x, y), float[2](x, y));
         }

         void main()
         {
                 float a[2][2];
                 f(a);
                 if (x > 0.0)
                     a[1][1] = 3.0;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant float16_t \(3'),
    Test("i32 temp array of array as function out",
         """
         #version 310 es
         precision mediump int;

         uniform int x,y;
         out int color;

         void f(out int[2][2] v)
         {
            v = int[2][2](int[2](x, y), int[2](x, y));
         }

         void main()
         {
                 int a[2][2];
                 f(a);
                 if (x > 0)
                     a[1][1] = 3;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant int16_t \(3'),
    Test("u32 temp array of array as function out",
         """
         #version 310 es
         precision mediump int;

         uniform uint x,y;
         out uint color;

         void f(out uint[2][2] v)
         {
            v = uint[2][2](uint[2](x, y), uint[2](x, y));
         }

         void main()
         {
                 uint a[2][2];
                 f(a);
                 if (x > 0u)
                     a[1][1] = 3u;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant uint16_t \(3'),
    Test("f32 temp array of array as function in",
         """
         #version 310 es
         precision mediump float;

         uniform float x,y;
         out float color;

         float[2][2] f(in float[2][2] v)
         {
            float t[2][2] = v;
            return t;
         }

         void main()
         {
                 float a[2][2];
                 a = f(a);
                 if (x > 0.0)
                     a[1][1] = 3.0;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant float16_t \(3'),
    Test("i32 temp array of array as function in",
         """
         #version 310 es
         precision mediump int;

         uniform int x,y;
         out int color;

         int[2][2] f(in int[2][2] v)
         {
            int t[2][2] = v;
            return t;
         }

         void main()
         {
                 int a[2][2];
                 a = f(a);
                 if (x > 0)
                     a[1][1] = 3;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant int16_t \(3'),
    Test("u32 temp array of array as function in",
         """
         #version 310 es
         precision mediump int;

         uniform uint x,y;
         out uint color;

         uint[2][2] f(in uint[2][2] v)
         {
            uint t[2][2] = v;
            return t;
         }

         void main()
         {
                 uint a[2][2];
                 a = f(a);
                 if (x > 0u)
                     a[1][1] = 3u;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant uint16_t \(3'),
    Test("f32 temp array of array as function inout",
         """
         #version 310 es
         precision mediump float;

         uniform float x,y;
         out float color;

         void f(inout float[2][2] v)
         {
            float t[2][2] = v;
            v = t;
         }

         void main()
         {
                 float a[2][2];
                 f(a);
                 if (x > 0.0)
                     a[1][1] = 3.0;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant float16_t \(3'),
    Test("i32 temp array of array as function inout",
         """
         #version 310 es
         precision mediump int;

         uniform int x,y;
         out int color;

         void f(inout int[2][2] v)
         {
            int t[2][2] = v;
            v = t;
         }

         void main()
         {
                 int a[2][2];
                 f(a);
                 if (x > 0)
                     a[1][1] = 3;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant int16_t \(3'),
    Test("u32 temp array of array as function inout",
         """
         #version 310 es
         precision mediump int;

         uniform uint x,y;
         out uint color;

         void f(inout uint[2][2] v)
         {
            uint t[2][2] = v;
            v = t;
         }

         void main()
         {
                 uint a[2][2];
                 f(a);
                 if (x > 0u)
                     a[1][1] = 3u;
                 color = a[0][0] + a[1][1];
         }
         """,
         r'\(constant uint16_t \(3'),
    Test("f32 temp struct (not lowered in the presence of control flow - TODO)",
         """
         #version 300 es
         precision mediump float;

         uniform float x,y;
         out float color;

         void main()
         {
                 struct { float x,y; } s;
                 s.x = x;
                 s.y = y;
                 if (x > 0.0)
                     s.y = 3.0;
                 color = s.x + s.y;
         }
         """,
         r'\(constant float \(3'), # should be float16_t
    Test("i32 temp struct (not lowered in the presence of control flow - TODO)",
         """
         #version 300 es
         precision mediump int;

         uniform int x,y;
         out int color;

         void main()
         {
                 struct { int x,y; } s;
                 s.x = x;
                 s.y = y;
                 if (x > 0)
                     s.y = 3;
                 color = s.x + s.y;
         }
         """,
         r'\(constant int \(3'), # should be int16_t
    Test("u32 temp struct (not lowered in the presence of control flow - TODO)",
         """
         #version 300 es
         precision mediump int;

         uniform uint x,y;
         out uint color;

         void main()
         {
                 struct { uint x,y; } s;
                 s.x = x;
                 s.y = y;
                 if (x > 0u)
                     s.y = 3u;
                 color = s.x + s.y;
         }
         """,
         r'\(constant uint \(3'), # should be uint16_t
]


def compile_shader(standalone_compiler, source):
    with tempfile.NamedTemporaryFile(mode='wt', suffix='.frag') as source_file:
        print(source, file=source_file)
        source_file.flush()
        return subprocess.check_output([standalone_compiler,
                                        '--version', '300',
                                        '--lower-precision',
                                        '--dump-lir',
                                        source_file.name],
                                       universal_newlines=True)


def run_test(standalone_compiler, test):
    ir = compile_shader(standalone_compiler, test.source)

    if re.search(test.match_re, ir) is None:
        print(ir)
        return False

    return True


def main():
    standalone_compiler = sys.argv[1]
    passed = 0

    for test in TESTS:
        print('Testing {} ... '.format(test.name), end='')

        result = run_test(standalone_compiler, test)

        if result:
            print('PASS')
            passed += 1
        else:
            print('FAIL')

    print('{}/{} tests returned correct results'.format(passed, len(TESTS)))
    sys.exit(0 if passed == len(TESTS) else 1)


if __name__ == '__main__':
    main()
