home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 3 / AACD03.BIN / AACD / Programming / sofa / archive / exml.lha / exml / expat / gennmtab / gennmtab.c
C/C++ Source or Header  |  1999-04-13  |  10KB  |  443 lines
  1. /*
  2. The contents of this file are subject to the Mozilla Public License
  3. Version 1.0 (the "License"); you may not use this file except in
  4. compliance with the License. You may obtain a copy of the License at
  5. http://www.mozilla.org/MPL/
  6.  
  7. Software distributed under the License is distributed on an "AS IS"
  8. basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
  9. License for the specific language governing rights and limitations
  10. under the License.
  11.  
  12. The Original Code is expat.
  13.  
  14. The Initial Developer of the Original Code is James Clark.
  15. Portions created by James Clark are Copyright (C) 1998
  16. James Clark. All Rights Reserved.
  17.  
  18. Contributor(s):
  19. */
  20.  
  21. #include <string.h>
  22. #include <stdio.h>
  23. #include <stddef.h>
  24.  
  25. struct range {
  26.   int start;
  27.   int end;
  28. };
  29.  
  30. struct range nmstrt[] = {
  31.   { '_' },
  32.   { ':' },
  33.   /* BaseChar */
  34.   { 0x0041, 0x005a },
  35.   { 0x0061, 0x007a },
  36.   { 0x00c0, 0x00d6 },
  37.   { 0x00d8, 0x00f6 },
  38.   { 0x00f8, 0x00ff },
  39.   { 0x0100, 0x0131 },
  40.   { 0x0134, 0x013e },
  41.   { 0x0141, 0x0148 },
  42.   { 0x014a, 0x017e },
  43.   { 0x0180, 0x01c3 },
  44.   { 0x01cd, 0x01f0 },
  45.   { 0x01f4, 0x01f5 },
  46.   { 0x01fa, 0x0217 },
  47.   { 0x0250, 0x02a8 },
  48.   { 0x02bb, 0x02c1 },
  49.   { 0x0386 },
  50.   { 0x0388, 0x038a },
  51.   { 0x038c },
  52.   { 0x038e, 0x03a1 },
  53.   { 0x03a3, 0x03ce },
  54.   { 0x03d0, 0x03d6 },
  55.   { 0x03da },
  56.   { 0x03dc },
  57.   { 0x03de },
  58.   { 0x03e0 },
  59.   { 0x03e2, 0x03f3 },
  60.   { 0x0401, 0x040c },
  61.   { 0x040e, 0x044f },
  62.   { 0x0451, 0x045c },
  63.   { 0x045e, 0x0481 },
  64.   { 0x0490, 0x04c4 },
  65.   { 0x04c7, 0x04c8 },
  66.   { 0x04cb, 0x04cc },
  67.   { 0x04d0, 0x04eb },
  68.   { 0x04ee, 0x04f5 },
  69.   { 0x04f8, 0x04f9 },
  70.   { 0x0531, 0x0556 },
  71.   { 0x0559 },
  72.   { 0x0561, 0x0586 },
  73.   { 0x05d0, 0x05ea },
  74.   { 0x05f0, 0x05f2 },
  75.   { 0x0621, 0x063a },
  76.   { 0x0641, 0x064a },
  77.   { 0x0671, 0x06b7 },
  78.   { 0x06ba, 0x06be },
  79.   { 0x06c0, 0x06ce },
  80.   { 0x06d0, 0x06d3 },
  81.   { 0x06d5 },
  82.   { 0x06e5, 0x06e6 },
  83.   { 0x0905, 0x0939 },
  84.   { 0x093d },
  85.   { 0x0958, 0x0961 },
  86.   { 0x0985, 0x098c },
  87.   { 0x098f, 0x0990 },
  88.   { 0x0993, 0x09a8 },
  89.   { 0x09aa, 0x09b0 },
  90.   { 0x09b2 },
  91.   { 0x09b6, 0x09b9 },
  92.   { 0x09dc, 0x09dd },
  93.   { 0x09df, 0x09e1 },
  94.   { 0x09f0, 0x09f1 },
  95.   { 0x0a05, 0x0a0a },
  96.   { 0x0a0f, 0x0a10 },
  97.   { 0x0a13, 0x0a28 },
  98.   { 0x0a2a, 0x0a30 },
  99.   { 0x0a32, 0x0a33 },
  100.   { 0x0a35, 0x0a36 },
  101.   { 0x0a38, 0x0a39 },
  102.   { 0x0a59, 0x0a5c },
  103.   { 0x0a5e },
  104.   { 0x0a72, 0x0a74 },
  105.   { 0x0a85, 0x0a8b },
  106.   { 0x0a8d },
  107.   { 0x0a8f, 0x0a91 },
  108.   { 0x0a93, 0x0aa8 },
  109.   { 0x0aaa, 0x0ab0 },
  110.   { 0x0ab2, 0x0ab3 },
  111.   { 0x0ab5, 0x0ab9 },
  112.   { 0x0abd },
  113.   { 0x0ae0 },
  114.   { 0x0b05, 0x0b0c },
  115.   { 0x0b0f, 0x0b10 },
  116.   { 0x0b13, 0x0b28 },
  117.   { 0x0b2a, 0x0b30 },
  118.   { 0x0b32, 0x0b33 },
  119.   { 0x0b36, 0x0b39 },
  120.   { 0x0b3d },
  121.   { 0x0b5c, 0x0b5d },
  122.   { 0x0b5f, 0x0b61 },
  123.   { 0x0b85, 0x0b8a },
  124.   { 0x0b8e, 0x0b90 },
  125.   { 0x0b92, 0x0b95 },
  126.   { 0x0b99, 0x0b9a },
  127.   { 0x0b9c },
  128.   { 0x0b9e, 0x0b9f },
  129.   { 0x0ba3, 0x0ba4 },
  130.   { 0x0ba8, 0x0baa },
  131.   { 0x0bae, 0x0bb5 },
  132.   { 0x0bb7, 0x0bb9 },
  133.   { 0x0c05, 0x0c0c },
  134.   { 0x0c0e, 0x0c10 },
  135.   { 0x0c12, 0x0c28 },
  136.   { 0x0c2a, 0x0c33 },
  137.   { 0x0c35, 0x0c39 },
  138.   { 0x0c60, 0x0c61 },
  139.   { 0x0c85, 0x0c8c },
  140.   { 0x0c8e, 0x0c90 },
  141.   { 0x0c92, 0x0ca8 },
  142.   { 0x0caa, 0x0cb3 },
  143.   { 0x0cb5, 0x0cb9 },
  144.   { 0x0cde },
  145.   { 0x0ce0, 0x0ce1 },
  146.   { 0x0d05, 0x0d0c },
  147.   { 0x0d0e, 0x0d10 },
  148.   { 0x0d12, 0x0d28 },
  149.   { 0x0d2a, 0x0d39 },
  150.   { 0x0d60, 0x0d61 },
  151.   { 0x0e01, 0x0e2e },
  152.   { 0x0e30 },
  153.   { 0x0e32, 0x0e33 },
  154.   { 0x0e40, 0x0e45 },
  155.   { 0x0e81, 0x0e82 },
  156.   { 0x0e84 },
  157.   { 0x0e87, 0x0e88 },
  158.   { 0x0e8a },
  159.   { 0x0e8d },
  160.   { 0x0e94, 0x0e97 },
  161.   { 0x0e99, 0x0e9f },
  162.   { 0x0ea1, 0x0ea3 },
  163.   { 0x0ea5 },
  164.   { 0x0ea7 },
  165.   { 0x0eaa, 0x0eab },
  166.   { 0x0ead, 0x0eae },
  167.   { 0x0eb0 },
  168.   { 0x0eb2, 0x0eb3 },
  169.   { 0x0ebd },
  170.   { 0x0ec0, 0x0ec4 },
  171.   { 0x0f40, 0x0f47 },
  172.   { 0x0f49, 0x0f69 },
  173.   { 0x10a0, 0x10c5 },
  174.   { 0x10d0, 0x10f6 },
  175.   { 0x1100 },
  176.   { 0x1102, 0x1103 },
  177.   { 0x1105, 0x1107 },
  178.   { 0x1109 },
  179.   { 0x110b, 0x110c },
  180.   { 0x110e, 0x1112 },
  181.   { 0x113c },
  182.   { 0x113e },
  183.   { 0x1140 },
  184.   { 0x114c },
  185.   { 0x114e },
  186.   { 0x1150 },
  187.   { 0x1154, 0x1155 },
  188.   { 0x1159 },
  189.   { 0x115f, 0x1161 },
  190.   { 0x1163 },
  191.   { 0x1165 },
  192.   { 0x1167 },
  193.   { 0x1169 },
  194.   { 0x116d, 0x116e },
  195.   { 0x1172, 0x1173 },
  196.   { 0x1175 },
  197.   { 0x119e },
  198.   { 0x11a8 },
  199.   { 0x11ab },
  200.   { 0x11ae, 0x11af },
  201.   { 0x11b7, 0x11b8 },
  202.   { 0x11ba },
  203.   { 0x11bc, 0x11c2 },
  204.   { 0x11eb },
  205.   { 0x11f0 },
  206.   { 0x11f9 },
  207.   { 0x1e00, 0x1e9b },
  208.   { 0x1ea0, 0x1ef9 },
  209.   { 0x1f00, 0x1f15 },
  210.   { 0x1f18, 0x1f1d },
  211.   { 0x1f20, 0x1f45 },
  212.   { 0x1f48, 0x1f4d },
  213.   { 0x1f50, 0x1f57 },
  214.   { 0x1f59 },
  215.   { 0x1f5b },
  216.   { 0x1f5d },
  217.   { 0x1f5f, 0x1f7d },
  218.   { 0x1f80, 0x1fb4 },
  219.   { 0x1fb6, 0x1fbc },
  220.   { 0x1fbe },
  221.   { 0x1fc2, 0x1fc4 },
  222.   { 0x1fc6, 0x1fcc },
  223.   { 0x1fd0, 0x1fd3 },
  224.   { 0x1fd6, 0x1fdb },
  225.   { 0x1fe0, 0x1fec },
  226.   { 0x1ff2, 0x1ff4 },
  227.   { 0x1ff6, 0x1ffc },
  228.   { 0x2126 },
  229.   { 0x212a, 0x212b },
  230.   { 0x212e },
  231.   { 0x2180, 0x2182 },
  232.   { 0x3041, 0x3094 },
  233.   { 0x30a1, 0x30fa },
  234.   { 0x3105, 0x312c },
  235.   { 0xac00, 0xd7a3 },
  236.   /* Ideographic */
  237.   { 0x4e00, 0x9fa5 },
  238.   { 0x3007 },
  239.   { 0x3021, 0x3029 },
  240. };
  241.  
  242. /* name chars that are not name start chars */
  243. struct range name[] = {
  244.   { '.' },
  245.   { '-' },
  246.   /* CombiningChar */
  247.   { 0x0300, 0x0345 },
  248.   { 0x0360, 0x0361 },
  249.   { 0x0483, 0x0486 },
  250.   { 0x0591, 0x05a1 },
  251.   { 0x05a3, 0x05b9 },
  252.   { 0x05bb, 0x05bd },
  253.   { 0x05bf },
  254.   { 0x05c1, 0x05c2 },
  255.   { 0x05c4 },
  256.   { 0x064b, 0x0652 },
  257.   { 0x0670 },
  258.   { 0x06d6, 0x06dc },
  259.   { 0x06dd, 0x06df },
  260.   { 0x06e0, 0x06e4 },
  261.   { 0x06e7, 0x06e8 },
  262.   { 0x06ea, 0x06ed },
  263.   { 0x0901, 0x0903 },
  264.   { 0x093c },
  265.   { 0x093e, 0x094c },
  266.   { 0x094d },
  267.   { 0x0951, 0x0954 },
  268.   { 0x0962, 0x0963 },
  269.   { 0x0981, 0x0983 },
  270.   { 0x09bc },
  271.   { 0x09be },
  272.   { 0x09bf },
  273.   { 0x09c0, 0x09c4 },
  274.   { 0x09c7, 0x09c8 },
  275.   { 0x09cb, 0x09cd },
  276.   { 0x09d7 },
  277.   { 0x09e2, 0x09e3 },
  278.   { 0x0a02 },
  279.   { 0x0a3c },
  280.   { 0x0a3e },
  281.   { 0x0a3f },
  282.   { 0x0a40, 0x0a42 },
  283.   { 0x0a47, 0x0a48 },
  284.   { 0x0a4b, 0x0a4d },
  285.   { 0x0a70, 0x0a71 },
  286.   { 0x0a81, 0x0a83 },
  287.   { 0x0abc },
  288.   { 0x0abe, 0x0ac5 },
  289.   { 0x0ac7, 0x0ac9 },
  290.   { 0x0acb, 0x0acd },
  291.   { 0x0b01, 0x0b03 },
  292.   { 0x0b3c },
  293.   { 0x0b3e, 0x0b43 },
  294.   { 0x0b47, 0x0b48 },
  295.   { 0x0b4b, 0x0b4d },
  296.   { 0x0b56, 0x0b57 },
  297.   { 0x0b82, 0x0b83 },
  298.   { 0x0bbe, 0x0bc2 },
  299.   { 0x0bc6, 0x0bc8 },
  300.   { 0x0bca, 0x0bcd },
  301.   { 0x0bd7 },
  302.   { 0x0c01, 0x0c03 },
  303.   { 0x0c3e, 0x0c44 },
  304.   { 0x0c46, 0x0c48 },
  305.   { 0x0c4a, 0x0c4d },
  306.   { 0x0c55, 0x0c56 },
  307.   { 0x0c82, 0x0c83 },
  308.   { 0x0cbe, 0x0cc4 },
  309.   { 0x0cc6, 0x0cc8 },
  310.   { 0x0cca, 0x0ccd },
  311.   { 0x0cd5, 0x0cd6 },
  312.   { 0x0d02, 0x0d03 },
  313.   { 0x0d3e, 0x0d43 },
  314.   { 0x0d46, 0x0d48 },
  315.   { 0x0d4a, 0x0d4d },
  316.   { 0x0d57 },
  317.   { 0x0e31 },
  318.   { 0x0e34, 0x0e3a },
  319.   { 0x0e47, 0x0e4e },
  320.   { 0x0eb1 },
  321.   { 0x0eb4, 0x0eb9 },
  322.   { 0x0ebb, 0x0ebc },
  323.   { 0x0ec8, 0x0ecd },
  324.   { 0x0f18, 0x0f19 },
  325.   { 0x0f35 },
  326.   { 0x0f37 },
  327.   { 0x0f39 },
  328.   { 0x0f3e },
  329.   { 0x0f3f },
  330.   { 0x0f71, 0x0f84 },
  331.   { 0x0f86, 0x0f8b },
  332.   { 0x0f90, 0x0f95 },
  333.   { 0x0f97 },
  334.   { 0x0f99, 0x0fad },
  335.   { 0x0fb1, 0x0fb7 },
  336.   { 0x0fb9 },
  337.   { 0x20d0, 0x20dc },
  338.   { 0x20e1 },
  339.   { 0x302a, 0x302f },
  340.   { 0x3099 },
  341.   { 0x309a },
  342.   /* Digit */
  343.   { 0x0030, 0x0039 },
  344.   { 0x0660, 0x0669 },
  345.   { 0x06f0, 0x06f9 },
  346.   { 0x0966, 0x096f },
  347.   { 0x09e6, 0x09ef },
  348.   { 0x0a66, 0x0a6f },
  349.   { 0x0ae6, 0x0aef },
  350.   { 0x0b66, 0x0b6f },
  351.   { 0x0be7, 0x0bef },
  352.   { 0x0c66, 0x0c6f },
  353.   { 0x0ce6, 0x0cef },
  354.   { 0x0d66, 0x0d6f },
  355.   { 0x0e50, 0x0e59 },
  356.   { 0x0ed0, 0x0ed9 },
  357.   { 0x0f20, 0x0f29 },
  358.   /* Extender */
  359.   { 0xb7 },
  360.   { 0x02d0 },
  361.   { 0x02d1 },
  362.   { 0x0387 },
  363.   { 0x0640 },
  364.   { 0x0e46 },
  365.   { 0x0ec6 },
  366.   { 0x3005 },
  367.   { 0x3031, 0x3035 },
  368.   { 0x309d, 0x309e },
  369.   { 0x30fc, 0x30fe },
  370. };
  371.  
  372. void setTab(char *tab, struct range *ranges, size_t nRanges)
  373. {
  374.   size_t i;
  375.   int j;
  376.   for (i = 0; i < nRanges; i++) {
  377.     if (ranges[i].end) {
  378.       for (j = ranges[i].start; j <= ranges[i].end; j++)
  379.     tab[j] = 1;
  380.     }
  381.     else
  382.       tab[ranges[i].start] = 1;
  383.   }
  384. }
  385.  
  386. void printTabs(char *tab)
  387. { 
  388.   int nBitmaps = 2;
  389.   int i, j, k;
  390.   unsigned char pageIndex[512];
  391.  
  392.   printf(
  393. "static const unsigned namingBitmap[] = {\n\
  394. 0x00000000, 0x00000000, 0x00000000, 0x00000000,\n\
  395. 0x00000000, 0x00000000, 0x00000000, 0x00000000,\n\
  396. 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,\n\
  397. 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,\n");
  398.   for (i = 0; i < 512; i++) {
  399.     int kind = tab[i*256];
  400.     for (j = 1; j < 256; j++)
  401.       if (tab[i*256 +j] != kind) {
  402.     kind = -1;
  403.     break;
  404.       }
  405.     if (i >= 256 &&  memcmp(tab + (i - 256)*256, tab + i*256, 256) == 0)
  406.       pageIndex[i] = pageIndex[i - 256];
  407.     else if (kind == -1) { 
  408.       pageIndex[i] = nBitmaps++;
  409.       for (j = 0; j < 8; j++) {
  410.     unsigned val = 0;
  411.     for (k = 0; k < 32; k++) {
  412.       if (tab[i*256 + j*32 +k])
  413.         val |= (1 << k);
  414.     }
  415.     printf("0x%08X,", val);
  416.     putchar((((j + 1) & 3) == 0) ? '\n' : ' ');
  417.       }
  418.     }
  419.     else
  420.       pageIndex[i] = kind;
  421.   }
  422.   printf("};\n");
  423.   printf("static const unsigned char nmstrtPages[] = {\n");
  424.   for (i = 0; i < 512; i++) {
  425.     if (i == 256)
  426.       printf("};\nstatic const unsigned char namePages[] = {\n");
  427.     printf("0x%02X,", pageIndex[i]);
  428.     putchar((((i + 1) & 7) == 0) ? '\n' : ' ');
  429.   }
  430.   printf("};\n");
  431. }
  432.  
  433. int main()
  434. { 
  435.   char tab[2*65536];
  436.   memset(tab, 0, 65536);
  437.   setTab(tab, nmstrt, sizeof(nmstrt)/sizeof(nmstrt[0]));
  438.   memcpy(tab + 65536, tab, 65536);
  439.   setTab(tab + 65536, name, sizeof(name)/sizeof(name[0]));
  440.   printTabs(tab);
  441.   return 0;
  442. }
  443.