Merge pull request #210 from jsalling/feature/int-detection

Int width detection without sizeof
2025-06-24 08:37:33 +08:00 · 2016-08-26 15:03:44 -04:00
parent daad2bc82b 28c94bd403
commit a74920d112
7 changed files with 68 additions and 168 deletions
--- a/examples/unity_config.h
+++ b/examples/unity_config.h
@ -1,5 +1,6 @@
 /* Unity Configuration
 * As of May 11th, 2016 at ThrowTheSwitch/Unity commit 837c529
+ * Update: August 25th, 2016
 * See Also: Unity/docs/UnityConfigurationGuide.pdf
 *
 * Unity is designed to run on almost anything that is targeted by a C compiler.
@ -53,31 +54,22 @@ extern "C"
 * automatically.
 **************************************************************************** */

-/* The first thing that Unity does to guess your types is check `stdint.h`. This
- * file includes defines like `UINT_MAX` that Unity can make use of to learn a
- * lot about your system. It's possible you don't want it to do this or it's
+/* The first attempt to guess your types is to check `limits.h`. Some compilers
+ * that don't support `stdint.h` could include `limits.h`. If you don't
+ * want Unity to check this file, define this to make it skip the inclusion.
+ * Unity looks at UINT_MAX & ULONG_MAX, which were available since C89.
+ */
+/* #define UNITY_EXCLUDE_LIMITS_H */
+
+/* The second thing that Unity does to guess your types is check `stdint.h`.
+ * This file defines `UINTPTR_MAX`, since C99, that Unity can make use of to
+ * learn about your system. It's possible you don't want it to do this or it's
 * possible that your system doesn't support `stdint.h`. If that's the case,
 * you're going to want to define this. That way, Unity will know to skip the
 * inclusion of this file and you won't be left with a compiler error.
 */
 /* #define UNITY_EXCLUDE_STDINT_H */

-/* The second attempt to guess your types is to check `limits.h`. Some compilers
- * that don't support `stdint.h` could include `limits.h` instead. If you don't
- * want Unity to check this file either, define this to make it skip the
- * inclusion.
- */
-/* #define UNITY_EXCLUDE_LIMITS_H */
-
-/* The third and final attempt to guess your types is to use the `sizeof()`
- * operator. Even if the first two options don't work, this one covers most
- * cases. There _is_ a rare compiler or two out there that doesn't support
- * `sizeof()` in the preprocessing stage, though. For these, you have the
- * ability to disable this feature as well.
- */
-/* #define UNITY_EXCLUDE_SIZEOF */
-
-
 /* ********************** MANUAL INTEGER TYPE DEFINITION ***********************
 * If you've disabled all of the automatic options above, you're going to have
 * to do the configuration yourself. There are just a handful of defines that
--- a/src/unity.h
+++ b/src/unity.h
@ -27,12 +27,11 @@ void tearDown(void);
 *     - Unity attempts to automatically discover your integer sizes
 *       - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in <stdint.h>
 *       - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in <limits.h>
- *       - define UNITY_EXCLUDE_SIZEOF to stop attempting to use sizeof in macros
 *     - If you cannot use the automatic methods above, you can force Unity by using these options:
 *       - define UNITY_SUPPORT_64
- *       - define UNITY_INT_WIDTH
- *       - UNITY_LONG_WIDTH
- *       - UNITY_POINTER_WIDTH
+ *       - set UNITY_INT_WIDTH
+ *       - set UNITY_LONG_WIDTH
+ *       - set UNITY_POINTER_WIDTH

 * Floats
 *     - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons
--- a/src/unity_internals.h
+++ b/src/unity_internals.h
@ -13,10 +13,15 @@

 #include <setjmp.h>

+#ifndef UNITY_EXCLUDE_MATH_H
+#include <math.h>
+#endif
+
 /* Unity Attempts to Auto-Detect Integer Types
- * Attempt 1: UINT_MAX, ULONG_MAX, etc in <stdint.h>
- * Attempt 2: UINT_MAX, ULONG_MAX, etc in <limits.h>
- * Attempt 3: Deduced from sizeof() macros */
+ * Attempt 1: UINT_MAX, ULONG_MAX in <limits.h>, or default to 32 bits
+ * Attempt 2: UINTPTR_MAX in <stdint.h>, or default to same size as long
+ * The user may override any of these derived constants:
+ * UNITY_INT_WIDTH, UNITY_LONG_WIDTH, UNITY_POINTER_WIDTH */
 #ifndef UNITY_EXCLUDE_STDINT_H
 #include <stdint.h>
 #endif
