// pointer types, because we generate code passing a struct ptr rather
// than using the typedef. This warning is expected and does not break
// a normal build.
// We can only disable -Wincompatible-pointer-types starting with GCC 5.

// #if __GNU_MAJOR__ >= 5
//
// #pragma GCC diagnostic ignored "-Wincompatible-pointer-types"
//
// typedef struct {
// 	int a;
// } issue27340Struct, *issue27340Ptr;
//

)

const object = common.RootTypeReferenceName

type TypeResolver struct {
}

// Resolve resolves the TypeRef for the given type name
// that starts with "Object".
// This is the unstructured version, which means the
// returned TypeRef does not refer to the schema.
func (r *TypeResolver) Resolve(name string) (common.TypeRef, bool) {
	if !strings.HasPrefix(name, object) {
		return nil, false
	}
	return NewTypeRef(name), true

	[op(0x07)]
	int SamrOpenDomain([in] policy_handle *handle,
			[in] uint32_t access_mask,
			[in] sid_t *sid,
			[out] policy_handle *domain_handle);

	typedef struct {
		uint32_t idx;
		unicode_string name;
	} SamrSamEntry;

	typedef struct {
		uint32_t count;
		[size_is(count)] SamrSamEntry *entries;
	} SamrSamArray;

	[op(0x0f)]
	int SamrEnumerateAliasesInDomain([in] policy_handle *domain_handle,

#include <stdio.h>

#undef nil
#define nil ((void*)0)
#define nelem(x) (sizeof(x)/sizeof((x)[0]))

typedef uint32_t uint32;
typedef uint64_t uint64;
typedef uintptr_t uintptr;

/*
 * The beginning of the per-goroutine structure,
 * as defined in ../pkg/runtime/runtime.h.
 * Just enough to edit these two fields.
 */
typedef struct G G;
struct G
{
	uintptr stacklo;
	uintptr stackhi;
};

/*

package org.gradle.kotlin.dsl.accessors

import org.gradle.api.reflect.TypeOf.typeOf

import org.gradle.kotlin.dsl.typeOf

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class KotlinTypeStringTest {

    @Test
    fun `#kotlinTypeStringFor array type`() {
        assertThat(
            kotlinTypeStringFor(typeOf<Array<String>>()),
            equalTo("Array<String>")

    }

    @Test
    public void canRepresentSimpleType() {
        TypeOf<String> type = new TypeOf<String>() {};

        assertTrue(type.isSimple());
        assertFalse(type.isArray());
        assertFalse(type.isParameterized());
        assertEquals(type.getConcreteClass(), String.class);
    }

    @Test
    public void canRepresentWildcardTypeExpression() {

#include "tensorflow/core/framework/attr_value.pb.h"

// An equivalent of a tensorflow::NameAttrList protocol buffer, but used in ways
// that sometimes do not require serialization.
typedef struct TFE_OpAttrs TFE_OpAttrs;

typedef struct TFE_Context TFE_Context;
typedef struct TFE_Op TFE_Op;

namespace tensorflow {
DEFINE_CONVERSION_FUNCTIONS(tensorflow::AbstractOpAttrs, TFE_OpAttrs);

)

var compareTests = [][]reflect.Value{
	ct(reflect.TypeOf(int(0)), -1, 0, 1),
	ct(reflect.TypeOf(int8(0)), -1, 0, 1),
	ct(reflect.TypeOf(int16(0)), -1, 0, 1),
	ct(reflect.TypeOf(int32(0)), -1, 0, 1),
	ct(reflect.TypeOf(int64(0)), -1, 0, 1),
	ct(reflect.TypeOf(uint(0)), 0, 1, 5),
	ct(reflect.TypeOf(uint8(0)), 0, 1, 5),
	ct(reflect.TypeOf(uint16(0)), 0, 1, 5),
	ct(reflect.TypeOf(uint32(0)), 0, 1, 5),
	ct(reflect.TypeOf(uint64(0)), 0, 1, 5),

typedef struct aaa *AAA;
typedef AAA BBB;
struct aaa { BBB val; };

AAA x(void) {
    return (AAA)0;

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cgotest

// typedef struct { } T42495A;
// typedef struct { int x[0]; } T42495B;
import "C"

//export Issue42495A
func Issue42495A(C.T42495A) {}

//export Issue42495B