736 lines
14 KiB
C
736 lines
14 KiB
C
// Copyright 2009 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.
|
|
|
|
/* Translate a .goc file into a .c file. A .goc file is a combination
|
|
of a limited form of Go with C. */
|
|
|
|
/*
|
|
package PACKAGENAME
|
|
{# line}
|
|
func NAME([NAME TYPE { , NAME TYPE }]) [(NAME TYPE { , NAME TYPE })] \{
|
|
C code with proper brace nesting
|
|
\}
|
|
*/
|
|
|
|
/* We generate C code which implements the function such that it can
|
|
be called from Go and executes the C code. */
|
|
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
/* Whether we're emitting for gcc */
|
|
static int gcc;
|
|
|
|
/* Package prefix to use; only meaningful for gcc */
|
|
static const char *prefix;
|
|
|
|
/* File and line number */
|
|
static const char *file;
|
|
static unsigned int lineno = 1;
|
|
|
|
/* List of names and types. */
|
|
struct params {
|
|
struct params *next;
|
|
char *name;
|
|
char *type;
|
|
};
|
|
|
|
/* index into type_table */
|
|
enum {
|
|
Bool,
|
|
Float,
|
|
Int,
|
|
Uint,
|
|
Uintptr,
|
|
String,
|
|
Slice,
|
|
Eface,
|
|
};
|
|
|
|
static struct {
|
|
char *name;
|
|
int size;
|
|
} type_table[] = {
|
|
/* variable sized first, for easy replacement */
|
|
/* order matches enum above */
|
|
/* default is 32-bit architecture sizes */
|
|
"bool", 1,
|
|
"float", 4,
|
|
"int", 4,
|
|
"uint", 4,
|
|
"uintptr", 4,
|
|
"String", 8,
|
|
"Slice", 12,
|
|
"Eface", 8,
|
|
|
|
/* fixed size */
|
|
"float32", 4,
|
|
"float64", 8,
|
|
"byte", 1,
|
|
"int8", 1,
|
|
"uint8", 1,
|
|
"int16", 2,
|
|
"uint16", 2,
|
|
"int32", 4,
|
|
"uint32", 4,
|
|
"int64", 8,
|
|
"uint64", 8,
|
|
|
|
NULL,
|
|
};
|
|
|
|
/* Fixed structure alignment (non-gcc only) */
|
|
int structround = 4;
|
|
|
|
/* Unexpected EOF. */
|
|
static void
|
|
bad_eof(void)
|
|
{
|
|
fprintf(stderr, "%s:%u: unexpected EOF\n", file, lineno);
|
|
exit(1);
|
|
}
|
|
|
|
/* Out of memory. */
|
|
static void
|
|
bad_mem(void)
|
|
{
|
|
fprintf(stderr, "%s:%u: out of memory\n", file, lineno);
|
|
exit(1);
|
|
}
|
|
|
|
/* Allocate memory without fail. */
|
|
static void *
|
|
xmalloc(unsigned int size)
|
|
{
|
|
void *ret = malloc(size);
|
|
if (ret == NULL)
|
|
bad_mem();
|
|
return ret;
|
|
}
|
|
|
|
/* Reallocate memory without fail. */
|
|
static void*
|
|
xrealloc(void *buf, unsigned int size)
|
|
{
|
|
void *ret = realloc(buf, size);
|
|
if (ret == NULL)
|
|
bad_mem();
|
|
return ret;
|
|
}
|
|
|
|
/* Free a list of parameters. */
|
|
static void
|
|
free_params(struct params *p)
|
|
{
|
|
while (p != NULL) {
|
|
struct params *next;
|
|
|
|
next = p->next;
|
|
free(p->name);
|
|
free(p->type);
|
|
free(p);
|
|
p = next;
|
|
}
|
|
}
|
|
|
|
/* Read a character, tracking lineno. */
|
|
static int
|
|
getchar_update_lineno(void)
|
|
{
|
|
int c;
|
|
|
|
c = getchar();
|
|
if (c == '\n')
|
|
++lineno;
|
|
return c;
|
|
}
|
|
|
|
/* Read a character, giving an error on EOF, tracking lineno. */
|
|
static int
|
|
getchar_no_eof(void)
|
|
{
|
|
int c;
|
|
|
|
c = getchar_update_lineno();
|
|
if (c == EOF)
|
|
bad_eof();
|
|
return c;
|
|
}
|
|
|
|
/* Read a character, skipping comments. */
|
|
static int
|
|
getchar_skipping_comments(void)
|
|
{
|
|
int c;
|
|
|
|
while (1) {
|
|
c = getchar_update_lineno();
|
|
if (c != '/')
|
|
return c;
|
|
|
|
c = getchar();
|
|
if (c == '/') {
|
|
do {
|
|
c = getchar_update_lineno();
|
|
} while (c != EOF && c != '\n');
|
|
return c;
|
|
} else if (c == '*') {
|
|
while (1) {
|
|
c = getchar_update_lineno();
|
|
if (c == EOF)
|
|
return EOF;
|
|
if (c == '*') {
|
|
do {
|
|
c = getchar_update_lineno();
|
|
} while (c == '*');
|
|
if (c == '/')
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
ungetc(c, stdin);
|
|
return '/';
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Read and return a token. Tokens are delimited by whitespace or by
|
|
[(),{}]. The latter are all returned as single characters. */
|
|
static char *
|
|
read_token(void)
|
|
{
|
|
int c;
|
|
char *buf;
|
|
unsigned int alc, off;
|
|
const char* delims = "(),{}";
|
|
|
|
while (1) {
|
|
c = getchar_skipping_comments();
|
|
if (c == EOF)
|
|
return NULL;
|
|
if (!isspace(c))
|
|
break;
|
|
}
|
|
alc = 16;
|
|
buf = xmalloc(alc + 1);
|
|
off = 0;
|
|
if (strchr(delims, c) != NULL) {
|
|
buf[off] = c;
|
|
++off;
|
|
} else {
|
|
while (1) {
|
|
if (off >= alc) {
|
|
alc *= 2;
|
|
buf = xrealloc(buf, alc + 1);
|
|
}
|
|
buf[off] = c;
|
|
++off;
|
|
c = getchar_skipping_comments();
|
|
if (c == EOF)
|
|
break;
|
|
if (isspace(c) || strchr(delims, c) != NULL) {
|
|
if (c == '\n')
|
|
lineno--;
|
|
ungetc(c, stdin);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
buf[off] = '\0';
|
|
return buf;
|
|
}
|
|
|
|
/* Read a token, giving an error on EOF. */
|
|
static char *
|
|
read_token_no_eof(void)
|
|
{
|
|
char *token = read_token();
|
|
if (token == NULL)
|
|
bad_eof();
|
|
return token;
|
|
}
|
|
|
|
/* Read the package clause, and return the package name. */
|
|
static char *
|
|
read_package(void)
|
|
{
|
|
char *token;
|
|
|
|
token = read_token_no_eof();
|
|
if (strcmp(token, "package") != 0) {
|
|
fprintf(stderr,
|
|
"%s:%u: expected \"package\", got \"%s\"\n",
|
|
file, lineno, token);
|
|
exit(1);
|
|
}
|
|
return read_token_no_eof();
|
|
}
|
|
|
|
/* Read and copy preprocessor lines. */
|
|
static void
|
|
read_preprocessor_lines(void)
|
|
{
|
|
while (1) {
|
|
int c;
|
|
|
|
do {
|
|
c = getchar_skipping_comments();
|
|
} while (isspace(c));
|
|
if (c != '#') {
|
|
ungetc(c, stdin);
|
|
break;
|
|
}
|
|
putchar(c);
|
|
do {
|
|
c = getchar_update_lineno();
|
|
putchar(c);
|
|
} while (c != '\n');
|
|
}
|
|
}
|
|
|
|
/* Read a type in Go syntax and return a type in C syntax. We only
|
|
permit basic types and pointers. */
|
|
static char *
|
|
read_type(void)
|
|
{
|
|
char *p, *op, *q;
|
|
int pointer_count;
|
|
unsigned int len;
|
|
|
|
p = read_token_no_eof();
|
|
if (*p != '*')
|
|
return p;
|
|
op = p;
|
|
pointer_count = 0;
|
|
while (*p == '*') {
|
|
++pointer_count;
|
|
++p;
|
|
}
|
|
len = strlen(p);
|
|
q = xmalloc(len + pointer_count + 1);
|
|
memcpy(q, p, len);
|
|
while (pointer_count > 0) {
|
|
q[len] = '*';
|
|
++len;
|
|
--pointer_count;
|
|
}
|
|
q[len] = '\0';
|
|
free(op);
|
|
return q;
|
|
}
|
|
|
|
/* Return the size of the given type. */
|
|
static int
|
|
type_size(char *p)
|
|
{
|
|
int i;
|
|
|
|
if(p[strlen(p)-1] == '*')
|
|
return type_table[Uintptr].size;
|
|
|
|
for(i=0; type_table[i].name; i++)
|
|
if(strcmp(type_table[i].name, p) == 0)
|
|
return type_table[i].size;
|
|
if(!gcc) {
|
|
fprintf(stderr, "%s:%u: unknown type %s\n", file, lineno, p);
|
|
exit(1);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* Read a list of parameters. Each parameter is a name and a type.
|
|
The list ends with a ')'. We have already read the '('. */
|
|
static struct params *
|
|
read_params(int *poffset)
|
|
{
|
|
char *token;
|
|
struct params *ret, **pp, *p;
|
|
int offset, size, rnd;
|
|
|
|
ret = NULL;
|
|
pp = &ret;
|
|
token = read_token_no_eof();
|
|
offset = 0;
|
|
if (strcmp(token, ")") != 0) {
|
|
while (1) {
|
|
p = xmalloc(sizeof(struct params));
|
|
p->name = token;
|
|
p->type = read_type();
|
|
p->next = NULL;
|
|
*pp = p;
|
|
pp = &p->next;
|
|
|
|
size = type_size(p->type);
|
|
rnd = size;
|
|
if(rnd > structround)
|
|
rnd = structround;
|
|
if(offset%rnd)
|
|
offset += rnd - offset%rnd;
|
|
offset += size;
|
|
|
|
token = read_token_no_eof();
|
|
if (strcmp(token, ",") != 0)
|
|
break;
|
|
token = read_token_no_eof();
|
|
}
|
|
}
|
|
if (strcmp(token, ")") != 0) {
|
|
fprintf(stderr, "%s:%u: expected '('\n",
|
|
file, lineno);
|
|
exit(1);
|
|
}
|
|
if (poffset != NULL)
|
|
*poffset = offset;
|
|
return ret;
|
|
}
|
|
|
|
/* Read a function header. This reads up to and including the initial
|
|
'{' character. Returns 1 if it read a header, 0 at EOF. */
|
|
static int
|
|
read_func_header(char **name, struct params **params, int *paramwid, struct params **rets)
|
|
{
|
|
int lastline;
|
|
char *token;
|
|
|
|
lastline = -1;
|
|
while (1) {
|
|
token = read_token();
|
|
if (token == NULL)
|
|
return 0;
|
|
if (strcmp(token, "func") == 0) {
|
|
if(lastline != -1)
|
|
printf("\n");
|
|
break;
|
|
}
|
|
if (lastline != lineno) {
|
|
if (lastline == lineno-1)
|
|
printf("\n");
|
|
else
|
|
printf("\n#line %d \"%s\"\n", lineno, file);
|
|
lastline = lineno;
|
|
}
|
|
printf("%s ", token);
|
|
}
|
|
|
|
*name = read_token_no_eof();
|
|
|
|
token = read_token();
|
|
if (token == NULL || strcmp(token, "(") != 0) {
|
|
fprintf(stderr, "%s:%u: expected \"(\"\n",
|
|
file, lineno);
|
|
exit(1);
|
|
}
|
|
*params = read_params(paramwid);
|
|
|
|
token = read_token();
|
|
if (token == NULL || strcmp(token, "(") != 0)
|
|
*rets = NULL;
|
|
else {
|
|
*rets = read_params(NULL);
|
|
token = read_token();
|
|
}
|
|
if (token == NULL || strcmp(token, "{") != 0) {
|
|
fprintf(stderr, "%s:%u: expected \"{\"\n",
|
|
file, lineno);
|
|
exit(1);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* Write out parameters. */
|
|
static void
|
|
write_params(struct params *params, int *first)
|
|
{
|
|
struct params *p;
|
|
|
|
for (p = params; p != NULL; p = p->next) {
|
|
if (*first)
|
|
*first = 0;
|
|
else
|
|
printf(", ");
|
|
printf("%s %s", p->type, p->name);
|
|
}
|
|
}
|
|
|
|
/* Write a 6g function header. */
|
|
static void
|
|
write_6g_func_header(char *package, char *name, struct params *params,
|
|
int paramwid, struct params *rets)
|
|
{
|
|
int first, n;
|
|
|
|
printf("void\n%s·%s(", package, name);
|
|
first = 1;
|
|
write_params(params, &first);
|
|
|
|
/* insert padding to align output struct */
|
|
if(rets != NULL && paramwid%structround != 0) {
|
|
n = structround - paramwid%structround;
|
|
if(n & 1)
|
|
printf(", uint8");
|
|
if(n & 2)
|
|
printf(", uint16");
|
|
if(n & 4)
|
|
printf(", uint32");
|
|
}
|
|
|
|
write_params(rets, &first);
|
|
printf(")\n{\n");
|
|
}
|
|
|
|
/* Write a 6g function trailer. */
|
|
static void
|
|
write_6g_func_trailer(struct params *rets)
|
|
{
|
|
struct params *p;
|
|
|
|
for (p = rets; p != NULL; p = p->next)
|
|
printf("\tFLUSH(&%s);\n", p->name);
|
|
printf("}\n");
|
|
}
|
|
|
|
/* Define the gcc function return type if necessary. */
|
|
static void
|
|
define_gcc_return_type(char *package, char *name, struct params *rets)
|
|
{
|
|
struct params *p;
|
|
|
|
if (rets == NULL || rets->next == NULL)
|
|
return;
|
|
printf("struct %s_%s_ret {\n", package, name);
|
|
for (p = rets; p != NULL; p = p->next)
|
|
printf(" %s %s;\n", p->type, p->name);
|
|
printf("};\n");
|
|
}
|
|
|
|
/* Write out the gcc function return type. */
|
|
static void
|
|
write_gcc_return_type(char *package, char *name, struct params *rets)
|
|
{
|
|
if (rets == NULL)
|
|
printf("void");
|
|
else if (rets->next == NULL)
|
|
printf("%s", rets->type);
|
|
else
|
|
printf("struct %s_%s_ret", package, name);
|
|
}
|
|
|
|
/* Write out a gcc function header. */
|
|
static void
|
|
write_gcc_func_header(char *package, char *name, struct params *params,
|
|
struct params *rets)
|
|
{
|
|
int first;
|
|
struct params *p;
|
|
|
|
define_gcc_return_type(package, name, rets);
|
|
write_gcc_return_type(package, name, rets);
|
|
printf(" %s_%s(", package, name);
|
|
first = 1;
|
|
write_params(params, &first);
|
|
printf(") asm (\"");
|
|
if (prefix != NULL)
|
|
printf("%s.", prefix);
|
|
printf("%s.%s\");\n", package, name);
|
|
write_gcc_return_type(package, name, rets);
|
|
printf(" %s_%s(", package, name);
|
|
first = 1;
|
|
write_params(params, &first);
|
|
printf(")\n{\n");
|
|
for (p = rets; p != NULL; p = p->next)
|
|
printf(" %s %s;\n", p->type, p->name);
|
|
}
|
|
|
|
/* Write out a gcc function trailer. */
|
|
static void
|
|
write_gcc_func_trailer(char *package, char *name, struct params *rets)
|
|
{
|
|
if (rets == NULL)
|
|
;
|
|
else if (rets->next == NULL)
|
|
printf("return %s;\n", rets->name);
|
|
else {
|
|
struct params *p;
|
|
|
|
printf(" {\n struct %s_%s_ret __ret;\n", package, name);
|
|
for (p = rets; p != NULL; p = p->next)
|
|
printf(" __ret.%s = %s;\n", p->name, p->name);
|
|
printf(" return __ret;\n }\n");
|
|
}
|
|
printf("}\n");
|
|
}
|
|
|
|
/* Write out a function header. */
|
|
static void
|
|
write_func_header(char *package, char *name,
|
|
struct params *params, int paramwid,
|
|
struct params *rets)
|
|
{
|
|
if (gcc)
|
|
write_gcc_func_header(package, name, params, rets);
|
|
else
|
|
write_6g_func_header(package, name, params, paramwid, rets);
|
|
printf("#line %d \"%s\"\n", lineno, file);
|
|
}
|
|
|
|
/* Write out a function trailer. */
|
|
static void
|
|
write_func_trailer(char *package, char *name,
|
|
struct params *rets)
|
|
{
|
|
if (gcc)
|
|
write_gcc_func_trailer(package, name, rets);
|
|
else
|
|
write_6g_func_trailer(rets);
|
|
}
|
|
|
|
/* Read and write the body of the function, ending in an unnested }
|
|
(which is read but not written). */
|
|
static void
|
|
copy_body(void)
|
|
{
|
|
int nesting = 0;
|
|
while (1) {
|
|
int c;
|
|
|
|
c = getchar_no_eof();
|
|
if (c == '}' && nesting == 0)
|
|
return;
|
|
putchar(c);
|
|
switch (c) {
|
|
default:
|
|
break;
|
|
case '{':
|
|
++nesting;
|
|
break;
|
|
case '}':
|
|
--nesting;
|
|
break;
|
|
case '/':
|
|
c = getchar_update_lineno();
|
|
putchar(c);
|
|
if (c == '/') {
|
|
do {
|
|
c = getchar_no_eof();
|
|
putchar(c);
|
|
} while (c != '\n');
|
|
} else if (c == '*') {
|
|
while (1) {
|
|
c = getchar_no_eof();
|
|
putchar(c);
|
|
if (c == '*') {
|
|
do {
|
|
c = getchar_no_eof();
|
|
putchar(c);
|
|
} while (c == '*');
|
|
if (c == '/')
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case '"':
|
|
case '\'':
|
|
{
|
|
int delim = c;
|
|
do {
|
|
c = getchar_no_eof();
|
|
putchar(c);
|
|
if (c == '\\') {
|
|
c = getchar_no_eof();
|
|
putchar(c);
|
|
c = '\0';
|
|
}
|
|
} while (c != delim);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Process the entire file. */
|
|
static void
|
|
process_file(void)
|
|
{
|
|
char *package, *name;
|
|
struct params *params, *rets;
|
|
int paramwid;
|
|
|
|
package = read_package();
|
|
read_preprocessor_lines();
|
|
while (read_func_header(&name, ¶ms, ¶mwid, &rets)) {
|
|
write_func_header(package, name, params, paramwid, rets);
|
|
copy_body();
|
|
write_func_trailer(package, name, rets);
|
|
free(name);
|
|
free_params(params);
|
|
free_params(rets);
|
|
}
|
|
free(package);
|
|
}
|
|
|
|
static void
|
|
usage(void)
|
|
{
|
|
fprintf(stderr, "Usage: goc2c [--6g | --gc] [--go-prefix PREFIX] [file]\n");
|
|
exit(1);
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
char *goarch;
|
|
|
|
while(argc > 1 && argv[1][0] == '-') {
|
|
if(strcmp(argv[1], "-") == 0)
|
|
break;
|
|
if(strcmp(argv[1], "--6g") == 0)
|
|
gcc = 0;
|
|
else if(strcmp(argv[1], "--gcc") == 0)
|
|
gcc = 1;
|
|
else if (strcmp(argv[1], "--go-prefix") == 0 && argc > 2) {
|
|
prefix = argv[2];
|
|
argc--;
|
|
argv++;
|
|
} else
|
|
usage();
|
|
argc--;
|
|
argv++;
|
|
}
|
|
|
|
if(argc <= 1 || strcmp(argv[1], "-") == 0) {
|
|
file = "<stdin>";
|
|
process_file();
|
|
return 0;
|
|
}
|
|
|
|
if(argc > 2)
|
|
usage();
|
|
|
|
file = argv[1];
|
|
if(freopen(file, "r", stdin) == 0) {
|
|
fprintf(stderr, "open %s: %s\n", file, strerror(errno));
|
|
exit(1);
|
|
}
|
|
|
|
if(!gcc) {
|
|
// 6g etc; update size table
|
|
goarch = getenv("GOARCH");
|
|
if(goarch != NULL && strcmp(goarch, "amd64") == 0) {
|
|
type_table[Uintptr].size = 8;
|
|
type_table[String].size = 16;
|
|
type_table[Slice].size = 8+4+4;
|
|
type_table[Eface].size = 8+8;
|
|
structround = 8;
|
|
}
|
|
}
|
|
|
|
process_file();
|
|
return 0;
|
|
}
|