Return to idsort.c CVS log

Up to [Research Unix] / researchv10no / cmd / ideal / idfilt

Annotation of researchv10no/cmd/ideal/idfilt/idsort.c, revision 1.1

1.1     ! root        1: #include "idfilt.h"
        !             2: 
        !             3: FILE *infile;
        !             4: FILE *tempfile;
        !             5: char *filename;
        !             6: int lineno = 0;
        !             7: 
        !             8: float maxx, maxy;
        !             9: float minx, miny;
        !            10: float width = 4.0;
        !            11: float colwid = 6.0;
        !            12: float xscale;
        !            13: 
        !            14: boolean maxxset, maxyset;
        !            15: boolean minxset, minyset;
        !            16: boolean widset, colset;
        !            17: boolean boundset;
        !            18: 
        !            19: boolean veryfirst = TRUE;
        !            20: 
        !            21: main (argc, argv)
        !            22: int argc;
        !            23: char *argv[];
        !            24: {
        !            25:        while (argc > 1 && argv[1][0] == '-') {
        !            26:                fprintf (stderr, "ideal filter: unknown flag %c\n", argv[1][1]);
        !            27:                argc--;
        !            28:                argv++;
        !            29:        }
        !            30:        if (argc < 2) {
        !            31:                infile = stdin;
        !            32:                lineno = 0;
        !            33:                interpret (infile);
        !            34:        } else {
        !            35:                while (argc-- > 1) {
        !            36:                        if (!(infile = fopen (*++argv, "r"))) {
        !            37:                                fprintf (stderr, "ideal sorter: can't open %s\n", *argv);
        !            38:                                exit (1);
        !            39:                        }
        !            40:                        filename = *argv;
        !            41:                        lineno = 0;
        !            42:                        interpret (infile);
        !            43:                        fclose (infile);
        !            44:                }
        !            45:        }
        !            46:        exit (0);
        !            47: }
        !            48: 
        !            49: interpret (infile)
        !            50: register FILE *infile;
        !            51: {
        !            52:        char buf[250];
        !            53: 
        !            54:        int numitems;
        !            55:        char cmd[10];
        !            56:        int i[10];
        !            57:        float f[30];
        !            58:        char *string;
        !            59:        boolean indots;
        !            60: 
        !            61: 
        !            62:        indots = FALSE;
        !            63:        while (fgets (buf, sizeof buf, infile)) {
        !            64:                if (!indots) {
        !            65:                        fputs (buf, stdout);
        !            66:                        if (strncmp(buf,".IS",3) == 0) {
        !            67:                                indots = TRUE;
        !            68:                                maxxset = minxset = maxyset = minyset = FALSE;
        !            69:                                colset = boundset = widset = FALSE;
        !            70:                                boundset = FALSE;
        !            71:                                tempfile = fopen ("jUnKfOo", "w");
        !            72:                        }
        !            73:                } else {
        !            74:                        if (strncmp(buf,"...line",7)) {
        !            75:                                if (!strncmp(buf,".IE",3) || !strncmp(buf,".IF",3)) {
        !            76:                                        idendE ();
        !            77:                                        indots = FALSE;
        !            78:                                }
        !            79:                                fputs (buf, stdout);
        !            80:                                if (!boundset) {
        !            81:                                        if (strcmp (cmd, "...maxx") == 0) {
        !            82:                                                sscanf (buf, "%s %f", cmd, &f[0]);
        !            83:                                                idmaxx (f[0]);
        !            84:                                        } else if (strcmp (cmd, "...maxy") == 0) {
        !            85:                                                sscanf (buf, "%s %f", cmd, &f[0]);
        !            86:                                                idmaxy (f[0]);
        !            87:                                        } else if (strcmp (cmd, "...minx") == 0) {
        !            88:                                                sscanf (buf, "%s %f", cmd, &f[0]);
        !            89:                                                idminx (f[0]);
        !            90:                                        } else if (strcmp (cmd, "...miny") == 0) {
        !            91:                                                sscanf (buf, "%s %f", cmd, &f[0]);
        !            92:                                                idminy (f[0]);
        !            93:                                        } else if (strcmp (cmd, "...width") == 0) {
        !            94:                                                sscanf (buf, "%s %f", cmd, &f[0]);
        !            95:                                                idwidth (f[0]);
        !            96:                                        } else if (strcmp (cmd, "...colwid") == 0) {
        !            97:                                                sscanf (buf, "%s %f", cmd, &f[0]);
        !            98:                                                idcolwid (f[0]);
        !            99:                                        } else if (strcmp (cmd, "...obbox") == 0) {
        !           100:                                                if (!veryfirst) {
        !           101:                                                        maxxset = maxyset = TRUE;
        !           102:                                                        minxset = minyset = TRUE;
        !           103:                                                        boundset = TRUE;
        !           104:                                                }
        !           105:                                        } else {
        !           106:                                                idendbound ();
        !           107:                                                veryfirst = FALSE;
        !           108:                                        }
        !           109:                                }
        !           110:                        } else {
        !           111:                                if (!boundset)
        !           112:                                        idendbound();
        !           113:                                sscanf (buf, "%s %f %f %f %f", cmd, &f[0], &f[1], &f[2], &f[3]);
        !           114:                                idline (f[0], f[1], f[2], f[3]);
        !           115:                        }
        !           116:                }
        !           117:        }
        !           118: }
        !           119: 
        !           120: void idmaxx (x)
        !           121: float x;
        !           122: {
        !           123:        if (!maxxset) {
        !           124:                maxx = x;
        !           125:                maxxset = TRUE;
        !           126:        }
        !           127: }
        !           128: 
        !           129: void idmaxy (y)
        !           130: float y;
        !           131: {
        !           132:        if (!maxyset) {
        !           133:                maxy = y;
        !           134:                maxyset = TRUE;
        !           135:        }
        !           136: }
        !           137: 
        !           138: void idminx (x)
        !           139: float x;
        !           140: {
        !           141:        if (!minxset) {
        !           142:                minx = x;
        !           143:                minxset = TRUE;
        !           144:        }
        !           145: }
        !           146: 
        !           147: void idminy (y)
        !           148: float y;
        !           149: {
        !           150:        if (!minyset) {
        !           151:                miny = y;
        !           152:                minyset = TRUE;
        !           153:        }
        !           154: }
        !           155: 
        !           156: void idwidth (wid)
        !           157: float wid;
        !           158: {
        !           159:        if (!widset) {
        !           160:                width = wid;
        !           161:                widset = TRUE;
        !           162:        }
        !           163: }
        !           164: 
        !           165: void idcolwid (wid)
        !           166: float wid;
        !           167: {
        !           168:        if (!colset) {
        !           169:                colwid = wid;
        !           170:                colset = TRUE;
        !           171:        }
        !           172: }
        !           173: 
        !           174: void idendbound ()
        !           175: {
        !           176:        if (boundset)
        !           177:                return;
        !           178:        idminx (-6.0);
        !           179:        idmaxy (6.0);
        !           180:        idmaxx (6.0);
        !           181:        idminy (-6.0);
        !           182:        if (maxx - minx < 0.2) {
        !           183:                maxx += 1;
        !           184:                minx -= 1;
        !           185:        }
        !           186:        if (maxy - miny < 0.2) {
        !           187:                maxy += 1;
        !           188:                miny -= 1;
        !           189:        }
        !           190:        xscale = width*972.0/(maxx - minx);
        !           191:        boundset = TRUE;
        !           192: }
        !           193: 
        !           194: void idendE ()
        !           195: {
        !           196:        char c;
        !           197:        fclose (tempfile);
        !           198:        system ("sort +2 -r -n -o jUnKfOo jUnKfOo");
        !           199:        tempfile = fopen ("jUnKfOo", "r");
        !           200:        while ((c = getc(tempfile)) != EOF)
        !           201:                putchar(c);
        !           202:        fclose (tempfile);
        !           203:        system ("rm jUnKfOo");
        !           204: }
        !           205: 
        !           206: 
        !           207: void idline (x1, y1, x2, y2)
        !           208: float x1, y1, x2, y2;
        !           209: {
        !           210:        double t;
        !           211:        int numsegs, i;
        !           212:        if (y1 < y2 ) {
        !           213:                t = x1;
        !           214:                x1 = x2;
        !           215:                x2 = t;
        !           216:                t = y1;
        !           217:                y1 = y2;
        !           218:                y2 = t;
        !           219:        }
        !           220:        numsegs = xscale*abs(y2-y1)/250;
        !           221:        if (numsegs <= 0) numsegs = 1;
        !           222:        for (i = 0; i < numsegs; i ++)
        !           223:                fprintf (tempfile, "...line %f %f %f %f\n",
        !           224:                        x1 + i*(x2-x1)/numsegs,
        !           225:                        y1 + i*(y2-y1)/numsegs,
        !           226:                        x1 + (i+1)*(x2-x1)/numsegs,
        !           227:                        y1 + (i+1)*(y2-y1)/numsegs
        !           228:                );
        !           229: }

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