adlint 1.0.0

data/share/demo/funptr_cast/funptr_cast.c

@@ -0,0 +1,26 @@
+#pragma once
+#pragma twice
+#pragma omp parallel
+
+typedef int (*compatible_funptr)();
+
+typedef int (*incompatible_funptr1)(int);
+typedef void (*incompatible_funptr2)();
+typedef long (*incompatible_funptr3)(char *);
+
+int main(void)
+{
+    compatible_funptr p1 = (compatible_funptr) &main;
+    const int i = 0;
+
+    incompatible_funptr1 p2 = (incompatible_funptr1) &main;
+    incompatible_funptr2 p3 = (incompatible_funptr2) &main;
+    incompatible_funptr3 p4 = (incompatible_funptr3) main;
+
+    void (*p5)(int) = (void (*)(int)) &main;
+
+    void (*p6)() = (void (*)()) i;
+    const int j = (int) &main;
+
+    return 0;
+}

data/share/demo/goto_stmt/goto_stmt.c

@@ -0,0 +1,19 @@
+int main(void)
+{
+    int i = rand();
+
+    if (i == 1) {
+        goto Label1;
+    }
+
+    if (i < 0) {
+        int j = 3 / i;
+Label1:
+Label2:
+        return j;
+    }
+
+    goto Label2;
+
+    return 0;
+}

data/share/demo/id_hiding/id_hiding.c

@@ -0,0 +1,19 @@
+extern int i;
+
+static int foo(const int i)
+{
+    return i;
+}
+
+static int bar(void)
+{
+    const int i = foo(0);
+    return i;
+}
+
+static int baz(void)
+{
+    typedef int foo;
+    const foo f = 0;
+    return f;
+}

data/share/demo/ill_defined/ill_defined.c

@@ -0,0 +1,13 @@
+#define FOO 1
+
+#if defined(FOO)
+int i;
+#endif
+
+#if defined FOO
+int ii;
+#endif
+
+#if defined "FOO"
+int iii;
+#endif

data/share/demo/implicit_conv/implicit_conv.c

@@ -0,0 +1,60 @@
+void foo(const unsigned int ui1, const unsigned int ui2,
+         const unsigned char uc1, const unsigned char uc2)
+{
+    unsigned long ul;
+
+    ul = ~ui1;
+
+    ul = ui1 * ui2;
+    ul = ui1 / ui2;
+    ul = ui1 % ui2;
+
+    ul = ui1 + ui2;
+    ul = ui1 - ui2;
+
+    ul = ui1 & uib;
+    ul = ui1 | uib;
+    ul = ui1 ^ ui2;
+
+    ul = ui1 << 1;
+    ul = ui1 >> 1;
+
+    ul = ~uc1;
+
+    ul = uc1 * uc2;
+    ul = uc1 / uc2;
+    ul = uc1 % uc2;
+
+    ul = uc1 + uc2;
+    ul = uc1 - uc2;
+
+    ul = uc1 & ucb;
+    ul = uc1 | ucb;
+    ul = uc1 ^ uc2;
+
+    ul = uc1 << 1;
+    ul = uc1 >> 1;
+
+    ul = (unsigned long) (~uc1);
+
+    ul = (unsigned long) (uc1 * uc2);
+    ul = (unsigned long) (uc1 / uc2);
+    ul = (unsigned long) (uc1 % uc2);
+
+    ul = (unsigned long) (uc1 + uc2);
+    ul = (unsigned long) (uc1 - uc2);
+
+    ul = (unsigned long) (uc1 & uc2);
+    ul = (unsigned long) (uc1 | uc2);
+    ul = (unsigned long) (uc1 ^ uc2);
+
+    ul = (unsigned long) (uc1 << 1);
+    ul = (unsigned long) (uc1 >> 1);
+}
+
+void bar(void)
+{
+    unsigned char uc = -1;
+
+    uc = -2;
+}

data/share/demo/implicit_int/implicit_int.c

@@ -0,0 +1,14 @@
+extern const g_int;
+
+extern foo(void);
+
+static bar(const *p)
+{
+    return *p;
+}
+
+extern baz(void)
+{
+    const i = 0;
+    return i;
+}

data/share/demo/incomplete_type/incomplete_type.c

