Fix cmake duplicate targets

CMakeLists.txt

@@ -7,27 +7,37 @@ include(CMakePackageConfigHelpers)
 set(AKERR_USE_STDLIB 1 CACHE BOOL "Use the C standard library")
 set(akerror_install_cmakedir "${CMAKE_INSTALL_LIBDIR}/cmake/akerror")
 
-set(SCRIPT ${CMAKE_SOURCE_DIR}/scripts/generrno.sh)
+set(SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/scripts/generrno.sh)
-set(INFILE ${CMAKE_SOURCE_DIR}/include/akerror.tmpl.h)
+set(INFILE ${CMAKE_CURRENT_SOURCE_DIR}/include/akerror.tmpl.h)
-set(OUTFILES ${CMAKE_SOURCE_DIR}/src/errno.c ${CMAKE_SOURCE_DIR}/include/akerror.h)
+
+set(GENERATED_DIR ${CMAKE_CURRENT_BINARY_DIR}/generated)
+
+set(GENERATED_ERRNO_C ${GENERATED_DIR}/src/errno.c)
+set(GENERATED_AKERROR_H ${GENERATED_DIR}/include/akerror.h)
+
 add_custom_command(
-  OUTPUT ${OUTFILES}
+  OUTPUT ${GENERATED_ERRNO_C} ${GENERATED_AKERROR_H}
-  COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_SOURCE_DIR}
+  COMMAND ${CMAKE_COMMAND} -E make_directory ${GENERATED_DIR}
-  COMMAND /usr/bin/env bash ${SCRIPT} ${CMAKE_SOURCE_DIR}
+  COMMAND /usr/bin/env bash
+          ${SCRIPT}
+          ${CMAKE_CURRENT_SOURCE_DIR}
+          ${GENERATED_DIR}
   DEPENDS ${SCRIPT} ${INFILE}
   VERBATIM
 )
 
-set_source_files_properties(src/errno.c PROPERTIES GENERATED TRUE)
+add_library(akerror SHARED
+  src/error.c
+  ${GENERATED_ERRNO_C}
+)
 
