Merge pull request #23 from asdf-format/issue-21

#21: Initial version of public headers

Author: embray

.github/workflows/build.yaml

@@ -75,3 +75,8 @@ jobs:
           tail -n +1 tests/*.log
           tail -n +1 tests/tmp/*.out.txt
 
+      - name: Dist
+        run: make dist ${{ github.event.inputs.make_flags }}
+
+      - name: Dist check
+        run: make distcheck ${{ github.event.inputs.make_flags }}

.gitignore

@@ -17,12 +17,12 @@ Makefile
 */Makefile
 
 # build outputs
+/asdf
 */*.o
 */*.lo
 .deps
 .dirstamp
 .libs
-asdf
 libasdf.la
 libtool
 m4/libtool.m4

Makefile.am

@@ -1,10 +1,27 @@
+src_files = src/block.c src/event.c src/info.c src/parse.c src/parse_util.c src/stream.c src/yaml.c
+src_headers = \
+    src/block.h \
+    src/compat/endian.h \
+    src/event.h \
+    src/info.h \
+    src/parse.h \
+    src/parse_util.h \
+    src/stream.h \
+    src/stream_intern.h \
+    src/util.h \
+    src/yaml.h
+include_dir = $(top_srcdir)/include
+
 AM_CFLAGS = -fvisibility=hidden
-AM_CPPFLAGS = -I$(top_srcdir)/src # so that tests also find header files
+AM_CPPFLAGS = -I$(top_srcdir)/include
 ACLOCAL_AMFLAGS = -Im4
 
-src_files = src/block.c src/event.c src/info.c src/parse.c src/parse_util.c src/stream.c src/yaml.c
-src_headers = src/block.h src/event.h src/info.h src/parse.h src/parse_util.h src/stream.h src/yaml.h
-
+include_HEADERS = $(include_dir)/asdf.h
+nobase_include_HEADERS = \
+    $(include_dir)/asdf/event.h \
+    $(include_dir)/asdf/parse.h \
+    $(include_dir)/asdf/util.h \
+    $(include_dir)/asdf/yaml.h
 noinst_HEADERS = $(src_headers)
 
 # libasdf library
@@ -43,3 +60,24 @@ CODE_COVERAGE_IGNORE_PATTERN = \
 include $(top_srcdir)/aminclude_static.am
 
 SUBDIRS = tests
+
+# Include sample files from asdf-standard in the distribution (used in tests)
+# Eventually test against older reference files as well
+reference_files = $(top_srcdir)/asdf-standard/reference_files/1.6.0
+EXTRA_DIST = \
+    $(reference_files)/anchor.asdf \
+    $(reference_files)/ascii.asdf \
+    $(reference_files)/basic.asdf \
+    $(reference_files)/complex.asdf \
+    $(reference_files)/compressed.asdf \
+    $(reference_files)/endian.asdf \
+    $(reference_files)/exploded0000.asdf \
+    $(reference_files)/exploded.asdf \
+    $(reference_files)/float.asdf \
+    $(reference_files)/int.asdf \
+    $(reference_files)/scalars.asdf \
+    $(reference_files)/shared.asdf \
+    $(reference_files)/stream.asdf \
+    $(reference_files)/structured.asdf \
+    $(reference_files)/unicode_bmp.asdf \
+    $(reference_files)/unicode_spp.asdf

include/asdf.h

@@ -0,0 +1,6 @@
+#ifndef ASDF_H
+#define ASDF_H
+
+#include <asdf/parse.h>
+
+#endif

include/asdf/event.h

