This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Increase page file quota advice in README.vms
[perl5.git] / generate_uudmap.c
index 27b142a..b5f84a7 100644 (file)
@@ -1,3 +1,39 @@
+/* generate_uudmap.c:
+
+   Create three .h files, whose names are specified as argv[1..3],
+   but are usually uudmap.h, bitcount.h and mg_data.h.
+
+   It uses mg_raw.h as input, plus it relies on the C compiler knowing
+   the ord value of character literals under EBCDIC, to generate output
+   tables on an order which are platform-specific.
+
+   The outputs are:
+
+     uudmap.h:
+         The values which will populate PL_uumap[], as used by
+         unpack('u').
+
+     bitcount.h
+          The values which will populate PL_bitcount[]:
+          this is a count of bits for each U8 value 0..255.
+          (I'm not sure why this has to be generated - surely it's
+          platform-independent - DAPM.)
+
+     mg_data.h
+          Takes the input from mg_raw.h and sorts by it magic char;
+          the values will populate PL_magic_data[]: this is an array of
+          per-magic U8 values containing an index into PL_magic_vtables[]
+          plus two flags:
+             PERL_MAGIC_READONLY_ACCEPTABLE
+             PERL_MAGIC_VALUE_MAGIC
+
+   Originally this program just generated uudmap.h
+   However, when we later wanted to generate bitcount.h, it was easier to
+   refactor it and keep the same name, than either alternative - rename it,
+   or duplicate all of the Makefile logic for a second program.
+   Ditto when mg_data.h was added.
+*/
+
 #include <stdio.h>
 #include <stdlib.h>
 /* If it turns out that we need to make this conditional on config.sh derived
    "hello world" won't port easily to it.  */
 #include <errno.h>
 
-void output_block_to_file(const char *progname, const char *filename,
-                         const char *block, size_t count) {
-  FILE *const out = fopen(filename, "w");
+struct mg_data_raw_t {
+    unsigned char type;
+    const char *value;
+    const char *comment;
+};
 
-  if (!out) {
-    fprintf(stderr, "%s: Could not open '%s': %s\n", progname, filename,
-           strerror(errno));
-    exit(1);
+static struct mg_data_raw_t mg_data_raw[] = {
+#ifdef WIN32
+#  include "..\mg_raw.h"
+#else
+#  include "mg_raw.h"
+#endif
+    {0, 0, 0}
+};
+
+struct mg_data_t {
+    const char *value;
+    const char *comment;
+};
+
+static struct mg_data_t mg_data[256];
+
+static void
+format_mg_data(FILE *out, const void *thing, size_t count) {
+  const struct mg_data_t *p = (const struct mg_data_t *)thing;
+
+  while (1) {
+      if (p->value) {
+          fprintf(out, "    %s\n    %s", p->comment, p->value);
+      } else {
+          fputs("    0", out);
+      }
+      ++p;
+      if (!--count)
+          break;
+      fputs(",\n", out);
   }
+  fputc('\n', out);
+}
+
+static void
+format_char_block(FILE *out, const void *thing, size_t count) {
+  const char *block = (const char *)thing;
 
-  fputs("{\n    ", out);
+  fputs("    ", out);
   while (count--) {
     fprintf(out, "%d", *block);
     block++;
     if (count) {
       fputs(", ", out);
       if (!(count & 15)) {
-       fputs("\n    ", out);
+        fputs("\n    ", out);
       }
     }
   }
-  fputs("\n}\n", out);
+  fputc('\n', out);
+}
+
+static void
+output_to_file(const char *progname, const char *filename,
+               void (format_function)(FILE *out, const void *thing, size_t count),
+               const void *thing, size_t count,
+               const char *header
+) {
+  FILE *const out = fopen(filename, "w");
+
+  if (!out) {
+    fprintf(stderr, "%s: Could not open '%s': %s\n", progname, filename,
+            strerror(errno));
+    exit(1);
+  }
+
+  fprintf(out, "/* %s:\n", filename);
+  fprintf(out, " * THIS FILE IS AUTO-GENERATED DURING THE BUILD by: %s\n",
+                progname);
+  fprintf(out, " *\n%s\n*/\n{\n", header);
+  format_function(out, thing, count);
+  fputs("}\n", out);
 
   if (fclose(out)) {
     fprintf(stderr, "%s: Could not close '%s': %s\n", progname, filename,
-           strerror(errno));
+            strerror(errno));
     exit(1);
   }
 }
@@ -43,14 +135,18 @@ static const char PL_uuemap[]
 
 typedef unsigned char U8;
 
-/* This will ensure it is all zeros.  */
+/* This will ensure it is initialized to all zeros.  */
 static char PL_uudmap[256];
+static char PL_bitcount[256];
 
 int main(int argc, char **argv) {
   size_t i;
+  int bits;
+  struct mg_data_raw_t *p = mg_data_raw;
 
-  if (argc < 2 || argv[1][0] == '\0') {
-    fprintf(stderr, "Usage: %s uudemap.h\n", argv[0]);
+  if (argc < 4 || argv[1][0] == '\0' || argv[2][0] == '\0'
+      || argv[3][0] == '\0') {
+    fprintf(stderr, "Usage: %s uudemap.h bitcount.h mg_data.h\n", argv[0]);
     return 1;
   }
 
@@ -62,9 +158,42 @@ int main(int argc, char **argv) {
    */
   PL_uudmap[(U8)' '] = 0;
 
-  output_block_to_file(argv[0], argv[1], PL_uudmap, sizeof(PL_uudmap));
+  output_to_file(argv[0], argv[1], &format_char_block,
+                 (const void *)PL_uudmap, sizeof(PL_uudmap),
+        " * These values will populate PL_uumap[], as used by unpack('u')"
+  );
+
+  for (bits = 1; bits < 256; bits++) {
+    if (bits & 1)      PL_bitcount[bits]++;
+    if (bits & 2)      PL_bitcount[bits]++;
+    if (bits & 4)      PL_bitcount[bits]++;
+    if (bits & 8)      PL_bitcount[bits]++;
+    if (bits & 16)     PL_bitcount[bits]++;
+    if (bits & 32)     PL_bitcount[bits]++;
+    if (bits & 64)     PL_bitcount[bits]++;
+    if (bits & 128)    PL_bitcount[bits]++;
+  }
+
+  output_to_file(argv[0], argv[2], &format_char_block,
+                 (const void *)PL_bitcount, sizeof(PL_bitcount),
+     " * These values will populate PL_bitcount[]:\n"
+     " * this is a count of bits for each U8 value 0..255"
+  );
+
+  while (p->value) {
+      mg_data[p->type].value = p->value;
+      mg_data[p->type].comment = p->comment;
+      ++p;
+  }
+      
+  output_to_file(argv[0], argv[3], &format_mg_data,
+                 (const void *)mg_data, sizeof(mg_data)/sizeof(mg_data[0]),
+     " * These values will populate PL_magic_data[]: this is an array of\n"
+     " * per-magic U8 values containing an index into PL_magic_vtables[]\n"
+     " * plus two flags:\n"
+     " *    PERL_MAGIC_READONLY_ACCEPTABLE\n"
+     " *    PERL_MAGIC_VALUE_MAGIC"
+  );
 
   return 0;
 }
-
-