More cleaning up.

diff --git a/Makefile b/Makefile
index f1cf050c62ff1d00617bffa926eee7a253e9a552..453172589bc48676bf7404560aa3467063f8f633 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -69,7 +69,7 @@ regtests: regtestdrivers
 regtestdrivers: $(REGFILES)
        @echo
 
-#-include $(DEPFILES) $(TSTDEPFILES) $(REGDEPFILES)
+-include $(DEPFILES) $(TSTDEPFILES) $(REGDEPFILES)
 
 clean:
        @for file in $(OBJFILES) $(DEPFILES) $(TSTFILES) $(TSTDEPFILES) $(REGFILES) $(REGDEPFILES) pdclib.a pdclib.tgz scanf_testdata_*; do if [ -f $$file ]; then rm $$file; fi; done

diff --git a/functions/_PDCLIB/print.c b/functions/_PDCLIB/print.c
index 5027c5fa8e5aaada9972292fa590a1c40b359a95..72db66bed2590a275e9bb346a1bc5a06ff2c55e5 100644 (file)
--- a/functions/_PDCLIB/print.c
+++ b/functions/_PDCLIB/print.c
@@ -43,7 +43,7 @@
    n - pointer to maximum number of characters to be delivered in this call
    s - the buffer into which the character shall be delivered
 */
-#define DELIVER( x ) \
+#define PUT( x ) \
 do { \
     int character = x; \
     if ( status->i < status->n ) { \
@@ -104,7 +104,7 @@ static void intformat( intmax_t value, struct _PDCLIB_status_t * status )
         {
             for ( size_t i = 0; i < status->width - characters; ++i )
             {
-                DELIVER( ' ' );
+                PUT( ' ' );
                 ++(status->current);
             }
         }
@@ -113,7 +113,7 @@ static void intformat( intmax_t value, struct _PDCLIB_status_t * status )
     preidx = 0;
     while ( preface[ preidx ] != '\0' )
     {
-        DELIVER( preface[ preidx++ ] );
+        PUT( preface[ preidx++ ] );
         ++(status->current);
     }
     if ( ( ! ( status->flags & E_minus ) ) && ( status->flags & E_zero ) )
@@ -123,14 +123,14 @@ static void intformat( intmax_t value, struct _PDCLIB_status_t * status )
         */
         while ( status->current < status->width )
         {
-            DELIVER( '0' );
+            PUT( '0' );
             ++(status->current);
         }
     }
     /* Do the precision padding if necessary. */
     for ( size_t i = 0; i < prec_pads; ++i )
     {
-        DELIVER( '0' );
+        PUT( '0' );
     }
     }
 }
@@ -175,12 +175,12 @@ static void int2base( intmax_t value, struct _PDCLIB_status_t * status )
     if ( status->flags & E_lower )
     {
         /* Lowercase letters. Same array used for strto...(). */
-        DELIVER( _PDCLIB_digits[ digit ] );
+        PUT( _PDCLIB_digits[ digit ] );
     }
     else
     {
         /* Uppercase letters. Array only used here, only 0-F. */
-        DELIVER( _PDCLIB_Xdigits[ digit ] );
+        PUT( _PDCLIB_Xdigits[ digit ] );
     }
     }
 }
@@ -192,7 +192,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
     if ( *(++spec) == '%' )
     {
         /* %% -> print single '%' */
-        DELIVER( *spec );
+        PUT( *spec );
         return ++spec;
     }
     /* Initializing status structure */
@@ -381,7 +381,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
             break;
         case 'c':
             /* TODO: Flags, wide chars. */
-            DELIVER( va_arg( status->arg, int ) );
+            PUT( va_arg( status->arg, int ) );
             return ++spec;
         case 's':
             /* TODO: Flags, wide chars. */
@@ -389,7 +389,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
                 char * s = va_arg( status->arg, char * );
                 while ( *s != '\0' )
                 {
-                    DELIVER( *(s++) );
+                    PUT( *(s++) );
                 }
                 return ++spec;
             }
@@ -456,11 +456,11 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
             }
             if ( status->flags & E_lower )
             {
-                DELIVER( _PDCLIB_digits[ digit ] );
+                PUT( _PDCLIB_digits[ digit ] );
             }
             else
             {
-                DELIVER( _PDCLIB_Xdigits[ digit ] );
+                PUT( _PDCLIB_Xdigits[ digit ] );
             }
         }
         else
@@ -494,7 +494,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
         {
             while ( status->current < status->width )
             {
-                DELIVER( ' ' );
+                PUT( ' ' );
                 ++(status->current);
             }
         }