@ -25,29 +30,13 @@
 #include <limits.h>
 #endif

-#ifndef UNITY_EXCLUDE_SIZEOF
-#ifndef UINT_MAX
-#define UINT_MAX     (sizeof(unsigned int) * 256 - 1)
-#endif
-#ifndef ULONG_MAX
-#define ULONG_MAX    (sizeof(unsigned long) * 256 - 1)
-#endif
-#ifndef UINTPTR_MAX
-/* apparently this is not a constant expression: (sizeof(unsigned int *) * 256 - 1) so we have to just let this fall through */
-#endif
-#endif
-
-#ifndef UNITY_EXCLUDE_MATH_H
-#include <math.h>
-#endif
-
 /*-------------------------------------------------------
 * Guess Widths If Not Specified
 *-------------------------------------------------------*/

-/* Determine the size of an int, if not already specificied.
+/* Determine the size of an int, if not already specified.
 * We cannot use sizeof(int), because it is not yet defined
- * at this stage in the trnslation of the C program.
+ * at this stage in the translation of the C program.
 * Therefore, infer it from UINT_MAX if possible. */
 #ifndef UNITY_INT_WIDTH
  #ifdef UINT_MAX
@ -58,15 +47,12 @@
    #elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF)
      #define UNITY_INT_WIDTH (64)
    #endif
-  #endif
-#endif
-#ifndef UNITY_INT_WIDTH
-  #define UNITY_INT_WIDTH (32)
+  #else /* Set to default */
+    #define UNITY_INT_WIDTH (32)
+  #endif /* UINT_MAX */
 #endif

-/* Determine the size of a long, if not already specified,
- * by following the process used above to define
- * UNITY_INT_WIDTH. */
+/* Determine the size of a long, if not already specified. */
 #ifndef UNITY_LONG_WIDTH
  #ifdef ULONG_MAX
    #if (ULONG_MAX == 0xFFFF)
@ -76,39 +62,24 @@
    #elif (ULONG_MAX == 0xFFFFFFFFFFFFFFFF)
      #define UNITY_LONG_WIDTH (64)
    #endif
-  #endif
-#endif
-#ifndef UNITY_LONG_WIDTH
-  #define UNITY_LONG_WIDTH (32)
+  #else /* Set to default */
+    #define UNITY_LONG_WIDTH (32)
+  #endif /* ULONG_MAX */
 #endif

-/* Determine the size of a pointer, if not already specified,
- * by following the process used above to define
- * UNITY_INT_WIDTH. */
+/* Determine the size of a pointer, if not already specified. */
 #ifndef UNITY_POINTER_WIDTH
  #ifdef UINTPTR_MAX
-    #if (UINTPTR_MAX+0 <= 0xFFFF)
+    #if (UINTPTR_MAX <= 0xFFFF)
      #define UNITY_POINTER_WIDTH (16)
-    #elif (UINTPTR_MAX+0 <= 0xFFFFFFFF)
+    #elif (UINTPTR_MAX <= 0xFFFFFFFF)
      #define UNITY_POINTER_WIDTH (32)
-    #elif (UINTPTR_MAX+0 <= 0xFFFFFFFFFFFFFFFF)
+    #elif (UINTPTR_MAX <= 0xFFFFFFFFFFFFFFFF)
      #define UNITY_POINTER_WIDTH (64)
    #endif
-  #endif
-#endif
-#ifndef UNITY_POINTER_WIDTH
-  #ifdef INTPTR_MAX
-    #if (INTPTR_MAX+0 <= 0x7FFF)
-      #define UNITY_POINTER_WIDTH (16)
-    #elif (INTPTR_MAX+0 <= 0x7FFFFFFF)
-      #define UNITY_POINTER_WIDTH (32)
-    #elif (INTPTR_MAX+0 <= 0x7FFFFFFFFFFFFFFF)
-      #define UNITY_POINTER_WIDTH (64)
-    #endif
-  #endif
-#endif
-#ifndef UNITY_POINTER_WIDTH
-  #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH
+  #else /* Set to default */
+    #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH
+  #endif /* UINTPTR_MAX */
 #endif

 /*-------------------------------------------------------
@ -138,36 +109,29 @@
 *-------------------------------------------------------*/

 #ifndef UNITY_SUPPORT_64
