github
/
tinygo
mirror of https://github.com/tinygo-org/tinygo.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3708 Commits
99 Branches
41 Tags
26 MiB
Tree: a40b11f535
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a40b11f535'
${ noResults }
tinygo/testdata/cgo/out.txt

77 lines
1.5 KiB
Raw Normal View History

all: add bare-bones Cgo support
6 years ago
fortytwo: 42
cgo: add support for C.int, c.uint, etc
6 years ago
add: 8
cgo: add support for C typedefs
6 years ago
myint: 3 5
cgo: do not rely on stdint.h to be available
6 years ago
myint size: 2
cgo: add support for C.int, c.uint, etc
6 years ago
longlong: -1099511627776
loader: support global variables in CGo (#173) Global variables (like functions) must be declared in the import "C" preamble and can then be used from Go.
6 years ago
global: 3
cgo: add support for #define constants These are converted to Go constants where possible.
6 years ago
defined ints: 5 5
defined floats: +5.800000e+000 +5.800000e+000
defined string: defined string
defined char: 99
cgo: implement prefix parsing This implements expressions such as "-5" and "-5 - 2", in other words, negative numbers.
4 years ago
defined expr: 9
loader/cgo: add support for pointer types
6 years ago
15: 15
25: 25
loader/cgo: add support for function pointers
6 years ago
callback 1: 50
callback 2: 600
cgo: add support for variadic functions This doesn't yet add support for actually making use of variadic functions, but at least allows (unintended) variadic functions like the following to work: void foo();
4 years ago
variadic0: 1
variadic2: 15
builder, cgo: support function definitions in CGo headers For example, the following did not work before but does work with this change: // int add(int a, int b) { // return a + b; // } import "C" func main() { println("add:", C.add(3, 5)) } Even better, the functions in the header are compiled together with the rest of the Go code and so they can be optimized together! Currently, inlining is not yet allowed but const-propagation across functions works. This should be improved in the future.
3 years ago
headerfunc: 6
cgo: implement support for static functions
3 years ago
static headerfunc: 4
static headerfunc 2: +4.000000e+000
static headerfunc void: 3
cgo: implement bool/float/complex types
6 years ago
bool: true true
float: +3.100000e+000
double: +3.200000e+000
complex float: (+4.100000e+000+3.300000e+000i)
complex double: (+4.200000e+000+3.400000e+000i)
complex long double: (+4.300000e+000+3.500000e+000i)
cgo: implement char type This type is a bit more difficult because it can be signed or unsigned depending on the target platform.
6 years ago
char match: true
cgo: implement void* pointer type void* is translated to unsafe.Pointer on the Go side.
6 years ago
void* match: true true true
cgo: support builtin #include headers Add support for header files bundled with the compiler by copying them into the release tarball.
6 years ago
int64_t match: true
cgo: implement C unions Unions are somewhat hard to implement in Go because they are not a native type. But it is actually possible with some compiler magic. This commit inserts a special "C union" field at the start of a struct to indicate that it is a union. As such a field cannot be written directly in Go, this is a useful to distinguish structs and unions.
6 years ago
struct: true 256 -123456 +3.140000e+000
array: 5 6 7
union: true
union s: 22
cgo: add support for C.float and C.double They are not necessary in TinyGo because they always map to float32 and float64, but it's a good idea to add them regardless for compatibility with existing software. (Now I think about it, perhaps it would have been better to require explicit casts here just in case we want to support some really weird C system, but then again we even force 64-bit double on AVR even though avr-gcc defaults to 32-bit double).
2 years ago
union f (C.float): +6.280000e+000
union f (float32): +3.140000e+000
cgo: implement C unions Unions are somewhat hard to implement in Go because they are not a native type. But it is actually possible with some compiler magic. This commit inserts a special "C union" field at the start of a struct to indicate that it is a union. As such a field cannot be written directly in Go, this is a useful to distinguish structs and unions.
6 years ago
union global data: 5 8 1
union local data: 5 8 1
cgo: improve typedef/struct/enum support Typedefs are now Go type aliases. And C.struct_ and C.union_ prefixed records work correctly now, even when they're not in a typedef.
6 years ago
union s: true
cgo: implement C unions Unions are somewhat hard to implement in Go because they are not a native type. But it is actually possible with some compiler magic. This commit inserts a special "C union" field at the start of a struct to indicate that it is a union. As such a field cannot be written directly in Go, this is a useful to distinguish structs and unions.
6 years ago
union f: +6.280000e+000
union field: +6.280000e+000
cgo: add support for bitfields using generated getters and setters
6 years ago
bitfield a: 15
bitfield b: 1
bitfield c: 2
bitfield d: 47
bitfield e: 5
bitfield a: 7
bitfield b: 0
bitfield c: 3
bitfield d: 47
bitfield e: 5
cgo: improve typedef/struct/enum support Typedefs are now Go type aliases. And C.struct_ and C.union_ prefixed records work correctly now, even when they're not in a typedef.
6 years ago
struct: 3 5
cgo: implement C.struct_ types These types (called elaborated types in C) are used as part of linked lists, among others. This is part an extra feature (to be compatible with CGo C.struct_ types) and part a bugfix: linked lists would result in endless recursion leading to a stack overflow.
6 years ago
n in chain: 3
n in chain: 6
n in chain: 7
cgo: add support for enum types Enum types are implemented as named types (with possible accompanying typedefs as type aliases). The constants inside the enums are treated as Go constants like in the Go toolchain.
6 years ago
option: 12
option A: 0
option B: 1
option C: -5
option D: -4
option E: 10
option F: 11
option G: 12
option 2A: 20
option 3A: 21
builder: make sure -fshort-enums is used consistently The main change is in building the libraries, where -fshort-enums was passed on RISC-V while other C files weren't compiled with this setting. Note: the test already passed before this change, but it seems like a good idea to explicitly test for enum size consistency. There is also not a particular reason not to pass -fshort-enums on RISC-V. Perhaps it's better to do it there too (on baremetal targets that don't have to worry about binary compatibility).
5 years ago
enum width matches: true
cgo: add support for CFLAGS in .c files This patch adds support for passing CFLAGS added in #cgo lines of the CGo preprocessing phase to the compiler when compiling C files inside packages. This is expected and convenient but didn't work before.
4 years ago
CFLAGS value: 17
cgo: add support for C.CString and related functions
3 years ago
cstr length: 18
C.CString: string passed to C
C.charBuf: 2 0 4 8
C.CStringN: 4 2 0 4 8
C.GoString(nil):
len(C.GoStringN(nil, 0)): 0
len(C.GoBytes(nil, 0)): 0
all: include picolibc for bare metal targets This is necessary for better CGo support on bare metal. Existing libraries expect to be able to include parts of libc and expect to be able to link to those symbols. Because with this all targets have a working libc, it is now possible to add tests to check that a libc in fact works basically. Not all parts of picolibc are included, such as the math or stdio parts. These should be added later, when needed. This commit also avoids the need for the custom memcpy/memset/memcmp symbols that are sometimes emitted by LLVM. The C library will take care of that.
5 years ago
copied string: foobar
cgo: add support for stdio in picolibc and wasi-libc This adds support for stdio in picolibc and fixes wasm_exec.js so that it can also support C puts. With this, C stdout works on all supported platforms.
3 years ago
line written using C puts