@@ -0,0 +1,49 @@
+extern struct Foo ga1[3];
+extern union Bar ga2[3];
+extern void ga3[3];
+extern int ga4[3][];
+extern int ga5[][3];
+
+extern int ga6[3]();
+extern int ga7[3](int);
+extern int (*ga8[3])(long);
+
+static struct Foo a1[3];
+static union Bar a2[3];
+static void a3[3];
+static int a4[3][];
+static int a5[][3];
+
+static int a6[3]();
+static int a7[3](int);
+static int (*a8[3])(long);
+
+void foo(const union Bar *p1, const union Bar * const p2)
+{
+    *p1 = *p2;
+    p1[0] = p2[0];
+    p1->i = p2->i;
+    p1 = p2;
+}
+
+void bar(const struct Foo *p1, const struct Foo * const p2)
+{
+    *p1 = *p2;
+    p1[0] = p2[0];
+    p1->i = p2->i;
+    p1 = p2;
+}
+
+void baz(void)
+{
+    int a9[];
+    const int a10[];
+    struct Foo f1;
+    const struct Foo f2;
+    union Bar b1;
+    const union Bar b2;
+    void v1;
+    const void v2;
+    int i1;
+    const int i2;
+}

data/share/demo/indirect_recur/indirect_recur_1.c

@@ -0,0 +1,14 @@
+#include "indirect_recur_1.h"
+#include "indirect_recur_2.h"
+
+int g;
+
+static int foo(void)
+{
+    return g;
+}
+
+int func_1(const int i)
+{
+    return func_2(g + i + foo());
+}

data/share/demo/indirect_recur/indirect_recur_1.h

@@ -0,0 +1,7 @@
+#if !defined(INDIRECT_RECUR_1_H)
+#define INDIRECT_RECUR_1_H
+
+extern int g;
+extern int func_1(const int);
+
+#endif

data/share/demo/indirect_recur/indirect_recur_2.c

@@ -0,0 +1,12 @@
+#include "indirect_recur_3.h"
+
+static int foo(const int i)
+{
+    extern int func_1(const int);
+    return func_3(i + 1) + func_1(i + 1);
+}
+
+int func_2(const int i)
+{
+    return foo(i + 1);
+}

data/share/demo/indirect_recur/indirect_recur_2.h

@@ -0,0 +1,6 @@
+#if !defined(INDIRECT_RECUR_2_H)
+#define INDIRECT_RECUR_2_H
+
+extern int func_2(const int);
+
+#endif

data/share/demo/indirect_recur/indirect_recur_3.c

@@ -0,0 +1,6 @@
+#include "indirect_recur_1.h"
+
+int func_3(const int i)
+{
+    return func_1(i + 1);
+}

data/share/demo/indirect_recur/indirect_recur_3.h

@@ -0,0 +1,6 @@
+#if !defined(INDIRECT_RECUR_3_H)
+#define INDIRECT_RECUR_3_H
+
+extern int func_3(const int);
+
+#endif

data/share/demo/indirect_recur/indirect_recur_4.c

@@ -0,0 +1,25 @@
+#include "indirect_recur_1.h"
+
+extern void exit(int);
+extern void (*signal(int, void (*)(int)))(int);
+#define SIGINT (1)
+
+static void handler(int signo)
+{
+    exit(1);
+}
+
+/*
+ * main(indirect_recur_4.c)
+ *   -> *func_1(indirect_recur_1.c) <-------+-------+
+ *        -> foo(indirect_recur_1.c)        |       |
+ *        -> *func_2(indirect_recur_2.c)    |       |
+ *             -> *foo(indirect_recur_2.c)--+       |
+ *                  -> *func_3(indirect_recur_3.c)--+
+ */
+
+int main(void)
+{
+    signal(SIGINT, handler);
+    return func_1(g);
+}

data/share/demo/intro_demo/intro_demo.c