-#if UNITY_LONG_WIDTH > 32
-#define UNITY_SUPPORT_64
-#endif
-#endif
-#ifndef UNITY_SUPPORT_64
-#if UNITY_POINTER_WIDTH > 32
-#define UNITY_SUPPORT_64
-#endif
+  #if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64
+    #define UNITY_SUPPORT_64
+  #endif
 #endif

 #ifndef UNITY_SUPPORT_64
-
-/* No 64-bit Support */
-typedef _UU32 _U_UINT;
-typedef _US32 _U_SINT;
-
+    /* No 64-bit Support */
+    typedef _UU32 _U_UINT;
+    typedef _US32 _U_SINT;
 #else

-/* 64-bit Support */
-#if (UNITY_LONG_WIDTH == 32)
+    /* 64-bit Support */
+  #if (UNITY_LONG_WIDTH == 32)
    typedef unsigned long long _UU64;
    typedef signed long long   _US64;
-#elif (UNITY_LONG_WIDTH == 64)
+  #elif (UNITY_LONG_WIDTH == 64)
    typedef unsigned long      _UU64;
    typedef signed long        _US64;
-#else
+  #else
    #error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported)
-#endif
-typedef _UU64 _U_UINT;
-typedef _US64 _U_SINT;
+  #endif
+    typedef _UU64 _U_UINT;
+    typedef _US64 _U_SINT;

 #endif

@ -369,13 +333,7 @@ typedef void (*UnityTestFunction)(void);

 typedef enum
 {
-#if (UNITY_INT_WIDTH == 16)
-    UNITY_DISPLAY_STYLE_INT      = 2 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH  == 32)
-    UNITY_DISPLAY_STYLE_INT      = 4 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH  == 64)
-    UNITY_DISPLAY_STYLE_INT      = 8 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#endif
+UNITY_DISPLAY_STYLE_INT = sizeof(int)+ UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
    UNITY_DISPLAY_STYLE_INT8     = 1 + UNITY_DISPLAY_RANGE_INT,
    UNITY_DISPLAY_STYLE_INT16    = 2 + UNITY_DISPLAY_RANGE_INT,
    UNITY_DISPLAY_STYLE_INT32    = 4 + UNITY_DISPLAY_RANGE_INT,
@ -383,25 +341,21 @@ typedef enum
    UNITY_DISPLAY_STYLE_INT64    = 8 + UNITY_DISPLAY_RANGE_INT,
 #endif

-#if (UNITY_INT_WIDTH == 16)
-    UNITY_DISPLAY_STYLE_UINT     = 2 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH  == 32)
-    UNITY_DISPLAY_STYLE_UINT     = 4 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH  == 64)
-    UNITY_DISPLAY_STYLE_UINT     = 8 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#endif
+UNITY_DISPLAY_STYLE_UINT = sizeof(unsigned) + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
    UNITY_DISPLAY_STYLE_UINT8    = 1 + UNITY_DISPLAY_RANGE_UINT,
    UNITY_DISPLAY_STYLE_UINT16   = 2 + UNITY_DISPLAY_RANGE_UINT,
    UNITY_DISPLAY_STYLE_UINT32   = 4 + UNITY_DISPLAY_RANGE_UINT,
 #ifdef UNITY_SUPPORT_64
    UNITY_DISPLAY_STYLE_UINT64   = 8 + UNITY_DISPLAY_RANGE_UINT,
 #endif
+
    UNITY_DISPLAY_STYLE_HEX8     = 1 + UNITY_DISPLAY_RANGE_HEX,
    UNITY_DISPLAY_STYLE_HEX16    = 2 + UNITY_DISPLAY_RANGE_HEX,
    UNITY_DISPLAY_STYLE_HEX32    = 4 + UNITY_DISPLAY_RANGE_HEX,
 #ifdef UNITY_SUPPORT_64
    UNITY_DISPLAY_STYLE_HEX64    = 8 + UNITY_DISPLAY_RANGE_HEX,
 #endif
+
    UNITY_DISPLAY_STYLE_UNKNOWN
 } UNITY_DISPLAY_STYLE_T;

