Return to fixstack.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin

Annotation of coherent/d/bin/fixstack.c, revision 1.1

1.1     ! root        1: /* fix stack on l.out type file
        !             2:  * first parm is the amount to add or subtract in hex
        !             3:  * the second parm is the l.out file name default "l.out"
        !             4:  */
        !             5: #include <stdio.h>
        !             6: #include <l.out.h>
        !             7: #include <canon.h>
        !             8: #include <mtype.h>
        !             9: main (argc, argv)
        !            10: char   *argv[];
        !            11: {
        !            12:        FILE *lout;
        !            13:        char *argp, c, negsw=0;
        !            14:        long hexno=0;
        !            15: 
        !            16:        if(--argc > 0) {
        !            17:                argp = *++argv;
        !            18:                while((c = *argp++) != '\0') {
        !            19:                        switch(c) {
        !            20:                                case '-' :
        !            21:                                        negsw=1;
        !            22:                                        break;
        !            23:                                case '+' :
        !            24:                                        negsw=0;
        !            25:                                        break;
        !            26:                                case '0' :
        !            27:                                case '1' :
        !            28:                                case '2' :
        !            29:                                case '3' :
        !            30:                                case '4' :
        !            31:                                case '5' :
        !            32:                                case '6' :
        !            33:                                case '7' :
        !            34:                                case '8' :
        !            35:                                case '9' :
        !            36:                                        hexno<<=4;
        !            37:                                        hexno+=(c-'0');
        !            38:                                        break;
        !            39:                                case 'a' :
        !            40:                                case 'b' :
        !            41:                                case 'c' :
        !            42:                                case 'd' :
        !            43:                                case 'e' :
        !            44:                                case 'f' :
        !            45:                                        hexno<<=4;
        !            46:                                        hexno+=(c-'a'+10);
        !            47:                                        break;
        !            48:                                case 'A' :
        !            49:                                case 'B' :
        !            50:                                case 'C' :
        !            51:                                case 'D' :
        !            52:                                case 'E' :
        !            53:                                case 'F' :
        !            54:                                        hexno<<=4;
        !            55:                                        hexno+=(c-'A'+10);
        !            56:                                        break;
        !            57:                                default:
        !            58:                                        usage();
        !            59:                        }
        !            60:                }
        !            61:        } else
        !            62:                usage();
        !            63: 
        !            64:        if(negsw)
        !            65:                hexno= -hexno;
        !            66: 
        !            67:        if(--argc > 0)
        !            68:                argp=*++argv;
        !            69:        else
        !            70:                argp="l.out";
        !            71: 
        !            72:        if(NULL==(lout=fopen(argp, "rw"))) {
        !            73:                fprintf(stderr, "fixstack: %s cannot open \n", argp);
        !            74:                exit(1);
        !            75:        }
        !            76: 
        !            77:        proscess(hexno, lout, argp);
        !            78:        exit(0);
        !            79: }
        !            80: 
        !            81: proscess(hexno, lout, argp)
        !            82: long hexno;
        !            83: FILE *lout;
        !            84: char *argp;
        !            85: {
        !            86:        long where;
        !            87:        struct ldheader head;
        !            88: 
        !            89:        where=ftell(lout);      /* not zero on some systems */
        !            90:        if(0 == (fread(&head, sizeof(head), 1, lout))) {
        !            91:                fprintf(stderr, "fixstack: error in read\n");
        !            92:                exit(1);
        !            93:        }
        !            94: 
        !            95:        if(fseek(lout, where, 0)) {
        !            96:                fprintf(stderr, "fixstack: error in seek\n");
        !            97:                exit(1);
        !            98:        }
        !            99: 
        !           100:        canshort(head.l_magic);
        !           101:        if(head.l_magic!=L_MAGIC) {
        !           102:                fprintf(stderr, "fixstack: %s not an l.out file %x\n",
        !           103:                        argp, head.l_magic );
        !           104:                exit(1);
        !           105:        }
        !           106:        
        !           107:        cansize(head.l_ssize[L_BSSD]);
        !           108:        head.l_ssize[L_BSSD] += hexno;
        !           109:        cansize(head.l_ssize[L_BSSD]);
        !           110: 
        !           111:        if(1 != (fwrite(&head, sizeof(head), 1, lout))) {
        !           112:                fprintf(stderr, "fixstack: error in write\n");
        !           113:                exit(1);
        !           114:        }
        !           115: }
        !           116: 
        !           117: usage()
        !           118: {
        !           119:        fprintf(stderr, "Usage: fixstack hexno filen.\n");
        !           120:        exit(1);
        !           121: }

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