posix split execl

Author: cirosantilli

c/compound_struct_literal.c

@@ -38,6 +38,12 @@ int main() {
         assert(sp->i == 1);
         assert(sp->j == 2);
 
+        /* Unlike string literals, they can be modified. */
+        sp->i = 3;
+        sp->j = 4;
+        assert(sp->i == 3);
+        assert(sp->j == 4);
+
         /*
         # Lifetime of compound struct literals
 

c/generic.c

@@ -8,18 +8,20 @@
 
 int main() {
 #if __STDC_VERSION__ >= 201112L
-#if defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 9
+#if defined(__GNUC__) && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
 #define typename(x) _Generic((x), \
     int:     "int", \
     float:   "float", \
     default: "other")
 
     int i;
+    const int ci;
     float f;
     void* v;
     assert(strcmp(typename(i), "int")   == 0);
+    assert(strcmp(typename(ci), "int")  == 0);
     assert(strcmp(typename(f), "float") == 0);
-    assert(strcmp(typename(i), "other") == 0);
+    assert(strcmp(typename(v), "other") == 0);
 #endif
 #endif
 }

c/null.c

@@ -1,62 +1,156 @@
 /*
-# NULL
+# null pointer constant
 
-    Good source: <http://c-faq.com/null/macro.html>
+    Good source: http://c-faq.com/null/macro.html
 
     Basic usage: indicate error as return value from function
+
+    C99 7.17/3 Common definitions `<stddef.h>` says:
+
+    # NULL
+
+        > NULL: macro which expands to an implementation-defined null pointer constant;
+
+        Then form the definition of "null pointer constant", it is either of:
+
+        - `0`
+        - `(void*)0`
+
+        Thus in x86-64, is it possible to differentiate them by size:
+        `0` is 4 bytes, while `(void*)` is 8.
+
+        C++:
+
+        -   ensures that NULL is an "rvalue of integer type that evaluates to zero" (`0`):
+            it cannot be a pointer.
+
+        -   introduces the related `nullptr`, which is guaranteed to be a pointer type.
+
+            This is specially important because of function overload.
+
+    # Null pointer constant
+
+    # Null pointer
+
+        Null pointer constant and null pointer are note the same thing!!!
+
+        6.3.2/3 Pointers:
+
+        > An integer constant expression with the value 0, or such an expression cast to type
+        void *, is called a null pointer constant.55) If a null pointer constant is converted to a
+        pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal
+        to a pointer to any object or function.
+
+        6.3.2/4 Pointers:
+
+        > Conversion of a null pointer to another pointer type yields a null pointer of that type.
+        Any two null pointers shall compare equal.
+
+        Therefore there are multiple `null` pointer types: `(void *)0`, `(int *)0`, etc.
+
+    # argc[argv]
+
+        Null pointer
+
+        5.1.2.2.1/2 Program startup:
+
+        > argv[argc] shall be a null pointer.
 */
 
 #include "common.h"
 
+int *ip;
+
 int main() {
     /*
-    Why it works: it never points to any possible valid memory location.
-    (`&` operator never gives anything equal to it).
-    this is so guaranteed that gcc emmits a warning in the following code
+    It never points to any possible valid memory location:
+    global, local variable, malloc return, ...
+
+    In other words, taking `&` of a variable never gives it.
     */
     {
         int i = 0;
         /* WARN GCC 4.7 warning: &i will never be null. Smart. */
         /*assert(&i != NULL);*/
     }
 
-    /* How it prints like: */
-    printf("NULL = %p\n", NULL);
+    /*
+    How it prints like: implementation defined.
 
-    /* `if(NULL)` and `if(!NULL)` in error checking code always work as expected */
-    assert(!NULL);
+    C99 7.19.6.1/8 The fprintf function:
+
+    > `p`: The argument shall be a pointer to void. The value of the pointer is
+    converted to a sequence of printing characters, in an implementation-defined
+    manner.
+    */
+    {
+        printf("printf NULL %%p = %p\n", NULL);
+    }
 
     /*
-    # NULL macro vs 0
+    # == for null pointers
 
-        Relationship to 0: typecasting `(int)0` to any pointer type as
-        `(int*)0`, `(char*)0` always gives NULL.
+        Treated specially at 6.5.9/5 Equality operators:
 
-        This is a valid way of representing the NULL pointer,
-        but it is better style to always use the `NULL` macro
+        > If one operand is a pointer and the other is a
+        null pointer constant, the null pointer constant is converted to the type of the pointer. 
 
-        The exact definition of `NULL` is implementation dependant.
-        A very common implementation is as `(void*)0`.
+        And 6.5.9/6:
 
-        C++11 also introduces the related `nullptr`.
+        > Two pointers compare equal if and only if both are null pointers, [...]
     */
     {
-        assert(NULL == (int*)0);
-        assert(NULL == (char*)0);
-        printf("sizeof(NULL) = %zu\n", sizeof(NULL));
+        /*
+        True, since both are null pointers.
+
+        TODO error or warning? WARN GCC 4.8: comparison of distinct pointers without cast.
+        */
+        {
+            /*assert((char *)0 == (int *)0);*/
+        }
+
+        /*
+        True: one is a pointer, and the other is a null pointer constant.
+        */
+        {
+            assert((char *)0 == NULL);
+
+            /* Above is converted to: */
+            assert((char *)0 == (char *)NULL);
+
+            /* True because `0` is a null pointer constant: */
+            assert((char *)0 == 0);
+
+            /*
+            True because NULL is either:
+
+            - `0`
+            - `(void *)0`, which is a null pointer constant
+            */
+            assert(NULL == 0);
+        }
+
+        /*
+        As a consequence, if(p) can be used directly on null checks,
+        as it is equivalent to:
+
+            if (p != 0)
+        */
+        {
+            if (NULL)
+                assert(false);
+        }
     }
 
-    /* ERROR: comparison of distinct pointer types requires a cast: */
+    /* WARN: comparison of distinct pointer types requires a cast: */
     {
         /*assert((int*)0 == (char*)0);*/
     }
 
     /*
     Never dereference the NULL pointer since it is guaranteed to point to nothing.
 
-    TODO to ANSI C, undefined behaviour? or guaranteed error?
-
-    May lead to a Segmentation fault.
+    TODO Undefined behaviour? On Linux leads to a Segmentation fault.
     */
     {
         /*volatile int i = *(int*)NULL;*/

c/offsetof.c

@@ -12,17 +12,30 @@
 #include "common.h"
 
 int main() {
-    struct foo {
-        char a;
-        char b[2];
-        int c;
-        char d;
-    };
-
-    printf("offsetof(struct foo, a) = %zu\n", offsetof(struct foo, a));
-    printf("offsetof(struct foo, b) = %zu\n", offsetof(struct foo, b));
-    printf("offsetof(struct foo, c) = %zu\n", offsetof(struct foo, c));
-    printf("offsetof(struct foo, d) = %zu\n", offsetof(struct foo, d));
+    /* Basic example. */
+    {
+        struct S {
+            char a;
+            char b[2];
+            int c;
+            char d;
+        };
+
+        printf("a = %zu\n", offsetof(struct S, a));
+        printf("b = %zu\n", offsetof(struct S, b));
+        printf("c = %zu\n", offsetof(struct S, c));
+        printf("d = %zu\n", offsetof(struct S, d));
+    }
+
+    /* Does not work with bitfields. */
+    {
+        struct S {
+            int a:1;
+        };
+
+        /* ERROR: attempt to take the address of a bitfield struct member. */
+        /*printf("a = %zu\n", offsetof(struct S, a));*/
+    }
 
     return EXIT_SUCCESS;
 }

c/operator.c

@@ -301,13 +301,28 @@ int main() {
         /*
         # &
 
-        AND bitwise
+            AND bitwise
+
+        # |
+
+            OR bitwise
         */
         {
             assert(((char)0x00 & (char)0x00) == (char)0x00);
             assert(((char)0xFF & (char)0x00) == (char)0x00);
             assert(((char)0xFF & (char)0xFF) == (char)0xFF);
 
+            /*
+            `&` and `|` have lower precedence than `==`!
+
+            Notorious design choice, since they are analogous to + and * ...
+            */
+            {
+                assert(!(2 &  0  == 0 ));
+                assert(!(2 & (0  == 0)));
+                assert( (2 &  0) == 0  );
+            }
+
             /*
             # Even
 

c/static/variable/main.c

@@ -6,6 +6,7 @@ static int si = 0;
 void a();
 
 void m() {
+    j = i;
     i++;
     si++;
     puts("m()");

c/stdio_h.c

@@ -769,7 +769,7 @@ int main() {
             - SEEK_END: relative to end of file
 
             It seems that seeking after the eof is undefined behaviour in ANSI C:
-            <http://bytes.com/topic/c/answers/219508-fseek-past-eof>
+            http://bytes.com/topic/c/answers/219508-fseek-past-eof
 
             This contrasts with POSIX lseek + write, in which the unwriten gap is 0.
         */