0.3.6.2/experiments/sgiprom_to_bin.c

/*
 *  Copyright (C) 2004-2005  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: sgiprom_to_bin.c,v 1.5 2005/02/21 07:18:10 debug Exp $
 *
 *  sgiprom_to_bin.c
 *
 *  This program takes a textfile containing a SGI PROM memory dump of
 *  the following format:
 *
 *      >> dump -b 0xBFC00000:0xBFCF0000
 *      0xbfc00000:    b   f0    0   f0    0    0    0    0
 *      0xbfc00008:    b   f0    1   f6    0    0    0    0
 *      SAME
 *      0xbfc00200:    b   f0    3   c9    0    0    0    0
 *      0xbfc00208:    b   f0    1   f6    0    0    0    0
 *      SAME
 *      0xbfc00280:    b   f0    3   cb    0    0    0    0
 *      ..
 *
 *  and turns it into a binary image.  Input is read from stdin.
 */

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define MAX     200


int main(int argc, char *argv[])
{
        FILE *f;
        unsigned char previous_line[8];
        int same_flag = 0;
        off_t same_start_offset = 0;

        if (argc < 2) {
                fprintf(stderr, "usage: %s output_filename\n", argv[0]);
                fprintf(stderr, "input is read from stdin\n");
                exit(1);
        }

        f = fopen(argv[1], "w");

        while (!feof(stdin)) {
                char s[MAX];
                s[0] = 0;
                fgets(s, sizeof(s), stdin);

                while (s[0] == '\r') {
                        memcpy(s, s+1, sizeof(s)-1);
                        s[MAX-1] = '\0';
                }

                /*  0xbfc00460:   24    5    0   10    0    5   28   c2  */
                if (s[0] == '0' && s[10]==':') {
                        unsigned long x;
                        int i;

                        x = strtol(s, NULL, 0);
                        if (x < 0xbfc00000) {
                                printf("x = 0x%08lx, less than 0xbfc00000. "
                                    "aborting\n", (long)x);
                                exit(1);
                        }
                        x -= 0xbfc00000;

                        if (same_flag) {
                                /*
                                 *  We should fill from same_start_offset to
                                 *  just before x, using previous_line data.
                                 */
                                off_t ofs;
                                printf("same_flag set, filling until just "
                                    "before 0x%08lx\n", (long)x);
                                fseek(f, same_start_offset, SEEK_SET);
                                for (ofs = same_start_offset; ofs < x;
                                    ofs += 8) {
                                        fwrite(previous_line, 1,
                                            sizeof(previous_line), f);
                                }
                                same_flag = 0;
                        }

                        printf("x = 0x%08lx\n", (long)x);

                        fseek(f, x, SEEK_SET);

                        for (i=0; i<strlen(s); i++)
                                if (s[i]==' ')
                                        s[i]='0';
                        for (i=0; i<8; i++) {
                                int ofs = i*5 + 14;
                                int d1, d2;
                                d1 = s[ofs];
                                d2 = s[ofs+1];
                                if (d1 >= '0' && d1<='9')
                                        d1 -= '0';
                                else
                                        d1 = d1 - 'a' + 10;
                                if (d2 >= '0' && d2<='9')
                                        d2 -= '0';
                                else
                                        d2 = d2 - 'a' + 10;
                                d1 = d1*16 + d2;

                                printf(" %02x", d1);
                                fprintf(f, "%c", d1);

                                previous_line[i] = d1;
                        }
                        printf("\n");
                }

                /*  "SAME":  */
                if (s[0] == 'S' && s[1] == 'A') {
                        /*
                         *  This should produce "same" output until the
                         *  next normal "0xbfc.." line.
                         */
                        same_flag = 1;
                        same_start_offset = ftell(f);
                }
        }

        fclose(f);

        return 0;
}

