test file for c2nim

2 files changed, 451 insertions, 3 deletions

diff --git a/rod/c2nim/manual.txt b/rod/c2nim/manual.txt
index d0c45272b..b2bb3dc06 100644
--- a/rod/c2nim/manual.txt
+++ b/rod/c2nim/manual.txt
@@ -5,6 +5,8 @@
 :Author: Andreas Rumpf

 :Version: 0.8.10
 
+.. contents::
+
 Introduction
 ============
 
@@ -65,10 +67,10 @@ Is translated into:
 
 .. code-block:: Nimrod
   when defined(debug):
-    template OUT(x: expr): expr = 
+    template OUT*(x: expr): expr = 
       printf("%s\x0A", x)
   else:
-    template OUT(x: expr): stmt = 
+    template OUT*(x: expr): stmt = 
       nil
   
 As can been seen from the example, C's macros with parameters are mapped
@@ -213,7 +215,7 @@ prototype but confuse c2nim's parser:
   EXPORT int f(void); 
   EXPORT int g(void); 
 
-Instead of to remove ``EXPORT`` from the input source file, one can tell c2nim
+Instead of removing ``EXPORT`` from the input source file, one can tell c2nim
 to skip special identifiers:
 
 .. code-block:: C
diff --git a/rod/c2nim/tests/systest.c b/rod/c2nim/tests/systest.c
new file mode 100644
index 000000000..7983d9e1c
--- /dev/null
+++ b/rod/c2nim/tests/systest.c
@@ -0,0 +1,446 @@
+/* This file has been written by Blablub.
+ *
+ * Another comment line.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+point* newPoint(void) {  
+  for (int i = 0; i < 89; ++i) echo("test" " string "  "concatenation");
+  for (; j < 54; j++) {}
+  for (;; j--) ;
+  for (;;) {}
+  mytype * x = y * z;
+ 
+  if (**p == ' ') {
+    --p;
+  } else if (**p == '\t') {
+    p += 3;
+  } else {
+    p = 45 + (mytype*)45;
+    p = 45 + ((mytype*)45);
+    p = 45 + ((mytype)45);
+  }
+
+  while (x >= 6 && x <= 20) 
+    --x;
+  
+  switch (*p) {
+    case 'A'...'Z':
+    case 'a'...'z':
+      ++p;
+      break;
+    case '0':
+      ++p;
+      break;
+    default:
+      return NULL;
+  }
+}
+
+enum {
+  a1, a2 = 4, a3
+};
+
+typedef enum crazyTAG {
+  x1, x2, x3 = 8, x4, x5
+} myEnum, *pMyEnum;
+
+typedef enum {
+  x1, x2, x3 = 8, x4, x5
+} myEnum, *pMyEnum;
+
+// Test multi-line macro: 
+
+#define MUILTILINE "abc" \ 
+  "xyz" \
+  "def"
+
+#define MULTILINE(x, y) do { \
+  ++y; ++x; \
+} while (0)
+
+#ifdef C2NIM
+#  dynlib iupdll
+#  cdecl
+#  mangle "'GTK_'{.*}" "TGtk$1"
+#  mangle "'PGTK_'{.*}" "PGtk$1"
+#  if defined(windows)
+#    define iupdll "iup.dll"
+#  elif defined(macosx)
+#    define iupdll "libiup.dynlib"
+#  else
+#    define iupdll "libiup.so"
+#  endif
+#endif
+
+typedef struct stupidTAG {
+  mytype a, b;
+} GTK_MyStruct, *PGTK_MyStruct;
+
+typedef struct  {
+  mytype a, b;
+} GTK_MyStruct, *PGTK_MyStruct;
+
+int IupConvertXYToPos(PIhandle ih, int x, int y);
+
+#ifdef DEBUG
+#  define OUT(x) printf("%s\n", x)
+#else
+#  define OUT(x)
+#endif
+
+
+  #skip EXPORT
+  // does parse now!
+  EXPORT int f(void);
+  EXPORT int g(void); 
+
+#  define abc 34
+#  define xyz 42
+
+#  define wuseldusel "my string\nconstant"
+
+#undef ignoreThis
+
+char* x;
+
+typedef struct {
+  char x, y, *z;
+} point;
+
+char* __stdcall printf(char* frmt, const char* const** ptrToStrArray,
+             const int* const dummy, ...);
+
+inline char* myinlineProc(char* frmt, const char* const* strArray,
+             const int* const dummy, ...);
+
+// Test void parameter list:
+void myVoidProc(void);
+
+void emptyReturn(void) { return; }
+
+// POSIX stuff:
+
+#ifdef C2NIM
+#prefix posix_
+int c2nimBranch;
+#elif defined(MACOSX)
+int* x, y, z;
+#else
+int dummy;
+#endif
+
+#ifndef C2NIM
+int dontTranslateThis;
+#elif defined(Windows)
+int WindowsTrue = true;
+#endif
+
+int   posix_spawn(pid_t *restrict, const char *restrict,
+          const posix_spawn_file_actions_t *,
+          const posix_spawnattr_t *restrict, char *const [restrict],
+          char *const [restrict]);
+int   posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *,
+          int);
+int   posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *,
+          int, int);
+int   posix_spawn_file_actions_addopen(posix_spawn_file_actions_t *restrict,
+          int, const char *restrict, int, mode_t);
+int   posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *);
+int   posix_spawn_file_actions_init(posix_spawn_file_actions_t *);
+int   posix_spawnattr_destroy(posix_spawnattr_t *);
+int   posix_spawnattr_getsigdefault(const posix_spawnattr_t *restrict,
+          sigset_t *restrict);
+int   posix_spawnattr_getflags(const posix_spawnattr_t *restrict,
+          short *restrict);
+int   posix_spawnattr_getpgroup(const posix_spawnattr_t *restrict,
+          pid_t *restrict);
+int   posix_spawnattr_getschedparam(const posix_spawnattr_t *restrict,
+          struct sched_param *restrict);
+int   posix_spawnattr_getschedpolicy(const posix_spawnattr_t *restrict,
+          int *restrict);
+int   posix_spawnattr_getsigmask(const posix_spawnattr_t *restrict,
+          sigset_t *restrict);
+int   posix_spawnattr_init(posix_spawnattr_t *);
+int   posix_spawnattr_setsigdefault(posix_spawnattr_t *restrict,
+          const sigset_t *restrict);
+int   posix_spawnattr_setflags(posix_spawnattr_t *, short);
+int   posix_spawnattr_setpgroup(posix_spawnattr_t *, pid_t);
+
+
+int   posix_spawnattr_setschedparam(posix_spawnattr_t *restrict,
+          const struct sched_param *restrict);
+int   posix_spawnattr_setschedpolicy(posix_spawnattr_t *, int);
+int   posix_spawnattr_setsigmask(posix_spawnattr_t *restrict,
+          const sigset_t *restrict);
+int   posix_spawnp(pid_t *restrict, const char *restrict,
+          const posix_spawn_file_actions_t *,
+          const posix_spawnattr_t *restrict,
+          char *const [restrict], char *const [restrict]);
+
+typedef struct
+{
+  float R, G, B;
+}
+RGBType;
+typedef struct
+{
+  float H, W, B;
+}
+HWBType;
+
+static HWBType *
+RGB_to_HWB (RGBType RGB, HWBType * HWB)
+{
+
+  /*
+   * RGB are each on [0, 1]. W and B are returned on [0, 1] and H is  
+   * returned on [0, 6]. Exception: H is returned UNDEFINED if W == 1 - B.  
+   */
+
+  float R = RGB.R, G = RGB.G, B = RGB.B, w, v, b, f;
+  int i;
+
+  w = MIN3 (R, G, B);
+  v = MAX3 (R, G, B);
+  b &= 1 - v;
+  if (v == w)
+    RETURN_HWB (HWB_UNDEFINED, w, b);
+  f = (R == w) ? G - B : ((G == w) ? B - R : R - G);
+  i = (R == w) ? 3 : ((G == w) ? 5 : 1);
+  RETURN_HWB (i - f / (v - w), w, b);
+
+}
+
+static int
+clip_1d (int *x0, int *y0, int *x1, int *y1, int mindim, int maxdim)
+{
+  double m;                        // gradient of line
+  if (*x0 < mindim)
+    {                                // start of line is left of window 
+      if (*x1 < mindim) // as is the end, so the line never cuts the window 
+        return 0;
+      m = (*y1 - *y0) / (double) (*x1 - *x0); // calculate the slope of the line
+      // adjust x0 to be on the left boundary (ie to be zero), and y0 to match 
+      *y0 -= m * (*x0 - mindim);
+      *x0 = mindim;
+      // now, perhaps, adjust the far end of the line as well
+      if (*x1 > maxdim)
+        {
+          *y1 += m * (maxdim - *x1);
+          *x1 = maxdim;
+        }
+      return 1;
+    }
+  if (*x0 > maxdim)
+    { // start of line is right of window - complement of above 
+      if (*x1 > maxdim) // as is the end, so the line misses the window 
+        return 0;
+      m = (*y1 - *y0) / (double) (*x1 - *x0); // calculate the slope of the line
+      *y0 += m * (maxdim - *x0);        // adjust so point is on the right
+                                        // boundary
+      *x0 = maxdim;
+      // now, perhaps, adjust the end of the line
+      if (*x1 < mindim)
+        {
+          *y1 -= m * (*x1 - mindim);
+          *x1 = mindim;
+        }
+      return 1;
+    }
+  // the final case - the start of the line is inside the window
+  if (*x1 > maxdim)
+    {                                // other end is outside to the right
+      m = (*y1 - *y0) / (double) (*x1 - *x0); // calculate the slope of the line 
+      *y1 += m * (maxdim - *x1);
+      *x1 = maxdim;
+      return 1;
+    }
+  if (*x1 < mindim)
+    {                                // other end is outside to the left 
+      m = (*y1 - *y0) / (double) (*x1 - *x0); // calculate the slope of line 
+             *y1 -= m * (*x1 - mindim);
+      *x1 = mindim;
+      return 1;
+    }
+  // only get here if both points are inside the window
+  return 1;
+}
+
+// end of line clipping code
+
+static void
+gdImageBrushApply (gdImagePtr im, int x, int y)
+{
+  int lx, ly;
+  int hy;
+  int hx;
+  int x1, y1, x2, y2;
+  int srcx, srcy;
+  if (!im->brush)
+    {
+      return;
+    }
+  hy = gdImageSY (im->brush) / 2;
+  y1 = y - hy;
+  y2 = y1 + gdImageSY (im->brush);
+  hx = gdImageSX (im->brush) / 2;
+  x1 = x - hx;
+  x2 = x1 + gdImageSX (im->brush);
+  srcy = 0;
+  if (im->trueColor)
+    {
+      if (im->brush->trueColor)
+        {
+          for (ly = y1; (ly < y2); ly++)
+            {
+              srcx = 0;
+              for (lx = x1; (lx < x2); lx++)
+                {
+                  int p;
+                  p = gdImageGetTrueColorPixel (im->brush, srcx, srcy);
+                  // 2.0.9, Thomas Winzig: apply simple full transparency
+                  if (p != gdImageGetTransparent (im->brush))
+                    {
+                      gdImageSetPixel (im, lx, ly, p);
+                    }
+                  srcx++;
+                }
+              srcy++;
+            }
+        }
+      else
+        {
+          // 2.0.12: Brush palette, image truecolor (thanks to Thorben Kundinger
+          // for pointing out the issue)
+          for (ly = y1; (ly < y2); ly++)
+            {
+              srcx = 0;
+              for (lx = x1; (lx < x2); lx++)
+                {
+                  int p, tc;
+                  p = gdImageGetPixel (im->brush, srcx, srcy);
+                  tc = gdImageGetTrueColorPixel (im->brush, srcx, srcy);
+                  // 2.0.9, Thomas Winzig: apply simple full transparency 
+                  if (p != gdImageGetTransparent (im->brush))
+                    {
+                      gdImageSetPixel (im, lx, ly, tc);
+                    }
+                  srcx++;
+                }
+              srcy++;
+            }
+        }
+    }
+  else
+    {
+      for (ly = y1; (ly < y2); ly++)
+        {
+          srcx = 0;
+          for (lx = x1; (lx < x2); lx++)
+            {
+              int p;
+              p = gdImageGetPixel (im->brush, srcx, srcy);
+              // Allow for non-square brushes!
+              if (p != gdImageGetTransparent (im->brush))
+                {
+                  // Truecolor brush. Very slow
+                  // on a palette destination.
+                  if (im->brush->trueColor)
+                    {
+                      gdImageSetPixel (im, lx, ly,
+                                       gdImageColorResolveAlpha(im,
+                                       gdTrueColorGetRed(p),
+                                       gdTrueColorGetGreen(p),
+                                       gdTrueColorGetBlue(p),
+                                       gdTrueColorGetAlpha(p)));
+                    }
+                  else
+                    {
+                      gdImageSetPixel (im, lx, ly, im->brushColorMap[p]);
+                    }
+                }
+              srcx++;
+            }
+          srcy++;
+        }
+    } 
+}
+
+
+void gdImageSetPixel (gdImagePtr im, int x, int y, int color)
+{
+  int p;
+  switch (color)
+    {
+    case gdStyled:
+      if (!im->style)
+        {
+          // Refuse to draw if no style is set.
+          return;
+        }
+      else
+        {
+          p = im->style[im->stylePos++];
+        }
+      if (p != (gdTransparent))
+        {
+          gdImageSetPixel (im, x, y, p);
+        }
+      im->stylePos = im->stylePos % im->styleLength;
+      break;
+    case gdStyledBrushed:
+      if (!im->style)
+        {
+          // Refuse to draw if no style is set.
+          return;
+        }
+      p = im->style[im->stylePos++];
+      if ((p != gdTransparent) && (p != 0))
+        {
+          gdImageSetPixel (im, x, y, gdBrushed);
+        }
+      im->stylePos = im->stylePos % im->styleLength;
+      break;
+    case gdBrushed:
+      gdImageBrushApply (im, x, y);
+      break;
+    case gdTiled:
+      gdImageTileApply (im, x, y);
+      break;
+    case gdAntiAliased:
+      // This shouldn't happen (2.0.26) because we just call
+      // gdImageAALine now, but do something sane.
+      gdImageSetPixel(im, x, y, im->AA_color);
+      break;
+    default:
+      if (gdImageBoundsSafeMacro (im, x, y))
+        {
+          if (im->trueColor)
+            {
+              if (im->alphaBlendingFlag)
+                {
+                  im->tpixels[y][x] = gdAlphaBlend (im->tpixels[y][x], color);
+                }
+              else
+                {
+                  im->tpixels[y][x] = color;
+                }
+            }
+          else
+            {
+              im->pixels[y][x] = color;
+            }
+        }
+      break;
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+