Return to killdups.c CVS log

Up to [PGP] / pgp / contrib / langtool

Annotation of pgp/contrib/langtool/killdups.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *   killdups.c
                      3:  *     Remove duplicate quoted strings in a file
                      4:  *     After each outputted quoted string, adds the PLACEHOLDER
                      5:  */
                      6: 
                      7: #include <stdio.h>
                      8: #include <string.h>
                      9: #include <stdlib.h>
                     10: 
                     11: #if 0
                     12: #define        PLACEHOLDER     "No translation\n"
                     13: #else
                     14: #define        PLACEHOLDER     ""
                     15: #endif
                     16: 
                     17: struct strbuf {
                     18:        char            *s;
                     19:        struct strbuf   *l, *r;
                     20: }              *top;
                     21: 
                     22: 
                     23: main ()
                     24: {
                     25:        char    *str, *getstr();
                     26: 
                     27:        while (str = getstr()) {
                     28:                if (!inlistadd (str)) {
                     29:                        putstr (str);
                     30:                }
                     31:        }
                     32: }
                     33: 
                     34: 
                     35: char *
                     36: getstr ()
                     37: {
                     38:        static char     buf[4096];
                     39:        char            *bp;
                     40:        int             c;
                     41:        int             bslash;
                     42:        char            *sbuf;
                     43: 
                     44:        bp = buf;
                     45:        while ((c = getchar()) != EOF  &&  c != '"')
                     46:                ;
                     47:        if (c == EOF)
                     48:                return NULL;
                     49:        bslash = 0;
                     50:        while ((c = getchar()) != EOF) {
                     51:                if (bslash) {
                     52:                        *bp++ = c;
                     53:                        bslash = 0;
                     54:                } else {
                     55:                        if (c == '"')
                     56:                                break;
                     57:                        if (c == '\\')
                     58:                                bslash = 1;
                     59:                        *bp++ = c;
                     60:                }
                     61:                if (bp - buf >= sizeof(buf)) {
                     62:                        fprintf (stderr, "String too long\n");
                     63:                        exit (2);
                     64:                }
                     65:        }
                     66:        *bp++ = '\0';
                     67:        sbuf = malloc (bp - buf);
                     68:        if (!sbuf) {
                     69:                fprintf (stderr, "Out of memory\n");
                     70:                exit (1);
                     71:        }
                     72:        strcpy (sbuf, buf);
                     73:        return sbuf;
                     74: }
                     75: 
                     76: int
                     77: putstr (s)
                     78: char           *s;
                     79: {
                     80:        printf ("\"%s\"\n%s\n", s, PLACEHOLDER);
                     81: }
                     82: 
                     83: int
                     84: inlistadd (s)
                     85: char           *s;
                     86: {
                     87:        int             delta;
                     88:        struct strbuf   *list;
                     89: 
                     90:        if (top == NULL) {
                     91:                newentry (&top, s);
                     92:                return 0;
                     93:        }
                     94:        list = top;
                     95:        for ( ; ; ) {
                     96:                delta = strcmp (s, list->s);
                     97:                if (delta == 0)
                     98:                        return 1;       /* Already in list */
                     99:                if (delta > 0) {
                    100:                        if (list->r == NULL) {
                    101:                                newentry (&list->r, s);
                    102:                                return 0;
                    103:                        } else
                    104:                                list = list->r;
                    105:                } else {
                    106:                        if (list->l == NULL) {
                    107:                                newentry (&list->l, s);
                    108:                                return 0;
                    109:                        } else
                    110:                                list = list->l;
                    111:                }
                    112:        }
                    113: }
                    114: 
                    115: int
                    116: newentry (alist, s)
                    117: struct strbuf  **alist;
                    118: char           *s;
                    119: {
                    120:        *alist = (struct strbuf *)malloc (sizeof(struct strbuf));
                    121:        if (*alist == NULL) {
                    122:                fprintf (stderr, "Out of memory\n");
                    123:                exit (3);
                    124:        }
                    125:        (*alist)->s = s;
                    126:        (*alist)->l = (*alist)->r = NULL;
                    127: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.