1	dpavlin	2	/*
2			* Copyright (C) 2004-2005 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28			* $Id: sgiprom_to_bin.c,v 1.5 2005/02/21 07:18:10 debug Exp $
29			*
30			* sgiprom_to_bin.c
31			*
32			* This program takes a textfile containing a SGI PROM memory dump of
33			* the following format:
34			*
35			* >> dump -b 0xBFC00000:0xBFCF0000
36			* 0xbfc00000: b f0 0 f0 0 0 0 0
37			* 0xbfc00008: b f0 1 f6 0 0 0 0
38			* SAME
39			* 0xbfc00200: b f0 3 c9 0 0 0 0
40			* 0xbfc00208: b f0 1 f6 0 0 0 0
41			* SAME
42			* 0xbfc00280: b f0 3 cb 0 0 0 0
43			* ..
44			*
45			* and turns it into a binary image. Input is read from stdin.
46			*/
47
48			#include <sys/types.h>
49			#include <stdio.h>
50			#include <stdlib.h>
51			#include <string.h>
52
53
54			#define MAX 200
55
56
57			int main(int argc, char *argv[])
58			{
59			FILE *f;
60			unsigned char previous_line[8];
61			int same_flag = 0;
62			off_t same_start_offset = 0;
63
64			if (argc < 2) {
65			fprintf(stderr, "usage: %s output_filename\n", argv[0]);
66			fprintf(stderr, "input is read from stdin\n");
67			exit(1);
68			}
69
70			f = fopen(argv[1], "w");
71
72			while (!feof(stdin)) {
73			char s[MAX];
74			s[0] = 0;
75			fgets(s, sizeof(s), stdin);
76
77			while (s[0] == '\r') {
78			memcpy(s, s+1, sizeof(s)-1);
79			s[MAX-1] = '\0';
80			}
81
82			/* 0xbfc00460: 24 5 0 10 0 5 28 c2 */
83			if (s[0] == '0' && s[10]==':') {
84			unsigned long x;
85			int i;
86
87			x = strtol(s, NULL, 0);
88			if (x < 0xbfc00000) {
89			printf("x = 0x%08lx, less than 0xbfc00000. "
90			"aborting\n", (long)x);
91			exit(1);
92			}
93			x -= 0xbfc00000;
94
95			if (same_flag) {
96			/*
97			* We should fill from same_start_offset to
98			* just before x, using previous_line data.
99			*/
100			off_t ofs;
101			printf("same_flag set, filling until just "
102			"before 0x%08lx\n", (long)x);
103			fseek(f, same_start_offset, SEEK_SET);
104			for (ofs = same_start_offset; ofs < x;
105			ofs += 8) {
106			fwrite(previous_line, 1,
107			sizeof(previous_line), f);
108			}
109			same_flag = 0;
110			}
111
112			printf("x = 0x%08lx\n", (long)x);
113
114			fseek(f, x, SEEK_SET);
115
116			for (i=0; i<strlen(s); i++)
117			if (s[i]==' ')
118			s[i]='0';
119			for (i=0; i<8; i++) {
120			int ofs = i*5 + 14;
121			int d1, d2;
122			d1 = s[ofs];
123			d2 = s[ofs+1];
124			if (d1 >= '0' && d1<='9')
125			d1 -= '0';
126			else
127			d1 = d1 - 'a' + 10;
128			if (d2 >= '0' && d2<='9')
129			d2 -= '0';
130			else
131			d2 = d2 - 'a' + 10;
132			d1 = d1*16 + d2;
133
134			printf(" %02x", d1);
135			fprintf(f, "%c", d1);
136
137			previous_line[i] = d1;
138			}
139			printf("\n");
140			}
141
142			/* "SAME": */
143			if (s[0] == 'S' && s[1] == 'A') {
144			/*
145			* This should produce "same" output until the
146			* next normal "0xbfc.." line.
147			*/
148			same_flag = 1;
149			same_start_offset = ftell(f);
150			}
151			}
152
153			fclose(f);
154
155			return 0;
156			}
157