xref: /frameworks/rs/tests/lldb/tests/harness/RS_funs.py

# Copyright (C) 2016 The Android Open Source Project
#
# 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.

'''A list of signatures for RS builtin functions and util functions for them.

from __future__ import absolute_import

Function signature syntax is usually C-like, however, fixed values can also be
specified for those functions where the input range is restricted.
Lines in the function table beginning with - are comments.
Also contains utility functions to build an LLDB expression from a single
function line.
'''

import re

# Remove blank and comment lines using a lambda.
FUNC_LIST = filter(lambda line: line.strip()
                                and not line.strip().startswith('-'), '''
- math functions

uchar abs(char v);
uchar2 abs(char2 v);
uchar3 abs(char3 v);
uchar4 abs(char4 v);
uint abs(int v);
uint2 abs(int2 v);
uint3 abs(int3 v);
uint4 abs(int4 v);
ushort abs(short v);
ushort2 abs(short2 v);
ushort3 abs(short3 v);
ushort4 abs(short4 v);

float acos(float v);
float2 acos(float2 v);
float3 acos(float3 v);
float4 acos(float4 v);

float acosh(float v);
float2 acosh(float2 v);
float3 acosh(float3 v);
float4 acosh(float4 v);

float acospi(float v);
float2 acospi(float2 v);
float3 acospi(float3 v);
float4 acospi(float4 v);

float asin(float v);
float2 asin(float2 v);
float3 asin(float3 v);
float4 asin(float4 v);

float asinh(float v);
float2 asinh(float2 v);
float3 asinh(float3 v);
float4 asinh(float4 v);

float asinpi(float v);
float2 asinpi(float2 v);
float3 asinpi(float3 v);
float4 asinpi(float4 v);

float atan(float v);
float2 atan(float2 v);
float3 atan(float3 v);
float4 atan(float4 v);

float atan2(float numerator, float denominator);
float2 atan2(float2 numerator, float2 denominator);
float3 atan2(float3 numerator, float3 denominator);
float4 atan2(float4 numerator, float4 denominator);

float atan2pi(float numerator, float denominator);
float2 atan2pi(float2 numerator, float2 denominator);
float3 atan2pi(float3 numerator, float3 denominator);
float4 atan2pi(float4 numerator, float4 denominator);

float atanh(float v);
float2 atanh(float2 v);
float3 atanh(float3 v);
float4 atanh(float4 v);

float atanpi(float v);
float2 atanpi(float2 v);
float3 atanpi(float3 v);
float4 atanpi(float4 v);

float cbrt(float v);
float2 cbrt(float2 v);
float3 cbrt(float3 v);
float4 cbrt(float4 v);

float ceil(float v);
float2 ceil(float2 v);
float3 ceil(float3 v);
float4 ceil(float4 v);

char clamp(char value, char min_value, char max_value);
char2 clamp(char2 value, char min_value, char max_value);
char2 clamp(char2 value, char2 min_value, char2 max_value);
char3 clamp(char3 value, char min_value, char max_value);
char3 clamp(char3 value, char3 min_value, char3 max_value);
char4 clamp(char4 value, char min_value, char max_value);
char4 clamp(char4 value, char4 min_value, char4 max_value);
float clamp(float value, float min_value, float max_value);
float2 clamp(float2 value, float min_value, float max_value);
float2 clamp(float2 value, float2 min_value, float2 max_value);
float3 clamp(float3 value, float min_value, float max_value);
float3 clamp(float3 value, float3 min_value, float3 max_value);
float4 clamp(float4 value, float min_value, float max_value);
float4 clamp(float4 value, float4 min_value, float4 max_value);
int clamp(int value, int min_value, int max_value);
int2 clamp(int2 value, int min_value, int max_value);
int2 clamp(int2 value, int2 min_value, int2 max_value);
int3 clamp(int3 value, int min_value, int max_value);
int3 clamp(int3 value, int3 min_value, int3 max_value);
int4 clamp(int4 value, int min_value, int max_value);
int4 clamp(int4 value, int4 min_value, int4 max_value);
long clamp(long value, long min_value, long max_value);
long2 clamp(long2 value, long min_value, long max_value);
long2 clamp(long2 value, long2 min_value, long2 max_value);
long3 clamp(long3 value, long min_value, long max_value);
long3 clamp(long3 value, long3 min_value, long3 max_value);
long4 clamp(long4 value, long min_value, long max_value);
long4 clamp(long4 value, long4 min_value, long4 max_value);
short clamp(short value, short min_value, short max_value);
short2 clamp(short2 value, short min_value, short max_value);
short2 clamp(short2 value, short2 min_value, short2 max_value);
short3 clamp(short3 value, short min_value, short max_value);
short3 clamp(short3 value, short3 min_value, short3 max_value);
short4 clamp(short4 value, short min_value, short max_value);
short4 clamp(short4 value, short4 min_value, short4 max_value);
uchar clamp(uchar value, uchar min_value, uchar max_value);
uchar2 clamp(uchar2 value, uchar min_value, uchar max_value);
uchar2 clamp(uchar2 value, uchar2 min_value, uchar2 max_value);
uchar3 clamp(uchar3 value, uchar min_value, uchar max_value);
uchar3 clamp(uchar3 value, uchar3 min_value, uchar3 max_value);
uchar4 clamp(uchar4 value, uchar min_value, uchar max_value);
uchar4 clamp(uchar4 value, uchar4 min_value, uchar4 max_value);
uint clamp(uint value, uint min_value, uint max_value);
uint2 clamp(uint2 value, uint min_value, uint max_value);
uint2 clamp(uint2 value, uint2 min_value, uint2 max_value);
uint3 clamp(uint3 value, uint min_value, uint max_value);
uint3 clamp(uint3 value, uint3 min_value, uint3 max_value);
uint4 clamp(uint4 value, uint min_value, uint max_value);
uint4 clamp(uint4 value, uint4 min_value, uint4 max_value);
ulong clamp(ulong value, ulong min_value, ulong max_value);
ulong2 clamp(ulong2 value, ulong min_value, ulong max_value);
ulong2 clamp(ulong2 value, ulong2 min_value, ulong2 max_value);
ulong3 clamp(ulong3 value, ulong min_value, ulong max_value);
ulong3 clamp(ulong3 value, ulong3 min_value, ulong3 max_value);
ulong4 clamp(ulong4 value, ulong min_value, ulong max_value);
ulong4 clamp(ulong4 value, ulong4 min_value, ulong4 max_value);
ushort clamp(ushort value, ushort min_value, ushort max_value);
ushort2 clamp(ushort2 value, ushort min_value, ushort max_value);
ushort2 clamp(ushort2 value, ushort2 min_value, ushort2 max_value);
ushort3 clamp(ushort3 value, ushort min_value, ushort max_value);
ushort3 clamp(ushort3 value, ushort3 min_value, ushort3 max_value);
ushort4 clamp(ushort4 value, ushort min_value, ushort max_value);
ushort4 clamp(ushort4 value, ushort4 min_value, ushort4 max_value);

char clz(char value);
char2 clz(char2 value);
char3 clz(char3 value);
char4 clz(char4 value);
int clz(int value);
int2 clz(int2 value);
int3 clz(int3 value);
int4 clz(int4 value);
short clz(short value);
short2 clz(short2 value);
short3 clz(short3 value);
short4 clz(short4 value);
uchar clz(uchar value);
uchar2 clz(uchar2 value);
uchar3 clz(uchar3 value);
uchar4 clz(uchar4 value);
uint clz(uint value);
uint2 clz(uint2 value);
uint3 clz(uint3 value);
uint4 clz(uint4 value);
ushort clz(ushort value);
ushort2 clz(ushort2 value);
ushort3 clz(ushort3 value);
ushort4 clz(ushort4 value);

float copysign(float magnitude_value, float sign_value);
float2 copysign(float2 magnitude_value, float2 sign_value);
float3 copysign(float3 magnitude_value, float3 sign_value);
float4 copysign(float4 magnitude_value, float4 sign_value);

float cos(float v);
float2 cos(float2 v);
float3 cos(float3 v);
float4 cos(float4 v);

float cosh(float v);
float2 cosh(float2 v);
float3 cosh(float3 v);
float4 cosh(float4 v);

float cospi(float v);
float2 cospi(float2 v);
float3 cospi(float3 v);
float4 cospi(float4 v);

float erf(float v);
float2 erf(float2 v);
float3 erf(float3 v);
float4 erf(float4 v);

float erfc(float v);
float2 erfc(float2 v);
float3 erfc(float3 v);
float4 erfc(float4 v);

float exp(float v);
float2 exp(float2 v);
float3 exp(float3 v);
float4 exp(float4 v);

float exp10(float v);
float2 exp10(float2 v);
float3 exp10(float3 v);
float4 exp10(float4 v);

float exp2(float v);
float2 exp2(float2 v);
float3 exp2(float3 v);
float4 exp2(float4 v);

float expm1(float v);
float2 expm1(float2 v);
float3 expm1(float3 v);
float4 expm1(float4 v);

float fabs(float v);
float2 fabs(float2 v);
float3 fabs(float3 v);
float4 fabs(float4 v);

float fdim(float a, float b);
float2 fdim(float2 a, float2 b);
float3 fdim(float3 a, float3 b);
float4 fdim(float4 a, float4 b);

float floor(float v);
float2 floor(float2 v);
float3 floor(float3 v);
float4 floor(float4 v);

float fma(float multiplicand1, float multiplicand2, float offset);
float2 fma(float2 multiplicand1, float2 multiplicand2, float2 offset);
float3 fma(float3 multiplicand1, float3 multiplicand2, float3 offset);
float4 fma(float4 multiplicand1, float4 multiplicand2, float4 offset);

float fmax(float a, float b);
float2 fmax(float2 a, float b);
float2 fmax(float2 a, float2 b);
float3 fmax(float3 a, float b);
float3 fmax(float3 a, float3 b);
float4 fmax(float4 a, float b);
float4 fmax(float4 a, float4 b);

float fmin(float a, float b);
float2 fmin(float2 a, float b);
float2 fmin(float2 a, float2 b);
float3 fmin(float3 a, float b);
float3 fmin(float3 a, float3 b);
float4 fmin(float4 a, float b);
float4 fmin(float4 a, float4 b);

float fmod(float numerator, float denominator);
float2 fmod(float2 numerator, float2 denominator);
float3 fmod(float3 numerator, float3 denominator);
float4 fmod(float4 numerator, float4 denominator);

float fract(float v, float* floor);
float2 fract(float2 v, float2* floor);
float3 fract(float3 v, float3* floor);
float4 fract(float4 v, float4* floor);

float frexp(float v, int* exponent);
float2 frexp(float2 v, int2* exponent);
float3 frexp(float3 v, int3* exponent);
float4 frexp(float4 v, int4* exponent);

float half_recip(float v);
float2 half_recip(float2 v);
float3 half_recip(float3 v);
float4 half_recip(float4 v);

float half_rsqrt(float v);
float2 half_rsqrt(float2 v);
float3 half_rsqrt(float3 v);
float4 half_rsqrt(float4 v);

float half_sqrt(float v);
float2 half_sqrt(float2 v);
float3 half_sqrt(float3 v);
float4 half_sqrt(float4 v);

float hypot(float a, float b);
float2 hypot(float2 a, float2 b);
float3 hypot(float3 a, float3 b);
float4 hypot(float4 a, float4 b);

int ilogb(float v);
int2 ilogb(float2 v);
int3 ilogb(float3 v);
int4 ilogb(float4 v);

float ldexp(float mantissa, int exponent);
float2 ldexp(float2 mantissa, int exponent);
float2 ldexp(float2 mantissa, int2 exponent);
float3 ldexp(float3 mantissa, int exponent);
float3 ldexp(float3 mantissa, int3 exponent);
float4 ldexp(float4 mantissa, int exponent);
float4 ldexp(float4 mantissa, int4 exponent);

float lgamma(float v);
float lgamma(float v, int* sign_of_gamma);
float2 lgamma(float2 v);
float2 lgamma(float2 v, int2* sign_of_gamma);
float3 lgamma(float3 v);
float3 lgamma(float3 v, int3* sign_of_gamma);
float4 lgamma(float4 v);
float4 lgamma(float4 v, int4* sign_of_gamma);

float log(float v);
float2 log(float2 v);
float3 log(float3 v);
float4 log(float4 v);

float log10(float v);
float2 log10(float2 v);
float3 log10(float3 v);
float4 log10(float4 v);

float log1p(float v);
float2 log1p(float2 v);
float3 log1p(float3 v);
float4 log1p(float4 v);

float log2(float v);
float2 log2(float2 v);
float3 log2(float3 v);
float4 log2(float4 v);

float logb(float v);
float2 logb(float2 v);
float3 logb(float3 v);
float4 logb(float4 v);

float mad(float multiplicand1, float multiplicand2, float offset);
float2 mad(float2 multiplicand1, float2 multiplicand2, float2 offset);
float3 mad(float3 multiplicand1, float3 multiplicand2, float3 offset);
float4 mad(float4 multiplicand1, float4 multiplicand2, float4 offset);

char max(char a, char b);
char2 max(char2 a, char2 b);
char3 max(char3 a, char3 b);
char4 max(char4 a, char4 b);
float max(float a, float b);
float2 max(float2 a, float2 b);
float3 max(float3 a, float3 b);
float4 max(float4 a, float4 b);
int max(int a, int b);
int2 max(int2 a, int2 b);
int3 max(int3 a, int3 b);
int4 max(int4 a, int4 b);
long max(long a, long b);
long2 max(long2 a, long2 b);
long3 max(long3 a, long3 b);
long4 max(long4 a, long4 b);
short max(short a, short b);
short2 max(short2 a, short2 b);
short3 max(short3 a, short3 b);
short4 max(short4 a, short4 b);
uchar max(uchar a, uchar b);
uchar2 max(uchar2 a, uchar2 b);
uchar3 max(uchar3 a, uchar3 b);
uchar4 max(uchar4 a, uchar4 b);
uint max(uint a, uint b);
uint2 max(uint2 a, uint2 b);
uint3 max(uint3 a, uint3 b);
uint4 max(uint4 a, uint4 b);
ulong max(ulong a, ulong b);
ulong2 max(ulong2 a, ulong2 b);
ulong3 max(ulong3 a, ulong3 b);
ulong4 max(ulong4 a, ulong4 b);
ushort max(ushort a, ushort b);
ushort2 max(ushort2 a, ushort2 b);
ushort3 max(ushort3 a, ushort3 b);
ushort4 max(ushort4 a, ushort4 b);

char min(char a, char b);
char2 min(char2 a, char2 b);
char3 min(char3 a, char3 b);
char4 min(char4 a, char4 b);
float min(float a, float b);
float2 min(float2 a, float2 b);
float3 min(float3 a, float3 b);
float4 min(float4 a, float4 b);
int min(int a, int b);
int2 min(int2 a, int2 b);
int3 min(int3 a, int3 b);
int4 min(int4 a, int4 b);
long min(long a, long b);
long2 min(long2 a, long2 b);
long3 min(long3 a, long3 b);
long4 min(long4 a, long4 b);
short min(short a, short b);
short2 min(short2 a, short2 b);
short3 min(short3 a, short3 b);
short4 min(short4 a, short4 b);
uchar min(uchar a, uchar b);
uchar2 min(uchar2 a, uchar2 b);
uchar3 min(uchar3 a, uchar3 b);
uchar4 min(uchar4 a, uchar4 b);
uint min(uint a, uint b);
uint2 min(uint2 a, uint2 b);
uint3 min(uint3 a, uint3 b);
uint4 min(uint4 a, uint4 b);
ulong min(ulong a, ulong b);
ulong2 min(ulong2 a, ulong2 b);
ulong3 min(ulong3 a, ulong3 b);
ulong4 min(ulong4 a, ulong4 b);
ushort min(ushort a, ushort b);
ushort2 min(ushort2 a, ushort2 b);
ushort3 min(ushort3 a, ushort3 b);
ushort4 min(ushort4 a, ushort4 b);

float mix(float start, float stop, float fraction);
float2 mix(float2 start, float2 stop, float fraction);
float2 mix(float2 start, float2 stop, float2 fraction);
float3 mix(float3 start, float3 stop, float fraction);
float3 mix(float3 start, float3 stop, float3 fraction);
float4 mix(float4 start, float4 stop, float fraction);
float4 mix(float4 start, float4 stop, float4 fraction);

float modf(float v, float* integral_part);
float2 modf(float2 v, float2* integral_part);
float3 modf(float3 v, float3* integral_part);
float4 modf(float4 v, float4* integral_part);

float nan(uint v);

float native_acos(float v);
float2 native_acos(float2 v);
float3 native_acos(float3 v);
float4 native_acos(float4 v);

float native_acosh(float v);
float2 native_acosh(float2 v);
float3 native_acosh(float3 v);
float4 native_acosh(float4 v);

float native_acospi(float v);
float2 native_acospi(float2 v);
float3 native_acospi(float3 v);
float4 native_acospi(float4 v);

float native_asin(float v);
float2 native_asin(float2 v);
float3 native_asin(float3 v);
float4 native_asin(float4 v);

float native_asinh(float v);
float2 native_asinh(float2 v);
float3 native_asinh(float3 v);
float4 native_asinh(float4 v);

float native_asinpi(float v);
float2 native_asinpi(float2 v);
float3 native_asinpi(float3 v);
float4 native_asinpi(float4 v);

float native_atan(float v);
float2 native_atan(float2 v);
float3 native_atan(float3 v);
float4 native_atan(float4 v);

float native_atan2(float numerator, float denominator);
float2 native_atan2(float2 numerator, float2 denominator);
float3 native_atan2(float3 numerator, float3 denominator);
float4 native_atan2(float4 numerator, float4 denominator);

float native_atan2pi(float numerator, float denominator);
float2 native_atan2pi(float2 numerator, float2 denominator);
float3 native_atan2pi(float3 numerator, float3 denominator);
float4 native_atan2pi(float4 numerator, float4 denominator);

float native_atanh(float v);
float2 native_atanh(float2 v);
float3 native_atanh(float3 v);
float4 native_atanh(float4 v);

float native_atanpi(float v);
float2 native_atanpi(float2 v);
float3 native_atanpi(float3 v);
float4 native_atanpi(float4 v);

float native_cbrt(float v);
float2 native_cbrt(float2 v);
float3 native_cbrt(float3 v);
float4 native_cbrt(float4 v);

float native_cos(float v);
float2 native_cos(float2 v);
float3 native_cos(float3 v);
float4 native_cos(float4 v);

float native_cosh(float v);
float2 native_cosh(float2 v);
float3 native_cosh(float3 v);
float4 native_cosh(float4 v);

float native_cospi(float v);
float2 native_cospi(float2 v);
float3 native_cospi(float3 v);
float4 native_cospi(float4 v);

float native_divide(float left_vector, float right_vector);
float2 native_divide(float2 left_vector, float2 right_vector);
float3 native_divide(float3 left_vector, float3 right_vector);
float4 native_divide(float4 left_vector, float4 right_vector);

float native_exp(float v);
float2 native_exp(float2 v);
float3 native_exp(float3 v);
float4 native_exp(float4 v);

float native_exp10(float v);
float2 native_exp10(float2 v);
float3 native_exp10(float3 v);
float4 native_exp10(float4 v);

float native_exp2(float v);
float2 native_exp2(float2 v);
float3 native_exp2(float3 v);
float4 native_exp2(float4 v);

float native_expm1(float v);
float2 native_expm1(float2 v);
float3 native_expm1(float3 v);
float4 native_expm1(float4 v);

float native_hypot(float a, float b);
float2 native_hypot(float2 a, float2 b);
float3 native_hypot(float3 a, float3 b);
float4 native_hypot(float4 a, float4 b);

float native_log(float v);
float2 native_log(float2 v);
float3 native_log(float3 v);
float4 native_log(float4 v);

float native_log10(float v);
float2 native_log10(float2 v);
float3 native_log10(float3 v);
float4 native_log10(float4 v);

float native_log1p(float v);
float2 native_log1p(float2 v);
float3 native_log1p(float3 v);
float4 native_log1p(float4 v);

float native_log2(float v);
float2 native_log2(float2 v);
float3 native_log2(float3 v);
float4 native_log2(float4 v);

float native_powr(float base, float exponent);
float2 native_powr(float2 base, float2 exponent);
float3 native_powr(float3 base, float3 exponent);
float4 native_powr(float4 base, float4 exponent);

float native_recip(float v);
float2 native_recip(float2 v);
float3 native_recip(float3 v);
float4 native_recip(float4 v);

float native_rootn(float v, int n);
float2 native_rootn(float2 v, int2 n);
float3 native_rootn(float3 v, int3 n);
float4 native_rootn(float4 v, int4 n);

float native_rsqrt(float v);
float2 native_rsqrt(float2 v);
float3 native_rsqrt(float3 v);
float4 native_rsqrt(float4 v);

float native_sin(float v);
float2 native_sin(float2 v);
float3 native_sin(float3 v);
float4 native_sin(float4 v);

float native_sincos(float v, float* cos);
float2 native_sincos(float2 v, float2* cos);
float3 native_sincos(float3 v, float3* cos);
float4 native_sincos(float4 v, float4* cos);

float native_sinh(float v);
float2 native_sinh(float2 v);
float3 native_sinh(float3 v);
float4 native_sinh(float4 v);

float native_sinpi(float v);
float2 native_sinpi(float2 v);
float3 native_sinpi(float3 v);
float4 native_sinpi(float4 v);

float native_sqrt(float v);
float2 native_sqrt(float2 v);
float3 native_sqrt(float3 v);
float4 native_sqrt(float4 v);

float native_tan(float v);
float2 native_tan(float2 v);
float3 native_tan(float3 v);
float4 native_tan(float4 v);

float native_tanh(float v);
float2 native_tanh(float2 v);
float3 native_tanh(float3 v);
float4 native_tanh(float4 v);

float native_tanpi(float v);
float2 native_tanpi(float2 v);
float3 native_tanpi(float3 v);
float4 native_tanpi(float4 v);

float nextafter(float v, float target);
float2 nextafter(float2 v, float2 target);
float3 nextafter(float3 v, float3 target);
float4 nextafter(float4 v, float4 target);

float pow(float base, float exponent);
float2 pow(float2 base, float2 exponent);
float3 pow(float3 base, float3 exponent);
float4 pow(float4 base, float4 exponent);

float pown(float base, int exponent);
float2 pown(float2 base, int2 exponent);
float3 pown(float3 base, int3 exponent);
float4 pown(float4 base, int4 exponent);

float powr(float base, float exponent);
float2 powr(float2 base, float2 exponent);
float3 powr(float3 base, float3 exponent);
float4 powr(float4 base, float4 exponent);

float radians(float v);
float2 radians(float2 v);
float3 radians(float3 v);
float4 radians(float4 v);

float remainder(float numerator, float denominator);
float2 remainder(float2 numerator, float2 denominator);
float3 remainder(float3 numerator, float3 denominator);
float4 remainder(float4 numerator, float4 denominator);

float remquo(float numerator, float denominator, int* quotient);
float2 remquo(float2 numerator, float2 denominator, int2* quotient);
float3 remquo(float3 numerator, float3 denominator, int3* quotient);
float4 remquo(float4 numerator, float4 denominator, int4* quotient);

float rint(float v);
float2 rint(float2 v);
float3 rint(float3 v);
float4 rint(float4 v);

float rootn(float v, int n);
float2 rootn(float2 v, int2 n);
float3 rootn(float3 v, int3 n);
float4 rootn(float4 v, int4 n);

float round(float v);
float2 round(float2 v);
float3 round(float3 v);
float4 round(float4 v);

char rsClamp(char amount, char low, char high);
int rsClamp(int amount, int low, int high);
short rsClamp(short amount, short low, short high);
uchar rsClamp(uchar amount, uchar low, uchar high);
uint rsClamp(uint amount, uint low, uint high);
ushort rsClamp(ushort amount, ushort low, ushort high);

float rsFrac(float v);

float rsRand(float max_value);
float rsRand(float min_value, float max_value);
int rsRand(int max_value);
int rsRand(int min_value, int max_value);

float rsqrt(float v);
float2 rsqrt(float2 v);
float3 rsqrt(float3 v);
float4 rsqrt(float4 v);

float sign(float v);
float2 sign(float2 v);
float3 sign(float3 v);
float4 sign(float4 v);

float sin(float v);
float2 sin(float2 v);
float3 sin(float3 v);
float4 sin(float4 v);

float sincos(float v, float* cos);
float2 sincos(float2 v, float2* cos);
float3 sincos(float3 v, float3* cos);
float4 sincos(float4 v, float4* cos);

float sinh(float v);
float2 sinh(float2 v);
float3 sinh(float3 v);
float4 sinh(float4 v);

float sinpi(float v);
float2 sinpi(float2 v);
float3 sinpi(float3 v);
float4 sinpi(float4 v);

float sqrt(float v);
float2 sqrt(float2 v);
float3 sqrt(float3 v);
float4 sqrt(float4 v);

float step(float edge, float v);
float2 step(float edge, float2 v);
float2 step(float2 edge, float v);
float2 step(float2 edge, float2 v);
float3 step(float edge, float3 v);
float3 step(float3 edge, float v);
float3 step(float3 edge, float3 v);
float4 step(float edge, float4 v);
float4 step(float4 edge, float v);
float4 step(float4 edge, float4 v);

float tan(float v);
float2 tan(float2 v);
float3 tan(float3 v);
float4 tan(float4 v);

float tanh(float v);
float2 tanh(float2 v);
float3 tanh(float3 v);
float4 tanh(float4 v);

float tanpi(float v);
float2 tanpi(float2 v);
float3 tanpi(float3 v);
float4 tanpi(float4 v);

float tgamma(float v);
float2 tgamma(float2 v);
float3 tgamma(float3 v);
float4 tgamma(float4 v);

float trunc(float v);
float2 trunc(float2 v);
float3 trunc(float3 v);
float4 trunc(float4 v);

uchar4 rsPackColorTo8888(float r, float g, float b);
uchar4 rsPackColorTo8888(float r, float g, float b, float a);
uchar4 rsPackColorTo8888(float3 color);
uchar4 rsPackColorTo8888(float4 color);
float4 rsUnpackColor8888(uchar4 c);

float4 rsYuvToRGBA_float4(uchar y, uchar u, uchar v);
uchar4 rsYuvToRGBA_uchar4(uchar y, uchar u, uchar v);

- vector functions

float3 cross(float3 left_vector, float3 right_vector);
float4 cross(float4 left_vector, float4 right_vector);

float distance(float  left_vector, float  right_vector);
float distance(float2 left_vector, float2 right_vector);
float distance(float3 left_vector, float3 right_vector);
float distance(float4 left_vector, float4 right_vector);

float dot(float  left_vector, float  right_vector);
float dot(float2 left_vector, float2 right_vector);
float dot(float3 left_vector, float3 right_vector);
float dot(float4 left_vector, float4 right_vector);

float fast_distance(float  left_vector, float  right_vector);
float fast_distance(float2 left_vector, float2 right_vector);
float fast_distance(float3 left_vector, float3 right_vector);
float fast_distance(float4 left_vector, float4 right_vector);

float fast_length(float  v);
float fast_length(float2 v);
float fast_length(float3 v);
float fast_length(float4 v);

float  fast_normalize(float  v);
float2 fast_normalize(float2 v);
float3 fast_normalize(float3 v);
float4 fast_normalize(float4 v);

float length(float  v);
float length(float2 v);
float length(float3 v);
float length(float4 v);

float native_distance(float  left_vector, float  right_vector);
float native_distance(float2 left_vector, float2 right_vector);
float native_distance(float3 left_vector, float3 right_vector);
float native_distance(float4 left_vector, float4 right_vector);

float native_length(float  v);
float native_length(float2 v);
float native_length(float3 v);
float native_length(float4 v);

float  native_normalize(float  v);
float2 native_normalize(float2 v);
float3 native_normalize(float3 v);
float4 native_normalize(float4 v);

float  normalize(float  v);
float2 normalize(float2 v);
float3 normalize(float3 v);
float4 normalize(float4 v);

- conversion functions

char2 convert_char2(char2 v);
char2 convert_char2(double2 v);
char2 convert_char2(float2 v);
char2 convert_char2(int2 v);
char2 convert_char2(long2 v);
char2 convert_char2(short2 v);
char2 convert_char2(uchar2 v);
char2 convert_char2(uint2 v);
char2 convert_char2(ulong2 v);
char2 convert_char2(ushort2 v);

char3 convert_char3(char3 v);
char3 convert_char3(double3 v);
char3 convert_char3(float3 v);
char3 convert_char3(int3 v);
char3 convert_char3(long3 v);
char3 convert_char3(short3 v);
char3 convert_char3(uchar3 v);
char3 convert_char3(uint3 v);
char3 convert_char3(ulong3 v);
char3 convert_char3(ushort3 v);

char4 convert_char4(char4 v);
char4 convert_char4(double4 v);
char4 convert_char4(float4 v);
char4 convert_char4(int4 v);
char4 convert_char4(long4 v);
char4 convert_char4(short4 v);
char4 convert_char4(uchar4 v);
char4 convert_char4(uint4 v);
char4 convert_char4(ulong4 v);
char4 convert_char4(ushort4 v);

double2 convert_double2(char2 v);
double2 convert_double2(double2 v);
double2 convert_double2(float2 v);
double2 convert_double2(int2 v);
double2 convert_double2(long2 v);
double2 convert_double2(short2 v);
double2 convert_double2(uchar2 v);
double2 convert_double2(uint2 v);
double2 convert_double2(ulong2 v);
double2 convert_double2(ushort2 v);

double3 convert_double3(char3 v);
double3 convert_double3(double3 v);
double3 convert_double3(float3 v);
double3 convert_double3(int3 v);
double3 convert_double3(long3 v);
double3 convert_double3(short3 v);
double3 convert_double3(uchar3 v);
double3 convert_double3(uint3 v);
double3 convert_double3(ulong3 v);
double3 convert_double3(ushort3 v);

double4 convert_double4(char4 v);
double4 convert_double4(double4 v);
double4 convert_double4(float4 v);
double4 convert_double4(int4 v);
double4 convert_double4(long4 v);
double4 convert_double4(short4 v);
double4 convert_double4(uchar4 v);
double4 convert_double4(uint4 v);
double4 convert_double4(ulong4 v);
double4 convert_double4(ushort4 v);

float2 convert_float2(char2 v);
float2 convert_float2(double2 v);
float2 convert_float2(float2 v);
float2 convert_float2(int2 v);
float2 convert_float2(long2 v);
float2 convert_float2(short2 v);
float2 convert_float2(uchar2 v);
float2 convert_float2(uint2 v);
float2 convert_float2(ulong2 v);
float2 convert_float2(ushort2 v);

float3 convert_float3(char3 v);
float3 convert_float3(double3 v);
float3 convert_float3(float3 v);
float3 convert_float3(int3 v);
float3 convert_float3(long3 v);
float3 convert_float3(short3 v);
float3 convert_float3(uchar3 v);
float3 convert_float3(uint3 v);
float3 convert_float3(ulong3 v);
float3 convert_float3(ushort3 v);

float4 convert_float4(char4 v);
float4 convert_float4(double4 v);
float4 convert_float4(float4 v);
float4 convert_float4(int4 v);
float4 convert_float4(long4 v);
float4 convert_float4(short4 v);
float4 convert_float4(uchar4 v);
float4 convert_float4(uint4 v);
float4 convert_float4(ulong4 v);
float4 convert_float4(ushort4 v);

int2 convert_int2(char2 v);
int2 convert_int2(double2 v);
int2 convert_int2(float2 v);
int2 convert_int2(int2 v);
int2 convert_int2(long2 v);
int2 convert_int2(short2 v);
int2 convert_int2(uchar2 v);
int2 convert_int2(uint2 v);
int2 convert_int2(ulong2 v);
int2 convert_int2(ushort2 v);

int3 convert_int3(char3 v);
int3 convert_int3(double3 v);
int3 convert_int3(float3 v);
int3 convert_int3(int3 v);
int3 convert_int3(long3 v);
int3 convert_int3(short3 v);
int3 convert_int3(uchar3 v);
int3 convert_int3(uint3 v);
int3 convert_int3(ulong3 v);
int3 convert_int3(ushort3 v);

int4 convert_int4(char4 v);
int4 convert_int4(double4 v);
int4 convert_int4(float4 v);
int4 convert_int4(int4 v);
int4 convert_int4(long4 v);
int4 convert_int4(short4 v);
int4 convert_int4(uchar4 v);
int4 convert_int4(uint4 v);
int4 convert_int4(ulong4 v);
int4 convert_int4(ushort4 v);

long2 convert_long2(char2 v);
long2 convert_long2(double2 v);
long2 convert_long2(float2 v);
long2 convert_long2(int2 v);
long2 convert_long2(long2 v);
long2 convert_long2(short2 v);
long2 convert_long2(uchar2 v);
long2 convert_long2(uint2 v);
long2 convert_long2(ulong2 v);
long2 convert_long2(ushort2 v);

long3 convert_long3(char3 v);
long3 convert_long3(double3 v);
long3 convert_long3(float3 v);
long3 convert_long3(int3 v);
long3 convert_long3(long3 v);
long3 convert_long3(short3 v);
long3 convert_long3(uchar3 v);
long3 convert_long3(uint3 v);
long3 convert_long3(ulong3 v);
long3 convert_long3(ushort3 v);

long4 convert_long4(char4 v);
long4 convert_long4(double4 v);
long4 convert_long4(float4 v);
long4 convert_long4(int4 v);
long4 convert_long4(long4 v);
long4 convert_long4(short4 v);
long4 convert_long4(uchar4 v);
long4 convert_long4(uint4 v);
long4 convert_long4(ulong4 v);
long4 convert_long4(ushort4 v);

short2 convert_short2(char2 v);
short2 convert_short2(double2 v);
short2 convert_short2(float2 v);
short2 convert_short2(int2 v);
short2 convert_short2(long2 v);
short2 convert_short2(short2 v);
short2 convert_short2(uchar2 v);
short2 convert_short2(uint2 v);
short2 convert_short2(ulong2 v);
short2 convert_short2(ushort2 v);

short3 convert_short3(char3 v);
short3 convert_short3(double3 v);
short3 convert_short3(float3 v);
short3 convert_short3(int3 v);
short3 convert_short3(long3 v);
short3 convert_short3(short3 v);
short3 convert_short3(uchar3 v);
short3 convert_short3(uint3 v);
short3 convert_short3(ulong3 v);
short3 convert_short3(ushort3 v);

short4 convert_short4(char4 v);
short4 convert_short4(double4 v);
short4 convert_short4(float4 v);
short4 convert_short4(int4 v);
short4 convert_short4(long4 v);
short4 convert_short4(short4 v);
short4 convert_short4(uchar4 v);
short4 convert_short4(uint4 v);
short4 convert_short4(ulong4 v);
short4 convert_short4(ushort4 v);

uchar2 convert_uchar2(char2 v);
uchar2 convert_uchar2(double2 v);
uchar2 convert_uchar2(float2 v);
uchar2 convert_uchar2(int2 v);
uchar2 convert_uchar2(long2 v);
uchar2 convert_uchar2(short2 v);
uchar2 convert_uchar2(uchar2 v);
uchar2 convert_uchar2(uint2 v);
uchar2 convert_uchar2(ulong2 v);
uchar2 convert_uchar2(ushort2 v);

uchar3 convert_uchar3(char3 v);
uchar3 convert_uchar3(double3 v);
uchar3 convert_uchar3(float3 v);
uchar3 convert_uchar3(int3 v);
uchar3 convert_uchar3(long3 v);
uchar3 convert_uchar3(short3 v);
uchar3 convert_uchar3(uchar3 v);
uchar3 convert_uchar3(uint3 v);
uchar3 convert_uchar3(ulong3 v);
uchar3 convert_uchar3(ushort3 v);

uchar4 convert_uchar4(char4 v);
uchar4 convert_uchar4(double4 v);
uchar4 convert_uchar4(float4 v);
uchar4 convert_uchar4(int4 v);
uchar4 convert_uchar4(long4 v);
uchar4 convert_uchar4(short4 v);
uchar4 convert_uchar4(uchar4 v);
uchar4 convert_uchar4(uint4 v);
uchar4 convert_uchar4(ulong4 v);
uchar4 convert_uchar4(ushort4 v);

uint2 convert_uint2(char2 v);
uint2 convert_uint2(double2 v);
uint2 convert_uint2(float2 v);
uint2 convert_uint2(int2 v);
uint2 convert_uint2(long2 v);
uint2 convert_uint2(short2 v);
uint2 convert_uint2(uchar2 v);
uint2 convert_uint2(uint2 v);
uint2 convert_uint2(ulong2 v);
uint2 convert_uint2(ushort2 v);

uint3 convert_uint3(char3 v);
uint3 convert_uint3(double3 v);
uint3 convert_uint3(float3 v);
uint3 convert_uint3(int3 v);
uint3 convert_uint3(long3 v);
uint3 convert_uint3(short3 v);
uint3 convert_uint3(uchar3 v);
uint3 convert_uint3(uint3 v);
uint3 convert_uint3(ulong3 v);
uint3 convert_uint3(ushort3 v);

uint4 convert_uint4(char4 v);
uint4 convert_uint4(double4 v);
uint4 convert_uint4(float4 v);
uint4 convert_uint4(int4 v);
uint4 convert_uint4(long4 v);
uint4 convert_uint4(short4 v);
uint4 convert_uint4(uchar4 v);
uint4 convert_uint4(uint4 v);
uint4 convert_uint4(ulong4 v);
uint4 convert_uint4(ushort4 v);

ulong2 convert_ulong2(char2 v);
ulong2 convert_ulong2(double2 v);
ulong2 convert_ulong2(float2 v);
ulong2 convert_ulong2(int2 v);
ulong2 convert_ulong2(long2 v);
ulong2 convert_ulong2(short2 v);
ulong2 convert_ulong2(uchar2 v);
ulong2 convert_ulong2(uint2 v);
ulong2 convert_ulong2(ulong2 v);
ulong2 convert_ulong2(ushort2 v);

ulong3 convert_ulong3(char3 v);
ulong3 convert_ulong3(double3 v);
ulong3 convert_ulong3(float3 v);
ulong3 convert_ulong3(int3 v);
ulong3 convert_ulong3(long3 v);
ulong3 convert_ulong3(short3 v);
ulong3 convert_ulong3(uchar3 v);
ulong3 convert_ulong3(uint3 v);
ulong3 convert_ulong3(ulong3 v);
ulong3 convert_ulong3(ushort3 v);

ulong4 convert_ulong4(char4 v);
ulong4 convert_ulong4(double4 v);
ulong4 convert_ulong4(float4 v);
ulong4 convert_ulong4(int4 v);
ulong4 convert_ulong4(long4 v);
ulong4 convert_ulong4(short4 v);
ulong4 convert_ulong4(uchar4 v);
ulong4 convert_ulong4(uint4 v);
ulong4 convert_ulong4(ulong4 v);
ulong4 convert_ulong4(ushort4 v);

ushort2 convert_ushort2(char2 v);
ushort2 convert_ushort2(double2 v);
ushort2 convert_ushort2(float2 v);
ushort2 convert_ushort2(int2 v);
ushort2 convert_ushort2(long2 v);
ushort2 convert_ushort2(short2 v);
ushort2 convert_ushort2(uchar2 v);
ushort2 convert_ushort2(uint2 v);
ushort2 convert_ushort2(ulong2 v);
ushort2 convert_ushort2(ushort2 v);

ushort3 convert_ushort3(char3 v);
ushort3 convert_ushort3(double3 v);
ushort3 convert_ushort3(float3 v);
ushort3 convert_ushort3(int3 v);
ushort3 convert_ushort3(long3 v);
ushort3 convert_ushort3(short3 v);
ushort3 convert_ushort3(uchar3 v);
ushort3 convert_ushort3(uint3 v);
ushort3 convert_ushort3(ulong3 v);
ushort3 convert_ushort3(ushort3 v);

ushort4 convert_ushort4(char4 v);
ushort4 convert_ushort4(double4 v);
ushort4 convert_ushort4(float4 v);
ushort4 convert_ushort4(int4 v);
ushort4 convert_ushort4(long4 v);
ushort4 convert_ushort4(short4 v);
ushort4 convert_ushort4(uchar4 v);
ushort4 convert_ushort4(uint4 v);
ushort4 convert_ushort4(ulong4 v);
ushort4 convert_ushort4(ushort4 v);

uchar4 rsPackColorTo8888(float r, float g, float b);
uchar4 rsPackColorTo8888(float r, float g, float b, float a);
uchar4 rsPackColorTo8888(float3 color);
uchar4 rsPackColorTo8888(float4 color);

float4 rsUnpackColor8888(uchar4 c);

float4 rsYuvToRGBA_float4(uchar y, uchar u, uchar v);

uchar4 rsYuvToRGBA_uchar4(uchar y, uchar u, uchar v);

- matrix functions, some of these are not supported yet

-bool rsMatrixInverse(rs_matrix4x4* m);

-bool rsMatrixInverseTranspose(rs_matrix4x4* m);

-void rsMatrixLoad(rs_matrix2x2* destination, float* array);
-void rsMatrixLoad(rs_matrix2x2* destination, rs_matrix2x2* source);
-void rsMatrixLoad(rs_matrix3x3* destination, float* array);
-void rsMatrixLoad(rs_matrix3x3* destination, rs_matrix3x3* source);
-void rsMatrixLoad(rs_matrix4x4* destination, float* array);
-void rsMatrixLoad(rs_matrix4x4* destination, rs_matrix2x2* source);
-void rsMatrixLoad(rs_matrix4x4* destination, rs_matrix3x3* source);
-void rsMatrixLoad(rs_matrix4x4* destination, rs_matrix4x4* source);

-void rsMatrixLoadFrustum(rs_matrix4x4* m, float left, float right, float bottom, float top, float near, float far);

-void rsMatrixLoadIdentity(rs_matrix2x2* m);
-void rsMatrixLoadIdentity(rs_matrix3x3* m);
-void rsMatrixLoadIdentity(rs_matrix4x4* m);

-void rsMatrixLoadMultiply(rs_matrix2x2* m, rs_matrix2x2* lhs, rs_matrix2x2* rhs);
-void rsMatrixLoadMultiply(rs_matrix3x3* m, rs_matrix3x3* lhs, rs_matrix3x3* rhs);
-void rsMatrixLoadMultiply(rs_matrix4x4* m, rs_matrix4x4* lhs, rs_matrix4x4* rhs);

-void rsMatrixLoadOrtho(rs_matrix4x4* m, float left, float right, float bottom, float top, float near, float far);

-void rsMatrixLoadPerspective(rs_matrix4x4* m, float fovy, float aspect, float near, float far);

-void rsMatrixLoadRotate(rs_matrix4x4* m, float rot, float x, float y, float z);

-void rsMatrixLoadScale(rs_matrix4x4* m, float x, float y, float z);

-void rsMatrixLoadTranslate(rs_matrix4x4* m, float x, float y, float z);

float2 rsMatrixMultiply(rs_matrix2x2* m, float2 in);
float3 rsMatrixMultiply(rs_matrix3x3* m, float2 in);
float3 rsMatrixMultiply(rs_matrix3x3* m, float3 in);
float4 rsMatrixMultiply(rs_matrix4x4* m, float2 in);
float4 rsMatrixMultiply(rs_matrix4x4* m, float3 in);
float4 rsMatrixMultiply(rs_matrix4x4* m, float4 in);
void rsMatrixMultiply(rs_matrix2x2* m, rs_matrix2x2* rhs);
void rsMatrixMultiply(rs_matrix3x3* m, rs_matrix3x3* rhs);
void rsMatrixMultiply(rs_matrix4x4* m, rs_matrix4x4* rhs);

-void rsMatrixRotate(rs_matrix4x4* m, float rot, float x, float y, float z);

-void rsMatrixScale(rs_matrix4x4* m, float x, float y, float z);

void rsMatrixSet(rs_matrix2x2* m, 0, 1, float v);
void rsMatrixSet(rs_matrix3x3* m, 2, 0, float v);
void rsMatrixSet(rs_matrix4x4* m, 1, 3, float v);

-void rsMatrixTranslate(rs_matrix4x4* m, float x, float y, float z);

-void rsMatrixTranspose(rs_matrix2x2* m);
-void rsMatrixTranspose(rs_matrix3x3* m);
-void rsMatrixTranspose(rs_matrix4x4* m);

- quaternion functions

void rsQuaternionAdd(rs_quaternion* q, rs_quaternion* rhs);

void rsQuaternionConjugate(rs_quaternion* q);

float rsQuaternionDot(rs_quaternion* q0, rs_quaternion* q1);

void rsQuaternionGetMatrixUnit(rs_matrix4x4* m, rs_quaternion* q);

void rsQuaternionLoadRotate(rs_quaternion* q, float rot, float x, float y, float z);

void rsQuaternionLoadRotateUnit(rs_quaternion* q, float rot, float x, float y, float z);

void rsQuaternionMultiply(rs_quaternion* q, rs_quaternion* rhs);
void rsQuaternionMultiply(rs_quaternion* q, float scalar);

void rsQuaternionNormalize(rs_quaternion* q);

void rsQuaternionSet(rs_quaternion* q, rs_quaternion* rhs);
void rsQuaternionSet(rs_quaternion* q, float w, float x, float y, float z);

void rsQuaternionSlerp(rs_quaternion* q, rs_quaternion* q0, rs_quaternion* q1, float t);

- allocation data access functions, this is a subset, since we don't have all types of allocations

-void rsAllocationCopy1DRange(allocation_1D_global, uint dstOff, uint dstMip, uint count, allocation_1D_global2, uint srcOff, uint srcMip);

-void rsAllocationCopy2DRange(allocation_2D_global, uint dstXoff, uint dstYoff, uint dstMip, rs_allocation_cubemap_face dstFace, uint width, uint height, allocation_2D_global2, uint srcXoff, uint srcYoff, uint srcMip, rs_allocation_cubemap_face srcFace);

int2 rsAllocationVLoadX_int2(allocation_1D_global, 0);
int2 rsAllocationVLoadX_int2(allocation_2D_global, 24, 25);
int2 rsAllocationVLoadX_int2(allocation_3D_global, 0, 1, 0);
int3 rsAllocationVLoadX_int3(allocation_1D_global, 1);
int3 rsAllocationVLoadX_int3(allocation_2D_global, 27, 28);
int3 rsAllocationVLoadX_int3(allocation_3D_global, 1, 0, 1);
int4 rsAllocationVLoadX_int4(allocation_1D_global, 0);
int4 rsAllocationVLoadX_int4(allocation_2D_global, 29, 30);
int4 rsAllocationVLoadX_int4(allocation_3D_global, 0, 1, 0);

void rsAllocationVStoreX_int2(allocation_1D_global, int2 val, 2);
void rsAllocationVStoreX_int2(allocation_2D_global, int2 val, 6, 7);
void rsAllocationVStoreX_int2(allocation_3D_global, int2 val, 0, 1, 0);
void rsAllocationVStoreX_int3(allocation_1D_global, int3 val, 1);
void rsAllocationVStoreX_int3(allocation_2D_global, int3 val, 12, 13);
void rsAllocationVStoreX_int3(allocation_3D_global, int3 val, 1, 0, 1);
void rsAllocationVStoreX_int4(allocation_1D_global, int4 val, 0);
void rsAllocationVStoreX_int4(allocation_2D_global, int4 val, 18, 19);
void rsAllocationVStoreX_int4(allocation_3D_global, int4 val, 0, 1, 0);

void* rsGetElementAt(allocation_1D_global, 0);
void* rsGetElementAt(allocation_2D_global, 20, 21);
void* rsGetElementAt(allocation_3D_global, 1, 0, 1);
int rsGetElementAt_int(allocation_1D_global, 1);
int rsGetElementAt_int(allocation_2D_global, 22, 23);
int rsGetElementAt_int(allocation_3D_global, 0, 1, 0);

uchar rsGetElementAtYuv_uchar_U(allocation_YUV_2D_global, 0, 1);

uchar rsGetElementAtYuv_uchar_V(allocation_YUV_2D_global, 2, 3);

uchar rsGetElementAtYuv_uchar_Y(allocation_YUV_2D_global, 0, 1);

float4 rsSample(allocation_1D_global, rs_sampler s, float location);
float4 rsSample(allocation_1D_global, rs_sampler s, float location, float lod);
float4 rsSample(allocation_1D_global, rs_sampler s, float2 location);
float4 rsSample(allocation_1D_global, rs_sampler s, float2 location, float lod);

void rsSetElementAt(allocation_1D_global, int* ptr, 2);
void rsSetElementAt(allocation_2D_global, int* ptr, 24, 25);
void rsSetElementAt_int(allocation_1D_global, int val, 0);
void rsSetElementAt_int(allocation_2D_global, int val, 26, 27);
void rsSetElementAt_int(allocation_3D_global, int val, 1, 0, 1);
'''.splitlines())


