/*
Linux ELF:
gcc -gdwarf-2 -m64 -c typedef.c && gcc -gdwarf-2 -m64 -o typedef.elf typedef.o

OS X Mach-O:
gcc -gdwarf-2 -m64 -c typedef.c -o typedef.macho
gcc -gdwarf-4 -m64 -c typedef.c -o typedef.macho4
*/
#include <complex.h>

typedef volatile int* t_ptr_volatile_int;
typedef const char *t_ptr_const_char;
typedef long t_long;
typedef unsigned short t_ushort;
typedef int t_func_int_of_float_double(float, double);

Joe Sylve <******@****.***> 1630609755 +0000

Than McIntosh <******@****.***> 1643121275 -0500

typedef void* jobject;

typedef jobject jclass;
typedef jobject jthrowable;
typedef jobject jstring;
typedef jobject jarray;
typedef jarray jbooleanArray;
typedef jarray jbyteArray;
typedef jarray jcharArray;
typedef jarray jshortArray;
typedef jarray jintArray;
typedef jarray jlongArray;
typedef jarray jfloatArray;
typedef jarray jdoubleArray;
typedef jarray jobjectArray;

		In: `package main

// typedef struct _jobject* jobject;
import "C"

var x C.jobject = nil

func f() {
	x = nil
}
`,
		Out: `package main

// typedef struct _jobject* jobject;
import "C"

var x C.jobject = 0

func f() {
	x = 0
}
`,
	},
	{
		Name: "jni.EqualArgument",
		In: `package main

// typedef struct _jobject* jobject;
import "C"

var x C.jobject

			In: `package main

// typedef void *$EGLTYPE;
import "C"

func f() {
	var x C.$EGLTYPE = nil
	x = nil
	x, x = nil, nil
}
`,
			Out: `package main

// typedef void *$EGLTYPE;
import "C"

func f() {
	var x C.$EGLTYPE = 0
	x = 0
	x, x = 0, 0
}
`,
		},
		{
			Name: "egl.globalVariable",
			In: `package main

// typedef void *$EGLTYPE;
import "C"

		In: `package main

// typedef const void *CFTypeRef;
import "C"

var x C.CFTypeRef = nil

func f() {
	x = nil
}
`,
		Out: `package main

// typedef const void *CFTypeRef;
import "C"

var x C.CFTypeRef = 0

func f() {
	x = 0
}
`,
	},
	{
		Name: "cftype.EqualArgument",
		In: `package main

// typedef const void *CFTypeRef;
import "C"

struct Types0 {};

// Type lists of length 1, 2, 3, and so on.

template <typename T1>
struct Types1 {
  typedef T1 Head;
  typedef Types0 Tail;
};

$range i 2..n

$for i [[
$range j 1..i
$range k 2..i
template <$for j, [[typename T$j]]>
struct Types$i {
  typedef T1 Head;
  typedef Types$(i-1)<$for k, [[T$k]]> Tail;
};


]]

}  // namespace internal

struct Types0 {};

// Type lists of length 1, 2, 3, and so on.

template <typename T1>
struct Types1 {
  typedef T1 Head;
  typedef Types0 Tail;
};

$range i 2..n

$for i [[
$range j 1..i
$range k 2..i
template <$for j, [[typename T$j]]>
struct Types$i {
  typedef T1 Head;
  typedef Types$(i-1)<$for k, [[T$k]]> Tail;
};


]]

}  // namespace internal

// license that can be found in the LICENSE file.

// Test that the error message for an unrepresentable typedef in a
// union appears on the right line. This test is only run if the size
// of long double is larger than 64.

package main

/*
typedef long double             Float128;

typedef struct SV {
    union {
        Float128         float128;
    } value;
} SV;
*/
import "C"