@@ -0,0 +1,57 @@
+#ifndef ASDF_EVENT_H
+#define ASDF_EVENT_H
+
+#include <stdbool.h>
+#include <stdio.h>
+
+#include <asdf/util.h>
+
+
+#define ASDF_EVENT_TYPES(X) \
+    X(ASDF_NONE_EVENT) \
+    X(ASDF_BEGIN_EVENT) \
+    X(ASDF_ASDF_VERSION_EVENT) \
+    X(ASDF_STANDARD_VERSION_EVENT) \
+    X(ASDF_COMMENT_EVENT) \
+    X(ASDF_TREE_START_EVENT) \
+    X(ASDF_YAML_EVENT) \
+    X(ASDF_TREE_END_EVENT) \
+    X(ASDF_BLOCK_EVENT) \
+    X(ASDF_PADDING_EVENT) \
+    X(ASDF_BLOCK_INDEX_EVENT) \
+    X(ASDF_END_EVENT)
+
+typedef enum {
+// clang-format off
+#define X(member) member,
+    ASDF_EVENT_TYPES(X)
+#undef X
+    ASDF_EVENT_TYPE_COUNT
+    // clang-format on
+} asdf_event_type_t;
+
+
+typedef struct asdf_event asdf_event_t;
+
+
+typedef struct asdf_block_info asdf_block_info_t;
+
+
+typedef struct asdf_tree_info asdf_tree_info_t;
+
+
+/* Forward declaration for asdf_parser_t */
+typedef struct asdf_parser asdf_parser_t;
+
+
+/* Public API functions */
+ASDF_EXPORT asdf_event_type_t asdf_event_type(asdf_event_t *event);
+ASDF_EXPORT const char *asdf_event_comment(const asdf_event_t *event);
+ASDF_EXPORT const asdf_tree_info_t *asdf_event_tree_info(const asdf_event_t *event);
+ASDF_EXPORT const asdf_block_info_t *asdf_event_block_info(const asdf_event_t *event);
+ASDF_EXPORT asdf_event_t *asdf_event_iterate(asdf_parser_t *parser);
+ASDF_EXPORT const char *asdf_event_type_name(asdf_event_type_t event_type);
+ASDF_EXPORT void asdf_event_print(const asdf_event_t *event, FILE *file, bool verbose);
+ASDF_EXPORT void asdf_event_free(asdf_parser_t *parser, asdf_event_t *event);
+
+#endif  /* ASDF_EVENT_H */

include/asdf/parse.h

@@ -0,0 +1,55 @@
+#ifndef ASDF_PARSE_H
+#define ASDF_PARSE_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include <asdf/util.h>
+
+
+// NOLINTNEXTLINE(readability-identifier-naming)
+#define _ASDF_PARSER_OPTS(X) \
+    X(ASDF_PARSER_OPT_EMIT_YAML_EVENTS, 0) \
+    X(ASDF_PARSER_OPT_BUFFER_TREE, 1)
+
+
+typedef enum {
+// clang-format off
+#define X(flag, bit) flag = (1UL << (bit)),
+    _ASDF_PARSER_OPTS(X)
+#undef X
+    // clang-format on
+} asdf_parser_opt_t;
+
+
+// NOLINTNEXTLINE(readability-magic-numbers)
+_Static_assert(ASDF_PARSER_OPT_BUFFER_TREE < (1UL << 63), "too many flags for 64-bit int");
+
+
+typedef uint64_t asdf_parser_optflags_t;
+
+
+typedef struct asdf_parser_cfg {
+    asdf_parser_optflags_t flags;
+} asdf_parser_cfg_t;
+
+
+typedef struct asdf_parser asdf_parser_t;
+
+
+/* Forward declaration for asdf_event_t */
+typedef struct asdf_event asdf_event_t;
+
+
+/* Public API functions */
+ASDF_EXPORT asdf_parser_t *asdf_parser_create(asdf_parser_cfg_t *config);
+ASDF_EXPORT int asdf_parser_set_input_file(asdf_parser_t *parser, const char *filename);
+ASDF_EXPORT int asdf_parser_set_input_fp(asdf_parser_t *parser, FILE *file, const char *filename);
+ASDF_EXPORT int asdf_parser_set_input_mem(asdf_parser_t *parser, const void *buf, size_t size);
+ASDF_EXPORT asdf_event_t *asdf_parser_parse(asdf_parser_t *parser);
+ASDF_EXPORT void asdf_parser_destroy(asdf_parser_t *parser);
+ASDF_EXPORT bool asdf_parser_has_error(const asdf_parser_t *parser);
+ASDF_EXPORT const char *asdf_parser_get_error(const asdf_parser_t *parser);
+
+#endif /* ASDF_PARSE_H */

include/asdf/util.h

@@ -0,0 +1,12 @@
+#ifndef ASDF_UTIL_H
+#define ASDF_UTIL_H
+
+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 4)
+    #define ASDF_EXPORT __attribute__ ((visibility ("default")))
+    #define ASDF_LOCAL __attribute__ ((visibility ("hidden")))
+#else
+    #define ASDF_EXPORT
+    #define ASDF_LOCAL
+#endif
+
+#endif  /* ASDF_UTIL_H */

include/asdf/yaml.h

