xlators/experimental: move template files to '.c.in' type

This is critical because we shouldn't be applying the automated
coding standard (clang-format) tool on these files.

This patchset is done by below steps:

* clang-format -i ${filename}

This creates syntax errors. Fix them using below two commands:
* sed -i -e 's/ @/@/g' ${filename}
* sed -i -e 's/,@/, @/g' ${filename}

With this, these files are having minimum changes requried to
compile, and is as close to the coding standard as possible.

* git rename ${filename} ${filename}.in

Updates: bz#1564149
Change-Id: Icf90f7f81d6fa4400be4826e094fdff8e64508d0
Signed-off-by: Amar Tumballi <amarts@redhat.com>

1 files changed, 177 insertions, 0 deletions

diff --git a/xlators/experimental/fdl/src/dump-tmpl.c.in b/xlators/experimental/fdl/src/dump-tmpl.c.in
new file mode 100644
index 00000000000..97249ac3e71
--- /dev/null
+++ b/xlators/experimental/fdl/src/dump-tmpl.c.in
@@ -0,0 +1,177 @@
+#pragma fragment PROLOG
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#include <ctype.h>
+#endif
+
+#include "glfs.h"
+#include "iatt.h"
+#include "xlator.h"
+#include "fdl.h"
+
+/*
+ * Returns 0 if the string is ASCII printable *
+ * and -1 if it's not ASCII printable         *
+ */
+int
+str_isprint(char *s)
+{
+    int ret = -1;
+
+    if (!s)
+        goto out;
+
+    while (s[0] != '\0') {
+        if (!isprint(s[0]))
+            goto out;
+        else
+            s++;
+    }
+
+    ret = 0;
+out:
+    return ret;
+}
+
+#pragma fragment DICT
+{
+    int key_len, data_len;
+    char *key_ptr;
+    char *key_val;
+    printf("@ARGNAME@ = dict {\n");
+    for (;;) {
+        key_len = *((int *)new_meta);
+        new_meta += sizeof(int);
+        if (!key_len) {
+            break;
+        }
+        key_ptr = new_meta;
+        new_meta += key_len;
+        data_len = *((int *)new_meta);
+        key_val = new_meta + sizeof(int);
+        new_meta += sizeof(int) + data_len;
+        if (str_isprint(key_val))
+            printf(" %s = <%d bytes>\n", key_ptr, data_len);
+        else
+            printf(" %s = %s <%d bytes>\n", key_ptr, key_val, data_len);
+    }
+    printf("}\n");
+}
+
+#pragma fragment DOUBLE
+printf("@ARGNAME@ = @FORMAT@\n", *((uint64_t *)new_meta),
+       *((uint64_t *)new_meta));
+new_meta += sizeof(uint64_t);
+
+#pragma fragment GFID
+printf("@ARGNAME@ = <gfid %s>\n", uuid_utoa(*((uuid_t *)new_meta)));
+new_meta += 16;
+
+#pragma fragment INTEGER
+printf("@ARGNAME@ = @FORMAT@\n", *((uint32_t *)new_meta),
+       *((uint32_t *)new_meta));
+new_meta += sizeof(uint32_t);
+
+#pragma fragment LOC
+printf("@ARGNAME@ = loc {\n");
+printf("  gfid = %s\n", uuid_utoa(*((uuid_t *)new_meta)));
+new_meta += 16;
+printf("  pargfid = %s\n", uuid_utoa(*((uuid_t *)new_meta)));
+new_meta += 16;
+if (*(new_meta++)) {
+    printf("  name = %s\n", new_meta);
+    new_meta += (strlen(new_meta) + 1);
+}
+printf("}\n");
+
+#pragma fragment STRING
+if (*(new_meta++)) {
+    printf("@ARGNAME@ = %s\n", new_meta);
+    new_meta += (strlen(new_meta) + 1);
+}
+
+#pragma fragment VECTOR
+{
+    size_t len = *((size_t *)new_meta);
+    new_meta += sizeof(len);
+    printf("@ARGNAME@ = <%zu bytes>\n", len);
+    new_data += len;
+}
+
+#pragma fragment IATT
+{
+    ia_prot_t *myprot = ((ia_prot_t *)new_meta);
+    printf("@ARGNAME@ = iatt {\n");
+    printf("  ia_prot = %c%c%c", myprot->suid ? 'S' : '-',
+           myprot->sgid ? 'S' : '-', myprot->sticky ? 'T' : '-');
+    printf("%c%c%c", myprot->owner.read ? 'r' : '-',
+           myprot->owner.write ? 'w' : '-', myprot->owner.exec ? 'x' : '-');
+    printf("%c%c%c", myprot->group.read ? 'r' : '-',
+           myprot->group.write ? 'w' : '-', myprot->group.exec ? 'x' : '-');
+    printf("%c%c%c\n", myprot->other.read ? 'r' : '-',
+           myprot->other.write ? 'w' : '-', myprot->other.exec ? 'x' : '-');
+    new_meta += sizeof(ia_prot_t);
+    uint32_t *myints = (uint32_t *)new_meta;
+    printf("  ia_uid = %u\n", myints[0]);
+    printf("  ia_gid = %u\n", myints[1]);
+    printf("  ia_atime = %u.%09u\n", myints[2], myints[3]);
+    printf("  ia_mtime = %u.%09u\n", myints[4], myints[5]);
+    new_meta += sizeof(*myints) * 6;
+}
+
+#pragma fragment FOP
+void fdl_dump_@NAME@(char **old_meta, char **old_data)
+{
+    char *new_meta = *old_meta;
+    char *new_data = *old_data;
+
+    /* TBD: word size/endianness */
+    @FUNCTION_BODY@
+
+    *old_meta = new_meta;
+    *old_data = new_data;
+}
+
+#pragma fragment CASE
+case GF_FOP_@UPNAME@:
+    printf("=== GF_FOP_@UPNAME@\n");
+    fdl_dump_@NAME@(&new_meta, &new_data);
+    break;
+
+#pragma fragment EPILOG
+    int
+    fdl_dump(char **old_meta, char **old_data)
+    {
+        char *new_meta = *old_meta;
+        char *new_data = *old_data;
+        static glfs_t *fs = NULL;
+        int recognized = 1;
+        event_header_t *eh;
+
+        /*
+         * We don't really call anything else in GFAPI, but this is the most
+         * convenient way to satisfy all of the spurious dependencies on how it
+         * or glusterfsd initialize (e.g. setting up THIS).
+         */
+        if (!fs) {
+            fs = glfs_new("dummy");
+        }
+
+        eh = (event_header_t *)new_meta;
+        new_meta += sizeof(*eh);
+
+        /* TBD: check event_type instead of assuming NEW_REQUEST */
+
+        switch (eh->fop_type) {
+            @SWITCH_BODY@
+
+            default :
+                printf("unknown fop %u\n", eh->fop_type);
+                recognized = 0;
+        }
+
+        *old_meta = new_meta;
+        *old_data = new_data;
+        return recognized;
+    }