diff --git a/functions/_PDCLIB/scan.c b/functions/_PDCLIB/scan.c
index b346ffc2bb81dc7943d1db696e168241e2a77370..6bef32ec54ceb6b56cb6a27dc4419ec5248fa870 100644 (file)
--- a/functions/_PDCLIB/scan.c
+++ b/functions/_PDCLIB/scan.c
@@ -32,18 +32,6 @@
 #define E_unsigned   1<<16
 
 
-/* Helper macro for assigning a readily converted integer value to the correct
-   parameter type, used in a switch on status->flags (see E_* flags above).
-   case_cond: combination of the E_* flags above, used for the switch-case
-   type:      integer type, used to get the correct type from the parameter
-              stack as well as for cast target.
-*/
-#define ASSIGN_VALUE_TO( case_cond, type ) \
-    case case_cond: \
-        *( va_arg( status->arg, type * ) ) = (type)( value * sign ); \
-        break
-
-
 /* Helper function to get a character from the string or stream, whatever is
    used for input. When reading from a string, returns EOF on end-of-string
    so that handling of the return value can be uniform for both streams and
@@ -535,22 +523,58 @@ const char * _PDCLIB_scan( const char * spec, struct _PDCLIB_status_t * status )
                                    E_intmax | E_size | E_ptrdiff |
                                    E_unsigned ) )
         {
-            ASSIGN_VALUE_TO( E_char, char );
-            ASSIGN_VALUE_TO( E_char | E_unsigned, unsigned char );
-            ASSIGN_VALUE_TO( E_short, short );
-            ASSIGN_VALUE_TO( E_short | E_unsigned, unsigned short );
-            ASSIGN_VALUE_TO( 0, int );
-            ASSIGN_VALUE_TO( E_unsigned, unsigned int );
-            ASSIGN_VALUE_TO( E_long, long );
-            ASSIGN_VALUE_TO( E_long | E_unsigned, unsigned long );
-            ASSIGN_VALUE_TO( E_llong, long long );
-            ASSIGN_VALUE_TO( E_llong | E_unsigned, unsigned long long );
-            ASSIGN_VALUE_TO( E_intmax, intmax_t );
-            ASSIGN_VALUE_TO( E_intmax | E_unsigned, uintmax_t );
-            ASSIGN_VALUE_TO( E_size, size_t );
-            /* ASSIGN_VALUE_TO( E_size | E_unsigned, unsigned size_t ); */
-            ASSIGN_VALUE_TO( E_ptrdiff, ptrdiff_t );
-            /* ASSIGN_VALUE_TO( E_ptrdiff | E_unsigned, unsigned ptrdiff_t ); */
+            case E_char:
+                *( va_arg( status->arg,               char * ) ) =               (char)( value * sign );
+                break;
+            case E_char | E_unsigned:
+                *( va_arg( status->arg,      unsigned char * ) ) =      (unsigned char)( value * sign );
+                break;
+
+            case E_short:
+                *( va_arg( status->arg,              short * ) ) =              (short)( value * sign );
+                break;
+            case E_short | E_unsigned:
+                *( va_arg( status->arg,     unsigned short * ) ) =     (unsigned short)( value * sign );
+                break;
+
+            case 0:
+                *( va_arg( status->arg,                int * ) ) =                (int)( value * sign );
+                break;
+            case E_unsigned:
+                *( va_arg( status->arg,       unsigned int * ) ) =       (unsigned int)( value * sign );
+                break;
+
+            case E_long:
+                *( va_arg( status->arg,               long * ) ) =               (long)( value * sign );
+                break;
+            case E_long | E_unsigned:
+                *( va_arg( status->arg,      unsigned long * ) ) =      (unsigned long)( value * sign );
+                break;
+
+            case E_llong:
+                *( va_arg( status->arg,          long long * ) ) =          (long long)( value * sign );
+                break;
+            case E_llong | E_unsigned:
+                *( va_arg( status->arg, unsigned long long * ) ) = (unsigned long long)( value * sign );
+                break;
+
+            case E_intmax:
+                *( va_arg( status->arg,           intmax_t * ) ) =           (intmax_t)( value * sign );
+                break;
+            case E_intmax | E_unsigned:
+                *( va_arg( status->arg,          uintmax_t * ) ) =          (uintmax_t)( value * sign );
+                break;
+
+            case E_size:
+                /* E_size always implies unsigned */
+                *( va_arg( status->arg,             size_t * ) ) =             (size_t)( value * sign );
+                break;
+
+            case E_ptrdiff:
+                /* E_ptrdiff always implies signed */
+                *( va_arg( status->arg,          ptrdiff_t * ) ) =          (ptrdiff_t)( value * sign );
+                break;
+
             default:
                 puts( "UNSUPPORTED SCANF FLAG COMBINATION" );
                 return NULL; /* behaviour unspecified */