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

Int width detection without sizeof

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
+/* The first attempt to guess your types is to check `limits.h`. Some compilers
- * file includes defines like `UINT_MAX` that Unity can make use of to learn a
+ * that don't support `stdint.h` could include `limits.h`. If you don't
- * lot about your system. It's possible you don't want it to do this or it's
+ * 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

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
+ *       - set UNITY_INT_WIDTH
- *       - UNITY_LONG_WIDTH
+ *       - set UNITY_LONG_WIDTH
- *       - UNITY_POINTER_WIDTH
+ *       - set UNITY_POINTER_WIDTH
 
  * Floats
  *     - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons

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 1: UINT_MAX, ULONG_MAX in <limits.h>, or default to 32 bits
- * Attempt 2: UINT_MAX, ULONG_MAX, etc in <limits.h>
+ * Attempt 2: UINTPTR_MAX in <stdint.h>, or default to same size as long
- * Attempt 3: Deduced from sizeof() macros */
+ * 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
+  #else /* Set to default */
-#endif
-#ifndef UNITY_INT_WIDTH
     #define UNITY_INT_WIDTH (32)
+  #endif /* UINT_MAX */
 #endif
 
-/* Determine the size of a long, if not already specified,
+/* Determine the size of a long, if not already specified. */
- * by following the process used above to define
- * UNITY_INT_WIDTH. */
 #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
+  #else /* Set to default */
-#endif
-#ifndef UNITY_LONG_WIDTH
     #define UNITY_LONG_WIDTH (32)
+  #endif /* ULONG_MAX */
 #endif
 
-/* Determine the size of a pointer, if not already specified,
+/* Determine the size of a pointer, if not already specified. */
- * by following the process used above to define
- * UNITY_INT_WIDTH. */
 #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
+  #else /* Set to default */
-#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
+  #endif /* UINTPTR_MAX */
 #endif
 
 /*-------------------------------------------------------
@@ -138,36 +109,29 @@
  *-------------------------------------------------------*/
 
 #ifndef UNITY_SUPPORT_64
-#if UNITY_LONG_WIDTH > 32
+  #if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64
-#define UNITY_SUPPORT_64
+    #define UNITY_SUPPORT_64
-#endif
+  #endif
-#endif
-#ifndef UNITY_SUPPORT_64
-#if UNITY_POINTER_WIDTH > 32
-#define UNITY_SUPPORT_64
-#endif
 #endif
 
 #ifndef UNITY_SUPPORT_64
-
+    /* No 64-bit Support */
-/* No 64-bit Support */
+    typedef _UU32 _U_UINT;
-typedef _UU32 _U_UINT;
+    typedef _US32 _U_SINT;
-typedef _US32 _U_SINT;
-
 #else
 
-/* 64-bit Support */
+    /* 64-bit Support */
-#if (UNITY_LONG_WIDTH == 32)
+  #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
+  #endif
-typedef _UU64 _U_UINT;
+    typedef _UU64 _U_UINT;
-typedef _US64 _U_SINT;
+    typedef _US64 _U_SINT;
 
 #endif
 
@@ -369,13 +333,7 @@ typedef void (*UnityTestFunction)(void);
 
 typedef enum
 {
-#if (UNITY_INT_WIDTH == 16)
+UNITY_DISPLAY_STYLE_INT = sizeof(int)+ UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-    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_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 = sizeof(unsigned) + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-    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_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

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      \
+-Wpointer-arith -Wredundant-decls -Wshadow -Wstrict-overflow=5 -Wstrict-prototypes             \
--Wunreachable-code -Wunused -fstrict-aliasing
+-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 > $@
 

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

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

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: []