-add_custom_target(generrno DEPENDS src/errno.c)
+target_include_directories(akerror PUBLIC
+  $<BUILD_INTERFACE:${GENERATED_DIR}>/include
+  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
 
 find_package(PkgConfig REQUIRED)
-add_library(akerror STATIC
+add_library(akerror::akerror ALIAS akerror)
-  src/error.c
-  src/errno.c
-)
-add_dependencies(akerror generrno)
 
 target_compile_definitions(akerror
     PUBLIC AKERR_USE_STDLIB=${AKERR_USE_STDLIB}
@@ -36,24 +46,18 @@ target_compile_definitions(akerror
 add_executable(test_err_catch tests/err_catch.c)
 add_executable(test_err_cleanup tests/err_cleanup.c)
 add_executable(test_err_trace tests/err_trace.c)
-add_executable(test_err_unhandled tests/err_unhandled.c)
+add_executable(test_err_improper_closure tests/err_improper_closure.c)
 add_test(NAME err_catch COMMAND test_err_catch)
 add_test(NAME err_cleanup COMMAND test_err_cleanup)
 add_test(NAME err_trace COMMAND test_err_trace)
-add_test(NAME err_unhandled COMMAND test_err_unhandled)
+add_test(NAME err_improper_closure COMMAND test_err_improper_closure)
 
-# Specify include directories for the library's headers (if applicable)
-target_include_directories(akerror PUBLIC
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/>
-)
 target_link_libraries(test_err_catch PRIVATE akerror)
 target_link_libraries(test_err_cleanup PRIVATE akerror)
 target_link_libraries(test_err_trace PRIVATE akerror)
-target_link_libraries(test_err_unhandled PRIVATE akerror)
+target_link_libraries(test_err_improper_closure PRIVATE akerror)
 
 set(main_lib_dest "lib/my_library-${MY_LIBRARY_VERSION}")
-install(TARGETS akerror EXPORT akerror DESTINATION "lib/")
 install(TARGETS akerror
   EXPORT akerrorTargets
   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
@@ -62,8 +66,6 @@ install(TARGETS akerror
   INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
 )
 
-install(EXPORT akerror FILE akerrorTargets.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/akerror)
-
 install(FILES "include/akerror.h" DESTINATION "include/")
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/akerror.pc DESTINATION "lib/pkgconfig/")
 

include/akerror.tmpl.h

@@ -30,9 +30,10 @@
 #define AKERR_VALUE                 (AKERR_LAST_ERRNO_VALUE + 12)
 #define AKERR_BEHAVIOR              (AKERR_LAST_ERRNO_VALUE + 13)
 #define AKERR_RELATIONSHIP          (AKERR_LAST_ERRNO_VALUE + 14)
+#define AKERR_EOF                   (AKERR_LAST_ERRNO_VALUE + 15)
 
 #ifndef AKERR_MAX_ERR_VALUE
-#define AKERR_MAX_ERR_VALUE (AKERR_LAST_ERRNO_VALUE + 14)
+#define AKERR_MAX_ERR_VALUE (AKERR_LAST_ERRNO_VALUE + 15)
 #elif AKERR_MAX_ERR_VALUE < 256
 #error user-defined AKERR_MAX_ERR_VALUE must be >= 256
 #endif
@@ -55,7 +56,6 @@ typedef struct
     bool reported;
     char stacktracebuf[AKERR_MAX_ERROR_STACKTRACE_BUF_LENGTH];
     char *stacktracebufptr;
-    int stacktracebufremaining;
 } akerr_ErrorContext;
 
 #define AKERR_NOIGNORE __attribute__((warn_unused_result))
@@ -68,7 +68,6 @@ extern akerr_ErrorUnhandledErrorHandler akerr_handler_unhandled_error;
 extern akerr_ErrorLogFunction akerr_log_method;
 extern akerr_ErrorContext *__akerr_last_ignored;
 
-akerr_ErrorContext AKERR_NOIGNORE *akerr_user_main(int argc, char **argv);
 akerr_ErrorContext AKERR_NOIGNORE *akerr_release_error(akerr_ErrorContext *ptr);
 akerr_ErrorContext AKERR_NOIGNORE *akerr_next_error();
 char *akerr_name_for_status(int status, char *name);

scripts/generrno.sh

@@ -1,16 +1,20 @@
 #!/bin/bash
 
 srcdir=$1
-rm -f ${srcdir}/src/errno.c
+outdir=$2
-echo "#include <akerror.h>" >> ${srcdir}/src/errno.c
+
-echo "#include <errno.h>" >> ${srcdir}/src/errno.c
+mkdir -p ${outdir}/src
-echo "void akerr_init_errno(void) {" >> ${srcdir}/src/errno.c
+mkdir -p ${outdir}/include
+rm -f ${outdir}/src/errno.c
+echo "#include <akerror.h>" >> ${outdir}/src/errno.c
+echo "#include <errno.h>" >> ${outdir}/src/errno.c
+echo "void akerr_init_errno(void) {" >> ${outdir}/src/errno.c
 maxval=$(errno --list | cut -d ' ' -f 2 | sort -g | tail -n 1)
 errno --list | while read LINE; do
     define=$(echo "$LINE" | cut -d ' ' -f 1);
     value=$(echo "$LINE" | cut -d ' ' -f 2);
     desc=$(echo "$LINE" | cut -d ' ' -f 3-);
-    echo "	akerr_name_for_status(${define}, \"${desc}\");" >> ${srcdir}/src/errno.c ;
+    echo "	akerr_name_for_status(${define}, \"${desc}\");" >> ${outdir}/src/errno.c ;
 done;
-echo "}" >> ${srcdir}/src/errno.c
+echo "}" >> ${outdir}/src/errno.c
-sed "s/#define AKERR_LAST_ERRNO_VALUE .*/#define AKERR_LAST_ERRNO_VALUE      ${maxval}/" ${srcdir}/include/akerror.tmpl.h > ${srcdir}/include/akerror.h
+sed "s/#define AKERR_LAST_ERRNO_VALUE .*/#define AKERR_LAST_ERRNO_VALUE      ${maxval}/" ${srcdir}/include/akerror.tmpl.h > ${outdir}/include/akerror.h

src/error.c

@@ -14,26 +14,10 @@ char __AKERR_ERROR_NAMES[AKERR_MAX_ERR_VALUE+1][AKERR_MAX_ERROR_NAME_LENGTH];
 
 akerr_ErrorContext AKERR_ARRAY_ERROR[AKERR_MAX_ARRAY_ERROR];
 
-int main(int argc, char **argv)
+int akerr_valid_error_address(akerr_ErrorContext *ptr)
 {
-    int i = 0;
+    // Is this within the memory region occupied by AKERR_ARRAY_ERROR?
-    PREPARE_ERROR(e);
+    return ((ptr >= &AKERR_ARRAY_ERROR[0]) && (ptr <= &AKERR_ARRAY_ERROR[AKERR_MAX_ARRAY_ERROR-1]));
-    ATTEMPT {
-	CATCH(e, akerr_user_main(argc, argv));
-	if ( e == NULL || e->status == 0 ) {
-	    /* User code claims everything went fine, doublecheck the error array before we quit */
-	    for ( i = AKERR_MAX_ARRAY_ERROR - 1; i >= 0; i-- ) {
-		if ( AKERR_ARRAY_ERROR[i].status != 0 && AKERR_ARRAY_ERROR[i].refcount != 0 ) {
-		    akerr_log_method("%s:%s:%d: Found unhandled and unreported error in the array at index %d\n", __FILE__, (char *)__func__, __LINE__, i);
-		    e = &AKERR_ARRAY_ERROR[i];
-		}
-	    }
-	}
-    } CLEANUP {
-    } PROCESS(e) {
-    } FINISH_NORETURN(e);
-    SUCCEED(e);
-    return 0;
 }
 
 void akerr_default_logger(const char *fmt, ...)
@@ -81,7 +65,9 @@ void akerr_init()
 	akerr_name_for_status(AKERR_VALUE, "Value Error");
 	akerr_name_for_status(AKERR_BEHAVIOR, "Behavior Error");
 	akerr_name_for_status(AKERR_RELATIONSHIP, "Relationship Error");
-	
+#if (defined(AKERR_USE_STDLIB) && AKERR_USE_STDLIB == 1) || (!defined(AKERR_USE_STDLIB))
+	akerr_init_errno();
+#endif
 	inited = 1;
     }
 }