@@ -0,0 +1,76 @@
+#include "intro_demo.h"
+#include "useless_header.h"
+
+static int foo(void)
+{
+    int i = rand();
+
+    if (i < 0) {
+        unsigned * const p = (unsigned *) malloc(sizeof(unsigned));
+        unsigned int ui;
+
+        if (p != NULL) {
+            *p = 0U;
+        }
+        /* No malloc() error handling in the else branch */
+
+        ui = *p;  /* Dereferencing a NULL pointer when malloc() failed */
+
+        switch (i) {
+        case -5:
+            i = -1;
+            ui = 0U;
+            break;
+        /* Control never reaches to this "case 10:" clause because "i" is less
+           than 0 at this point */
+        case 10:
+            ui = 100U;
+            break;
+        default:
+            ui = 0U;
+            break;
+        }
+
+        /* Control never reaches to this if-body-statement because
+         * usual-arithmetic-conversion makes "i < ui" into
+         * "(unsigned int) i < ui" and then the value of "i" which is less than
+         * 0 will be converted into a new value which is greater than 0 because
+         * of the wrap-around.
+         * So, the expression ("a value greater than 0" < 0) makes always false
+         */
+        if (i < ui) {
+            /* exit() standard function terminates this execution path */
+            exit(0);
+        }
+    }
+    else {
+        /* "i" is greater than or equal to 0 at this point */
+        unsigned j = 10 / i;
+
+        if (i < 1) {
+            j = 3 / i;  /* "i" is equal to 0 at this point */
+        }
+
+        if (i <= 0x0FFFFFFF) {
+            i <<= 3;
+        }
+        else {
+            i = i << 1;  /* "i" is greater than or equal to 0x10000000 */
+        }
+
+        /* abort() standard function terminates this execution path */
+        abort();
+    }
+
+    /* Control never reaches to this if-body-statement because "i" is less than
+       0 and not equal to -5 at this point */
+    if (i == -5) {
+        abort();
+    }
+
+    return i;
+}
+
+static inline int bar(void) { return 0; }
+
+int main(void) { return foo(); }

data/share/demo/intro_demo/intro_demo.h

@@ -0,0 +1,12 @@
+#if !defined(INTRO_DEMO_H)
+#define INTRO_DEMO_H
+
+#define NULL (0)
+
+extern int rand(void);
+extern void exit(int);
+extern void abort(void);
+extern void *malloc(int);
+extern int printf(const char *, ...);
+
+#endif

data/share/demo/intro_demo/useless_header.h

@@ -0,0 +1,5 @@
+extern struct {
+    int i;
+    int j;
+    int k;
+} hoge;

data/share/demo/invalid_call/invalid_call.c

@@ -0,0 +1,32 @@
+int baz(i)
+    const int i;
+{
+    return i;
+}
+
+int main(void)
+{
+    const short s = 0;
+    const int i = 0;
+
+    foo(s);
+    foo(i);
+    foo(s, i);
+
+    bar(s);
+    bar(i);
+    bar(s, i);
+
+    baz(s);
+    baz(i);
+    baz(s, i);
+
+    return 0;
+}
+
+extern int foo(int);
+
+static int bar(const int i)
+{
+    return i;
+}

data/share/demo/kandr_fundef/kandr_fundef.c

@@ -0,0 +1,10 @@
+extern int foo(x, y)
+    short x;
+{
+    return x + y;
+}
+
+int main(void)
+{
+    return foo(0);
+}

data/share/demo/line_comment/line_comment.c

@@ -0,0 +1,12 @@
+// line comment
+
+/*
+// block comment
+ */
+
+extern int foo(int, /* hoge */ long); // line comment
+
+int main(void)
+{
+    return foo(0, 1L); // line comment
+} // end of main

data/share/demo/local_decl/local_decl.c

@@ -0,0 +1,9 @@
+int main(void)
+{
+    extern int i;
+    extern int foo(int);
+    extern int bar();
+    static int baz(void);
+
+    return bar(foo(i));
+}

data/share/demo/logical_trick/logical_trick.c

@@ -0,0 +1,36 @@
+extern int foo(void);
+
+static inline void bar(const int x, int y)
+{
+    if ((x == 0) && (y == 0)) {
+    }
+
+    if ((x > 0) && (y++ < 0)) {
+    }
+
+    if ((x < 0) && foo()) {
+    }
+
+    {
+        int i;
+
+        i = !(x || y);
+        i = !(x | b);
+
+        i = !(x && b);
+        i = !(x & b);
+    }
+
+    {
+        int i;
+
+        i = ~((x > y) && (x > 5));
+        i = !((x > b) && (x > 5));
+    }
+}
+
+static int baz(const int x, const int y)
+{
+    (x && y) || 0;
+    return 0;
+}