@ -486,7 +440,7 @@ void UnityPrintFloat(const _UF number);
 #endif

 /*-------------------------------------------------------
- * Test Assertion Fuctions
+ * Test Assertion Functions
 *-------------------------------------------------------
 *  Use the macros below this section instead of calling
 *  these directly. The macros have a consistent naming
--- a/test/Makefile
+++ b/test/Makefile
@ -1,9 +1,9 @@
-CC ?= gcc
+CC = gcc
 ifeq ($(shell uname -s), Darwin)
-CC ?= clang
+CC = clang
 endif
 #DEBUG = -O0 -g
-CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror -Wredundant-decls
+CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror
 CFLAGS += $(DEBUG)
 DEFINES =  -D UNITY_OUTPUT_CHAR=putcharSpy
 DEFINES += -D UNITY_SUPPORT_64 -D UNITY_INCLUDE_DOUBLE -D UNITY_NO_WEAK
@ -14,10 +14,9 @@ BUILD_DIR = build
 TARGET = build/testunity-cov.exe

 # To generate coverage, call 'make -s', the default target runs.
-# To see missing coverage, follow up with 'make uncovered'.
 # For verbose output of all the tests, run 'make test'.
 default: coverage
-.PHONY: default coverage uncovered test clean
+.PHONY: default coverage test clean
 coverage: $(BUILD_DIR)/testunityRunner.c
 	cd $(BUILD_DIR) && \
 	$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC), ../$i) $(COV_FLAGS) -o ../$(TARGET)
@ -28,12 +27,18 @@ coverage: $(BUILD_DIR)/testunityRunner.c
 	grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true

 test: CFLAGS += -Wbad-function-cast -Wcast-qual -Wconversion -Wformat=2 -Wold-style-definition \
-Wpointer-arith -Wshadow -Wstrict-overflow=5 -Wstrict-prototypes -Wswitch-default -Wundef      \
-Wunreachable-code -Wunused -fstrict-aliasing
+-Wpointer-arith -Wredundant-decls -Wshadow -Wstrict-overflow=5 -Wstrict-prototypes             \
+-Wswitch-default -Wundef -Wunreachable-code -Wunused -fstrict-aliasing
 test: $(BUILD_DIR)/testunityRunner.c
 	$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC) -o $(TARGET)
 	./$(TARGET)

+# Compile only, for testing that preprocessor detection works
+UNITY_C_ONLY =-c ../src/unity.c -o $(BUILD_DIR)/unity.o
+intDetection:
+	$(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_STDINT_H
+	$(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_LIMITS_H
+
 $(BUILD_DIR)/testunityRunner.c: tests/testunity.c | $(BUILD_DIR)
 	awk $(AWK_SCRIPT) tests/testunity.c > $@

--- a/test/targets/gcc_32.yml
+++ b/test/targets/gcc_32.yml
@ -22,7 +22,6 @@ compiler:
    items:
      - UNITY_EXCLUDE_STDINT_H
      - UNITY_EXCLUDE_LIMITS_H
-      - UNITY_EXCLUDE_SIZEOF
      - UNITY_INCLUDE_DOUBLE
      - UNITY_SUPPORT_TEST_CASES
      - UNITY_INT_WIDTH=32
--- a/test/targets/gcc_64.yml
+++ b/test/targets/gcc_64.yml
@ -22,7 +22,6 @@ compiler:
    items:
      - UNITY_EXCLUDE_STDINT_H
      - UNITY_EXCLUDE_LIMITS_H
-      - UNITY_EXCLUDE_SIZEOF
      - UNITY_INCLUDE_DOUBLE
      - UNITY_SUPPORT_TEST_CASES
      - UNITY_SUPPORT_64
--- a/test/targets/gcc_auto_sizeof.yml
+++ b/test/targets/gcc_auto_sizeof.yml
@ -1,48 +0,0 @@
-compiler:
-  path: gcc
-  source_path:     '../src/'
-  unit_tests_path: &unit_tests_path 'tests/'
-  build_path:      &build_path 'build/'
-  options:
-    - '-c'
-    - '-m64'
-    - '-Wall'
-    - '-Wno-address'
-    - '-std=c99'
-    - '-pedantic'
-  includes:
-    prefix: '-I'
-    items:
-      - 'src/'
-      - '../src/'
-      - 'testdata/'
-      - *unit_tests_path
-  defines:
-    prefix: '-D'
-    items:
-      - UNITY_EXCLUDE_STDINT_H
-      - UNITY_EXCLUDE_LIMITS_H
-      - UNITY_INCLUDE_DOUBLE
-      - UNITY_SUPPORT_TEST_CASES
-      - UNITY_SUPPORT_64
-  object_files:
-    prefix: '-o'
-    extension: '.o'
-    destination: *build_path
-linker:
-  path: gcc
-  options:
-    - -lm
-    - '-m64'
-  includes:
-    prefix: '-I'
-  object_files:
-    path: *build_path
-    extension: '.o'
-  bin_files:
-    prefix: '-o'
-    extension: '.exe'
-    destination: *build_path
-colour: true
-:unity:
-  :plugins: []