implement full parser

.github/workflows/tests.yml

@@ -33,4 +33,4 @@ jobs:
       - name: Run tests with valgrind memory leak check
         run: |
           cd build
-          valgrind --leak-check=full --error-exitcode=1 ./tests/minissd_tests
+          valgrind --leak-check=full --track-origins=yes --error-exitcode=1 ./tests/minissd_tests

.vscode/settings.json

@@ -2,6 +2,7 @@
     "cSpell.words": [
         "libgtest",
         "MINISSD",
+        "STREQ",
         "valgrind"
     ],
     "files.associations": {

CMakeLists.txt

@@ -5,10 +5,17 @@ set(CMAKE_C_STANDARD 99)
 
 option(MINISSD_BUILD_EXAMPLE "Build example" ON)
 option(MINISSD_BUILD_TESTS "Build tests" ON)
+option(MINISSD_BUILD_SHARED "Build shared library" OFF)
 
 set(SOURCES src/minissd.c include/minissd.h)
 
-add_library(${PROJECT_NAME} STATIC ${SOURCES})
+if(MINISSD_BUILD_SHARED)
+    add_library(${PROJECT_NAME} SHARED ${SOURCES})
+    target_compile_definitions(${PROJECT_NAME} PRIVATE MINISSD_SHARED)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE MINISSD_EXPORTS)
+else()
+    add_library(${PROJECT_NAME} STATIC ${SOURCES})
+endif()
 
 target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
 target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)

example/minissd_print.c

@@ -5,18 +5,18 @@
 #include <stdio.h>
 #include <assert.h>
 
-void print_attributes(Attribute *attr)
+void print_attributes(Attribute const *attr)
 {
     while (attr)
     {
         printf("  Attribute: %s\n", minissd_get_attribute_name(attr));
 
-        for (Argument *arg = minissd_get_attribute_arguments(attr); arg; arg = minissd_get_next_argument(arg))
+        for (AttributeParameter const *arg = minissd_get_attribute_parameters(attr); arg; arg = minissd_get_next_attribute_parameter(arg))
         {
-            printf("    Argument: %s", arg->key);
-            if (arg->value)
+            printf("    Parameter: %s", arg->key);
+            if (arg->opt_value)
             {
-                printf(" = %s", arg->value);
+                printf(" = %s", arg->opt_value);
             }
             printf("\n");
         }
@@ -61,10 +61,18 @@ int main(int argc, char **argv)
         return 1;
     }
 
-    for (AstNode *node = ast; node; node = minissd_get_next_node(node))
+    for (AstNode const *node = ast; node; node = minissd_get_next_node(node))
     {
         printf("Node Type: ");
-        switch (minissd_get_node_type(node))
+        NodeType const *type = minissd_get_node_type(node);
+
+        if (!type)
+        {
+            printf("Unknown Node Type\n");
+            continue;
+        }
+
+        switch (*type)
         {
         case NODE_IMPORT:
             printf("Import\n");
@@ -77,7 +85,7 @@ int main(int argc, char **argv)
             printf("  Name: %s\n", minissd_get_data_name(node));
             print_attributes(minissd_get_attributes(node));
 
-            for (Property *prop = minissd_get_properties(node); prop; prop = minissd_get_next_property(prop))
+            for (Property const *prop = minissd_get_properties(node); prop; prop = minissd_get_next_property(prop))
             {
                 printf("  Property: %s : %s\n", minissd_get_property_name(prop), minissd_get_property_type(prop));
                 print_attributes(prop->attributes);
@@ -89,11 +97,11 @@ int main(int argc, char **argv)
             printf("  Name: %s\n", minissd_get_enum_name(node));
             print_attributes(minissd_get_attributes(node));
 
-            for (EnumVariant *value = minissd_get_enum_variants(node); value; value = minissd_get_next_enum_value(value))
+            for (EnumVariant const *value = minissd_get_enum_variants(node); value; value = minissd_get_next_enum_variant(value))
             {
                 bool has_value;
-                int val = minissd_get_enum_variant(value, &has_value);
-                printf("  Enum Value: %s", minissd_get_enum_variant_name(value));
+                int val = minissd_get_enum_variant_value(value, &has_value);
+                printf("  Enum Variant: %s", minissd_get_enum_variant_name(value));
                 if (has_value)
                 {
                     printf(" = %d", val);
@@ -103,8 +111,43 @@ int main(int argc, char **argv)
             }
             break;
 
-        default:
-            printf("Unknown Node Type\n");
+        case NODE_SERVICE:
+            printf("Service\n");
+            printf("  Name: %s\n", minissd_get_service_name(node));
+            print_attributes(minissd_get_attributes(node));
+
+            for (Dependency const *dep = minissd_get_dependencies(node); dep; dep = minissd_get_next_dependency(dep))
+            {
+                printf("  Depends: %s\n", minissd_get_dependency_path(dep));
+                print_attributes(dep->opt_ll_attributes);
+            }
+
+            for (Handler const *handler = minissd_get_handlers(node); handler; handler = minissd_get_next_handler(handler))
+            {
+                printf("  Handler: %s\n", handler->name);
+                if (handler->opt_return_type)
+                {
+                    printf("    Return Type: %s\n", handler->opt_return_type);
+                }
+                for (Argument const *arg = minissd_get_handler_arguments(handler); arg; arg = minissd_get_next_argument(arg))
+                {
+                    printf("    Argument: %s : %s\n", minissd_get_argument_name(arg), minissd_get_argument_type(arg));
+                    print_attributes(minissd_get_argument_attributes(arg));
+                }
+                print_attributes(handler->opt_ll_attributes);
+            }
+
+            for (Event const *event = minissd_get_events(node); event; event = minissd_get_next_event(event))
+            {
+                printf("  Event: %s\n", event->name);
+                for (Argument const *arg = minissd_get_event_arguments(event); arg; arg = minissd_get_next_argument(arg))
+                {
+                    printf("    Argument: %s : %s\n", minissd_get_argument_name(arg), minissd_get_argument_type(arg));
+                    print_attributes(minissd_get_argument_attributes(arg));
+                }
+                print_attributes(event->opt_ll_attributes);
+            }
+            break;
         }
     }