TYPE_MAP = {
    'void' : '',
    'char' : r'\((signed )?char\)',
    'uchar' : r'\(uchar\)',
    'short' : r'\(short\)',
    'ushort' : r'\(ushort\)',
    'int' : r'\(int\)',
    'uint' : r'\(uint\)',
    'long' : r'\((long )?long\)',
    'ulong' : r'\(ulong\)',
    'float' : r'\(float\)',
    'float2' : r'\(float2\)',
    'float3' : r'\(float3\)',
    'float4' : r'\(float4\)'
    }


def _build_arg(token):
    '''Given a C argument construct an lldb expression for the argument.

    Given a token, which represents a single argument of a C function
    declaration, construct an lldb expression for the argument.

    Args:
        token: A string representing a single argument to a function. This
               can be either [type][name] (e.g. int arg) or [value] (e.g. 5).

    Returns:
        The string that is the lldb expression for that argument, e.g.
        int_global or 5.
    '''
    if len(token.split()) == 1:
        # This is a fixed constant. Just take that as output.
        return token

    result = token.split()[0]

    # Remove the rs_ prefix, because our globals' names don't have them
    if result[:3] == 'rs_':
        result = result[3:]

    # If the function expects a pointer, take the address of the global
    if result[-1] == '*':
        result = '&' + result
        result = result[:-1]

    result += '_global'
    return result


def build_expr(line):
    '''Build an lldb expression given a function prototype.

    Given a function declaration, this function will construct an lldb
    expression to call it.

    Args:
        line: A string representing a function declaration.

    Returns:
        The string that is the lldb expression.
    '''
    tokens = re.findall(r"[^(),;]+", line)
    assert len(tokens) > 0
    ret_name = tokens[0].split()
    ret = ret_name[0]
    name = ret_name[1]
    expr = 'expr {0}('.format(name)

    first = True
    for tok in tokens[1:]:
        if not first:
            expr += ', '
        expr += _build_arg(tok)
        first = False

    expr += ')'
    return ret, expr