tests/err_catch.c

@@ -23,7 +23,7 @@ akerr_ErrorContext *func1(void)
 }
 
 
-akerr_ErrorContext *akerr_user_main(int argc, char **argv)
+int main(void)
 {
     PREPARE_ERROR(errctx);
     ATTEMPT {
@@ -32,6 +32,5 @@ akerr_ErrorContext *akerr_user_main(int argc, char **argv)
     } PROCESS(errctx) {
     } HANDLE(errctx, AKERR_NULLPOINTER) {
       akerr_log_method("Caught exception");
-    } FINISH(errctx, true);
+    } FINISH_NORETURN(errctx);
-    SUCCEED(errctx);
 }

tests/err_cleanup.c

@@ -25,7 +25,7 @@ akerr_ErrorContext *func1(void)
     SUCCEED_RETURN(errctx);
 }
 
-akerr_ErrorContext *akerr_user_main(int argc, char **argv)
+int main(void)
 {
     x = 12345;
     PREPARE_ERROR(errctx);
@@ -35,8 +35,9 @@ akerr_ErrorContext *akerr_user_main(int argc, char **argv)
     } PROCESS(errctx) {
     } HANDLE(errctx, AKERR_NULLPOINTER) {
 	if ( x == 0 ) {
-	    FAIL_RETURN(errctx, AKERR_API, "Cleanup does not work");	    
+	    fprintf(stderr, "Cleanup works\n");
+	    return 0;
 	}
-    } FINISH(errctx, true);
+	return 1;
-    SUCCEED(errctx);
+    } FINISH_NORETURN(errctx);
 }

tests/err_improper_closure.c

@@ -0,0 +1,22 @@
+#include "akerror.h"
+#include <stdio.h>
+
+akerr_ErrorContext AKERR_NOIGNORE *improper_closure(void)
+{
+    PREPARE_ERROR(errctx);
+    ATTEMPT {
+    } CLEANUP {
+    } PROCESS(errctx) {
+    } FINISH(errctx, true);
+    fprintf(stderr, "Improperly returning from improper_closure\n");
+}
+
+int main(void)
+{
+    PREPARE_ERROR(errctx);
+    ATTEMPT {
+	CATCH(errctx, improper_closure());
+    } CLEANUP {
+    } PROCESS(errctx) {
+    } FINISH_NORETURN(errctx);
+}

tests/err_trace.c

@@ -23,13 +23,12 @@ akerr_ErrorContext *func1(void)
 }
 
 
-akerr_ErrorContext *akerr_user_main(int argc, char **argv)
+int main(void)
 {
     PREPARE_ERROR(errctx);
     ATTEMPT {
 	CATCH(errctx, func1());
     } CLEANUP {
     } PROCESS(errctx) {
-    } FINISH(errctx, true);
+    } FINISH_NORETURN(errctx);
-    SUCCEED(errctx);
 }