/*
*******************************************************************************
*
*   Copyright (C) 2000, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   file name:  gbmake4.c
*   encoding:   US-ASCII
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2000oct19
*   created by: Markus W. Scherer
*
*   This tool reads and processes codepage mapping files for GB 18030.
*   Its main function is to read a mapping table with the one- and two-byte
*   mappings of GB 18030 and to then output a mapping table with all of the
*   four-byte mappings for the BMP.
*   Four-byte mappings that are included in the input are skipped in the output.
*   When an "r" argument is specified, it will instead write a list of
*   ranges of contiguous mappings where both Unicode code points and GB 18030
*   four-byte sequences form contiguous blocks.
*   This kind of output can be appended to a mapping table with a "ranges" line
*   in between, and the resulting output will exclude the input ranges.
*   This is useful for generating a partial mapping table and to handle the input
*   ranges algorithmically in conversion.
*
*   Single surrogates are excluded from the output.
*
*   To compile, just call a C compiler/linker with this source file.
*   On Windows: cl gbmake4.c
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* array of flags for each Unicode BMP code point */
static char
flags[0x10000]={ 0 };

/* flag values: 0: not assigned  1:from Unicode  2:to Unicode  4:four-byte sequence */
#define UNASSIGNED  0
#define FROMU       1
#define TOU         2
#define ROUNDTRIP   3
#define FOURBYTE    4

static void
incFourGB18030(unsigned char bytes[4]) {
    if(bytes[3]<0x39) {
        ++bytes[3];
    } else {
        bytes[3]=0x30;
        if(bytes[2]<0xfe) {
            ++bytes[2];
        } else {
            bytes[2]=0x81;
            if(bytes[1]<0x39) {
                ++bytes[1];
            } else {
                bytes[1]=0x30;
                ++bytes[0];
            }
        }
    }
}

static int
readRanges() {
    char line[200];
    char *s, *end;
    unsigned long c1, c2;

    /* parse the input file from stdin, in the format of gbkuni30.txt */
    while(gets(line)!=NULL) {
        /* skip empty and comment lines */
        if(line[0]==0 || line[0]=='#') {
            continue;
        }

        /* find the Unicode code point range */
        s=strstr(line, "U+");
        if(s==NULL) {
            fprintf(stderr, "error parsing range from \"%s\"\n", line);
            return 1;
        }

        /* read range */
        s+=2;
        c1=strtoul(s, &end, 16);
        if(end==s || *end!='-') {
            fprintf(stderr, "error parsing range start from \"%s\"\n", line);
            return 1;
        }

        s=end+1;
        c2=strtoul(s, &end, 16);
        if(end==s || *end!=' ' && *end!=0) {
            fprintf(stderr, "error parsing range end from \"%s\"\n", line);
            return 1;
        }

        /* ignore ranges above the BMP */
        if(c2>0xffff) {
            c2=0xffff;
        }

        /* set the flags for all code points in this range */
        while(c1<=c2) {
            if(flags[c1]!=UNASSIGNED) {
                fprintf(stderr, "error: range covers already-assigned U+%04lX\n", c1);
                return 1;
            }
            flags[c1++]=ROUNDTRIP|FOURBYTE;
        }
    }

    return 0;
}

extern int
main(int argc, const char *argv[]) {
    char line[200];
    char *end;
    unsigned long c, b;
    unsigned char bytes[4]={ 0x81, 0x30, 0x81, 0x30 };
    char flag;

    /* parse the input file from stdin, in the format of gbkuni30.txt */
    while(gets(line)!=NULL) {
        /* skip empty and comment lines */
        if(line[0]==0 || line[0]=='#' || line[0]==0x1a) {
            continue;
        }

        /* end of code points, beginning of ranges? */
        if(0==strcmp(line, "ranges")) {
            int result=readRanges();
            if(result!=0) {
                return result;
            }
            break;
        }

        /* read Unicode code point */
        c=strtoul(line, &end, 16);
        if(end==line) {
            fprintf(stderr, "error: missing code point in \"%s\"\n", line);
            return 1;
        }
        if(*end==':') {
            flag=ROUNDTRIP;
        } else if(*end=='>') {
            flag=FROMU;
        } else if(*end=='<') {
            flag=TOU;
        } else {
            fprintf(stderr, "error: delimiter not one of :>< in \"%s\"\n", line);
            return 1;
        }

        /* ignore non-BMP code points */
        if(c>0xffff) {
            continue;
        }

        /* read byte sequence as one long value */
        b=strtoul(end+1, &end, 16);
        if(*end!=0 && *end!='*') {
            fprintf(stderr, "error parsing byte sequence from \"%s\"\n", line);
            return 1;
        }
        if(b>0xffff) {
            flag|=FOURBYTE;
        }

        /* set the flag for the code point, make sure the mapping from Unicode is not duplicate */
        if((flags[c]&flag&FROMU)!=0) {
            fprintf(stderr, "error: duplicate assignment for U+%04lX, old flags %u, new %s\n", c, flags[c], line);
            return 1;
        }
        flags[c]|=flag;
    }

    if(argc<=1) {
        /* generate all four-byte sequences that are not already in the input */
        for(c=0x80; c<=0xffff; ++c) {
            /* skip single surrogates */
            if(c==0xd800) {
                c=0xe000;
            }
            if(flags[c]==UNASSIGNED) {
                printf("%04lX:%02X%02X%02X%02X\n", c, bytes[0], bytes[1], bytes[2], bytes[3]);
                /* increment the sequence for the next code point */
                incFourGB18030(bytes);
            } else if(flags[c]&FOURBYTE) {
                /* increment the four-byte sequence for each already-used four-byte sequence */
                incFourGB18030(bytes);
            }
        }
    } else if(0==strcmp(argv[1], "r")) {
        /* generate ranges of contiguous code points with four-byte sequences for what is not covered by the input */
        unsigned char b1[4], b2[4];
        unsigned long c1, c2;

        printf("ranges\n");
        for(c1=0x80; c1<=0xffff;) {
            /* skip single surrogates */
            if(c1==0xd800) {
                c1=0xe000;
            }

            /* get start bytes of range */
            memcpy(b1, bytes, 4);

            /* look for the first non-range code point */
            for(c2=c1; c2<=0xffff && flags[c2]==UNASSIGNED && c2!=0xd800; ++c2) {
                /* save this sequence to avoid decrementing it after this loop */
                memcpy(b2, bytes, 4);
                /* increment the sequence for the next code point */
                incFourGB18030(bytes);
            }
            /* c2 is the first code point after the range; b2 are the bytes for the last code point in the range */

            /* print this range, number of codes first for easy sorting */
            printf("%06lX  U+%04lX-%04lX  GB+%02X%02X%02X%02X-%02X%02X%02X%02X\n",
                c2-c1, c1, c2-1,
                b1[0], b1[1], b1[2], b1[3],
                b2[0], b2[1], b2[2], b2[3]);

            /* skip single surrogates */
            if(c2==0xd800) {
                c2=0xe000;
            }

            /* skip all assigned Unicode BMP code points */
            for(c1=c2; c1<=0xffff && flags[c1]!=UNASSIGNED; ++c1) {
                if(flags[c1]&FOURBYTE) {
                    /* increment the four-byte sequence for each already-used four-byte sequence */
                    incFourGB18030(bytes);
                }
            }
        }
    } else {
        fprintf(stderr, "unknown mode argument \"%s\"\n", argv[1]);
        return 2;
    }

    return 0;
}