int avro_schema_to_json(const avro_schema_t schema, avro_writer_t out)
{
check_param(EINVAL, is_avro_schema(schema), "schema");
check_param(EINVAL, out, "writer");
int rval;
if (is_avro_primitive(schema)) {
check(rval, avro_write_str(out, "{\"type\":\""));
}
switch (avro_typeof(schema)) {
case AVRO_STRING:
check(rval, avro_write_str(out, "string"));
break;
case AVRO_BYTES:
check(rval, avro_write_str(out, "bytes"));
break;
case AVRO_INT32:
check(rval, avro_write_str(out, "int"));
break;
case AVRO_INT64:
check(rval, avro_write_str(out, "long"));
break;
case AVRO_FLOAT:
check(rval, avro_write_str(out, "float"));
break;
case AVRO_DOUBLE:
check(rval, avro_write_str(out, "double"));
break;
case AVRO_BOOLEAN:
check(rval, avro_write_str(out, "boolean"));
break;
case AVRO_NULL:
check(rval, avro_write_str(out, "null"));
break;
case AVRO_RECORD:
return write_record(out, avro_schema_to_record(schema));
case AVRO_ENUM:
return write_enum(out, avro_schema_to_enum(schema));
case AVRO_FIXED:
return write_fixed(out, avro_schema_to_fixed(schema));
case AVRO_MAP:
return write_map(out, avro_schema_to_map(schema));
case AVRO_ARRAY:
return write_array(out, avro_schema_to_array(schema));
case AVRO_UNION:
return write_union(out, avro_schema_to_union(schema));
case AVRO_LINK:
return write_link(out, avro_schema_to_link(schema));
}
if (is_avro_primitive(schema)) {
return avro_write_str(out, "\"}");
}
avro_set_error("Unknown schema type");
return EINVAL;
}
void write_fluffy_decls(FILE *output, const translation_unit_t *unit)
{
out = output;
global_scope = &unit->scope;
print_to_file(out);
fprintf(out, "/* WARNING: Automatically generated file */\n");
/* write structs,unions + enums */
entity_t *entity = unit->scope.entities;
for( ; entity != NULL; entity = entity->base.next) {
if (entity->kind != ENTITY_TYPEDEF)
continue;
type_t *type = entity->typedefe.type;
if(type->kind == TYPE_COMPOUND_STRUCT
|| type->kind == TYPE_COMPOUND_UNION) {
write_compound(entity->base.symbol, &type->compound);
} else if(type->kind == TYPE_ENUM) {
write_enum(entity->base.symbol, &type->enumt);
}
}
/* write global variables */
entity = unit->scope.entities;
for( ; entity != NULL; entity = entity->base.next) {
if (entity->kind != ENTITY_VARIABLE)
continue;
write_variable(entity);
}
/* write functions */
entity = unit->scope.entities;
for( ; entity != NULL; entity = entity->base.next) {
if (entity->kind != ENTITY_FUNCTION)
continue;
write_function(entity);
}
}
void write_jna_decls(FILE *output, const translation_unit_t *unit)
{
out = output;
global_scope = &unit->scope;
pset_new_init(&avoid_symbols);
print_to_file(out);
fprintf(out, "/* WARNING: Automatically generated file */\n");
fputs("import com.sun.jna.Native;\n", out);
fputs("import com.sun.jna.Pointer;\n", out);
fputs("\n", out);
const char *register_libname = libname;
if (register_libname == NULL)
register_libname = "library";
/* TODO: where to get the name from? */
fputs("public class binding {\n", out);
fputs("\tstatic {\n", out);
fprintf(out, "\t\tNative.register(\"%s\");\n", register_libname);
fputs("\t}\n", out);
fputs("\n", out);
/* read the avoid list */
FILE *avoid = fopen("avoid.config", "r");
if (avoid != NULL) {
for (;;) {
char buf[1024];
char *res = fgets(buf, sizeof(buf), avoid);
if (res == NULL)
break;
if (buf[0] == 0)
continue;
size_t len = strlen(buf);
if (buf[len-1] == '\n')
buf[len-1] = 0;
char *str = malloc(len+1);
memcpy(str, buf, len+1);
symbol_t *symbol = symbol_table_insert(str);
pset_new_insert(&avoid_symbols, symbol);
}
fclose(avoid);
}
/* write structs,unions + enums */
entity_t *entity = unit->scope.entities;
for ( ; entity != NULL; entity = entity->base.next) {
if (entity->kind == ENTITY_ENUM) {
if (find_enum_typedef(&entity->enume) != NULL)
continue;
write_enum(entity->base.symbol, &entity->enume);
} else if (entity->kind == ENTITY_TYPEDEF) {
type_t *type = entity->declaration.type;
if (type->kind == TYPE_ENUM) {
write_enum(entity->base.symbol, type->enumt.enume);
}
}
#if 0
if (is_type_compound(type)) {
write_compound(entity->base.symbol, &type->compound);
}
#endif
}
/* write functions */
entity = unit->scope.entities;
for ( ; entity != NULL; entity = entity->base.next) {
if (entity->kind != ENTITY_FUNCTION)
continue;
if (entity->base.pos.is_system_header)
continue;
if (entity->function.elf_visibility != ELF_VISIBILITY_DEFAULT)
continue;
if (output_limits != NULL) {
bool in_limits = false;
char const *const input_name = entity->base.pos.input_name;
for (output_limit *limit = output_limits; limit != NULL;
limit = limit->next) {
if (streq(limit->filename, input_name)) {
in_limits = true;
break;
}
}
if (!in_limits)
continue;
}
if (pset_new_contains(&avoid_symbols, entity->base.symbol))
continue;
write_function(entity);
}
fputs("}\n", out);
pset_new_destroy(&avoid_symbols);
}
static int write_datum(avro_writer_t writer, const avro_encoding_t * enc,
avro_schema_t writers_schema, avro_datum_t datum)
{
if (is_avro_schema(writers_schema) && is_avro_link(writers_schema)) {
return write_datum(writer, enc,
(avro_schema_to_link(writers_schema))->to,
datum);
}
switch (avro_typeof(datum)) {
case AVRO_NULL:
return enc->write_null(writer);
case AVRO_BOOLEAN:
return enc->write_boolean(writer,
avro_datum_to_boolean(datum)->i);
case AVRO_STRING:
return enc->write_string(writer,
avro_datum_to_string(datum)->s);
case AVRO_BYTES:
return enc->write_bytes(writer,
avro_datum_to_bytes(datum)->bytes,
avro_datum_to_bytes(datum)->size);
case AVRO_INT32:
case AVRO_INT64:{
int64_t val = avro_typeof(datum) == AVRO_INT32 ?
avro_datum_to_int32(datum)->i32 :
avro_datum_to_int64(datum)->i64;
if (is_avro_schema(writers_schema)) {
/* handle promotion */
if (is_avro_float(writers_schema)) {
return enc->write_float(writer,
(float)val);
} else if (is_avro_double(writers_schema)) {
return enc->write_double(writer,
(double)val);
}
}
return enc->write_long(writer, val);
}
case AVRO_FLOAT:{
float val = avro_datum_to_float(datum)->f;
if (is_avro_schema(writers_schema)
&& is_avro_double(writers_schema)) {
/* handle promotion */
return enc->write_double(writer, (double)val);
}
return enc->write_float(writer, val);
}
case AVRO_DOUBLE:
return enc->write_double(writer,
avro_datum_to_double(datum)->d);
case AVRO_RECORD:
return write_record(writer, enc,
avro_schema_to_record(writers_schema),
datum);
case AVRO_ENUM:
return write_enum(writer, enc,
avro_schema_to_enum(writers_schema),
avro_datum_to_enum(datum));
case AVRO_FIXED:
return avro_write(writer,
avro_datum_to_fixed(datum)->bytes,
avro_datum_to_fixed(datum)->size);
case AVRO_MAP:
return write_map(writer, enc,
avro_schema_to_map(writers_schema),
avro_datum_to_map(datum));
case AVRO_ARRAY:
return write_array(writer, enc,
avro_schema_to_array(writers_schema),
avro_datum_to_array(datum));
case AVRO_UNION:
return write_union(writer, enc,
avro_schema_to_union(writers_schema),
avro_datum_to_union(datum));
case AVRO_LINK:
break;
}
return 0;
}