data/share/demo/long_sym/long_sym.c

@@ -0,0 +1,5 @@
+extern int verylonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglongsymbol1_decl;
+extern int verylonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglongsymbol2_decl;
+
+extern int verylonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglongsymbol1_def = 0;
+extern int verylonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglongsymbol2_def = 0;

data/share/demo/loop_var/loop_var.c

@@ -0,0 +1,92 @@
+int foo(void)
+{
+    int i;
+    int ii;
+
+    for (i = 0; i < 10; i++)
+        ;
+    for (ii = 0; i < 10; i++)
+        ;
+    for (i = 0, ii = 0; ii < 10; ii++)
+        ;
+
+    return i;
+}
+
+void bar(void)
+{
+    int i;
+    int j;
+    int k = 0;
+
+    for (i = 0; i < 10; k = k + 1) {
+        i++;
+    }
+
+    for (i = 0; i < 10; i++) {
+        i++;
+    }
+
+    for (j = 0; j < 10; j++) {
+        if (j == 5) {
+            j++;
+        }
+        if (j == 15) {
+            j++;
+        }
+        if (j == -15) {
+            j++;
+        }
+    }
+
+    for (j = 0; ; j++) {
+        if (j < 0) {
+            j++;
+        }
+        if (j == 3) {
+            j++;
+        }
+        if (j == 5) {
+LABEL:
+            break;
+        }
+    }
+}
+
+void baz(void)
+{
+    int i;
+    int j = 0;
+
+    for (i = 0; i < 5; ) {
+        ++i;
+    }
+
+    for (i = 0; i < 5; j++) {
+        i++;
+    }
+
+    for (i = 0; i < 5; ++j) {
+        i++;
+    }
+
+    for (i = 0; i < 5; j--) {
+        i++;
+    }
+
+    for (i = 0; i < 5; --j) {
+        i++;
+    }
+
+    for (i = 0; i < 5; j = i + j) {
+        ++i;
+    }
+
+    for (i = 0; i < 5; j += 2) {
+        i++;
+    }
+
+    for (i = 0; i < 5; j -= 2) {
+        ++i;
+    }
+}

data/share/demo/malloc_or_die/malloc_or_die.c

@@ -0,0 +1,43 @@
+extern void *malloc(int);
+
+int main(void)
+{
+    char *p;
+
+    p = (char *) malloc(10);
+    if (p == NULL) {
+        return 2;
+    }
+    *p = (char) 1;
+
+    p = (char *) malloc(10);
+    if (p == NULL) {
+        return 2;
+    }
+    else {
+        *p = (char) 1;
+    }
+
+    p = (char *) malloc(10);
+    if (p == NULL) {
+        return 2;
+    }
+    else if (p == NULL) {
+        *p = (char) 0;
+    }
+    else {
+        *p = (char) 1;
+    }
+
+    *p = (char) 3;
+
+    p = (char *) malloc(10);
+    switch (p) {
+    case NULL:
+        return 4;
+    default:
+        *p = (char) 5;
+    }
+
+    return *p;
+}

data/share/demo/may_be_null/may_be_null.c

@@ -0,0 +1,52 @@
+#define NULL (0)
+
+extern int *may_return_null(void);
+extern int rand(void);
+
+int main(void)
+{
+    int i;
+    int *p = NULL;
+
+    i = *(int *)(NULL);
+
+    *p = 1; /* p is obviously NULL */
+
+    p = may_return_null();
+
+    *p = 2; /* p is NULL when may_return_null() returns NULL */
+
+    if (rand() == 1) {
+        p = &i;
+        *p = 3; /* p points to i in this path */
+    }
+
+    *p = 4; /* p is NULL when rand() returns != 1 */
+
+    switch (rand()) {
+    case 0:
+        p = &i;
+        break;
+    case 1:
+        p = NULL;
+        break;
+    default:
+        return 0;
+    }
+
+    *p = 5; /* p is NULL when rand() returns 1 */
+
+    for (i = 0; i < rand(); ++i) {
+        p = &i;
+    }
+
+    *p = 6; /* p is NULL when rand() returns 0 */
+
+    while (rand() < 1) {
+        p = &i;
+    }
+
+    *p = 7; /* p is NULL when rand() returns >= 1 */
+
+    return *p;
+}