@@ -0,0 +1,29 @@
+#ifndef ASDF_YAML_H
+#define ASDF_YAML_H
+
+#include <asdf/event.h>
+#include <asdf/util.h>
+
+
+typedef enum {
+    // Not a YAML event
+    ASDF_YAML_NONE_EVENT = 0,
+    ASDF_YAML_STREAM_START_EVENT,
+    ASDF_YAML_STREAM_END_EVENT,
+    ASDF_YAML_DOCUMENT_START_EVENT,
+    ASDF_YAML_DOCUMENT_END_EVENT,
+    ASDF_YAML_MAPPING_START_EVENT,
+    ASDF_YAML_MAPPING_END_EVENT,
+    ASDF_YAML_SEQUENCE_START_EVENT,
+    ASDF_YAML_SEQUENCE_END_EVENT,
+    ASDF_YAML_SCALAR_EVENT,
+    ASDF_YAML_ALIAS_EVENT
+} asdf_yaml_event_type_t;
+
+
+ASDF_EXPORT const char *asdf_yaml_event_scalar_value(const asdf_event_t *event, size_t *lenp);
+ASDF_EXPORT const char *asdf_yaml_event_tag(const asdf_event_t *event, size_t *lenp);
+ASDF_EXPORT asdf_yaml_event_type_t asdf_yaml_event_type(const asdf_event_t *event);
+ASDF_EXPORT const char *asdf_yaml_event_type_text(const asdf_event_t *event);
+
+#endif  /* ASDF_YAML_H */

src/event.c

@@ -12,6 +12,7 @@
 #include "block.h"
 #include "event.h"
 #include "parse.h"
+#include "parse_util.h"
 #include "util.h"
 #include "yaml.h"
 
@@ -48,13 +49,57 @@ const asdf_block_info_t *asdf_event_block_info(const asdf_event_t *event) {
 }
 
 
-int asdf_event_iterate(asdf_parser_t *parser, asdf_event_t *event) {
+void asdf_event_cleanup(asdf_parser_t *parser, asdf_event_t *event) {
     assert(parser);
-    assert(event);
 
-    // Clear previous event contents
-    asdf_event_destroy(parser, event);
-    return asdf_parser_parse(parser, event);
+    if (!event)
+        return;
+
+    switch (event->type) {
+    case ASDF_TREE_START_EVENT:
+    case ASDF_TREE_END_EVENT:
+        free(event->payload.tree);
+        break;
+    case ASDF_YAML_EVENT:
+        fy_parser_event_free(parser->yaml_parser, event->payload.yaml);
+        break;
+    case ASDF_ASDF_VERSION_EVENT:
+    case ASDF_STANDARD_VERSION_EVENT:
+        if (event->payload.version)
+            free(event->payload.version->version);
+
+        free(event->payload.version);
+        break;
+    case ASDF_BLOCK_EVENT:
+        free(event->payload.block);
+        break;
+    case ASDF_COMMENT_EVENT:
+        free(event->payload.comment);
+        break;
+    default:
+        break;
+    }
+    ZERO_MEMORY(event, sizeof(asdf_event_t));
+}
+
+
+asdf_event_t *asdf_event_iterate(asdf_parser_t *parser) {
+    if (!parser)
+        return NULL;
+
+    // Recycle the current event before allocating a new one
+    if (parser->current_event_p) {
+        asdf_event_cleanup(parser, &parser->current_event_p->event);
+        asdf_parse_event_recycle(parser, &parser->current_event_p->event);
+        parser->current_event_p = NULL;
+    }
+
+    asdf_event_t *event = asdf_parser_parse(parser);
+
+    if (!event)
+        free(parser->current_event_p);
+
+    return event;
 }
 
 
@@ -171,31 +216,16 @@ void asdf_event_print(const asdf_event_t *event, FILE *file, bool verbose) {
 }
 
 
-void asdf_event_destroy(asdf_parser_t *parser, asdf_event_t *event) {
-    assert(event);
-    switch (event->type) {
-    case ASDF_TREE_START_EVENT:
-    case ASDF_TREE_END_EVENT:
-        free(event->payload.tree);
-        break;
-    case ASDF_YAML_EVENT:
-        fy_parser_event_free(parser->yaml_parser, event->payload.yaml);
-        break;
-    case ASDF_ASDF_VERSION_EVENT:
-    case ASDF_STANDARD_VERSION_EVENT:
-        if (event->payload.version)
-            free(event->payload.version->version);
+void asdf_event_free(asdf_parser_t *parser, asdf_event_t *event) {
+    assert(parser);
 
-        free(event->payload.version);
-        break;
-    case ASDF_BLOCK_EVENT:
-        free(event->payload.block);
-        break;
-    case ASDF_COMMENT_EVENT:
-        free(event->payload.comment);
-        break;
-    default:
-        break;
-    }
-    ZERO_MEMORY(event, sizeof(asdf_event_t));
+    if (!event)
+        return;
+
+    if (!event) return;
+
+    struct asdf_event_p *event_p = (struct asdf_event_p *)((char *)event - offsetof(struct asdf_event_p, event));
+    asdf_event_cleanup(parser, &event_p->event);
+    free(event_p);
+    parser->current_event_p = NULL;
 }