![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to recnv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / cci / pt|
Return to recnv.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / cci / pt |
1.1 root 1: /************************************************************************
2: * *
3: * reccnv.c converts a standard PT hexfile to a larger record for *
4: * format. Options allows input filename to be defined output *
5: * fle is always hexout. Checksums are set to "00" instead of *
6: * trying to calculate them. *
7: * This program assumes that each record is 44 chars long it then *
8: * combines two records affectively into one. *
9: * 88 is the standard 152 the second pass and is the third pass *
10: * *
11: ************************************************************************/
12:
13: #include <stdio.h>
14: #define mode 0777
15: #define TRUE 1;
16: #define FALSE 0;
17: static int lastflg; /* says working on last records */
18:
19: main(argc, argv)
20: int argc;
21: char **argv;
22:
23: {
24: static char record[1024]; /* actual data */
25: static char srecord[1024]; /* actual data */
26: register int fs, ss, rs; /* record size */
27: static char *ttrp, *ttrp2;
28: FILE *in;
29: int outf;
30: int cs, i, pr;
31: char *name = "hexout"; /* default filename for output */
32: char *name1 = "DEFAULT_LD_FL"; /* default filename */
33: char *rp; /* record pointer */
34: int l=88; /*length of record to fix */
35: int dl; /* length of data segment */
36: int fl=9; /* header length always the same */
37: char *dlc; /* data length character */
38: int aoff; /* address offset for checking */
39:
40: if(argc < 2)
41: printf("\n using default read file and record size 88\n");
42: else if(argc == 2)
43: {
44: name1 = *(++argv);
45: }
46: else if(argc == 3)
47: {
48: name1 = *(++argv);
49: l = atoi(*(++argv));
50: }
51:
52: /* fix the record parameters */
53: switch(l)
54: {
55: case 3:
56: l = 280; /* length of two records to be combined */
57: dlc = "8"; /* new data length character */
58: dl = 256; /* new data field length */
59: aoff = 0x40; /* address offset of two sequ. rec's. */
60: break;
61: case 2:
62: l = 152;
63: dlc = "4";
64: dl = 128;
65: aoff = 0x20;
66: break;
67: default : /* 88 two normal rows */
68: l = 88;
69: dlc = "2";
70: dl = 64;
71: aoff = 0x10;
72: break;
73: }
74:
75: rp = record; /* setup pointer to array to dump info */
76: ttrp2 = srecord; /* setup pointer to array to dump info */
77: if((in = fopen(name1, "r")) == (FILE *)NULL )
78: printf("can't fopen input file\n");
79: if((outf = creat(name, mode)) < 0)
80: printf("can't create hexout\n");
81: if((open(name, 2)) < 0)
82: printf("can't open hexout\n");
83:
84: /* read and convert the records */
85: while (((fs = getrec(in, srecord )) + (ss = getrec(in, record))) > 0)
86: {
87: rs = fs + ss;
88: if(rs == l)
89: {
90: ttrp = rp;
91: /* check to see if the two records have sequential addresses */
92: if (pr = acnv(record, srecord, aoff)) /* addreses sequential ?? */
93: {
94: *(ttrp + 1) = *dlc; /* double the data amount */
95: ttrp = rp + ((dl/2)+fl); /* where to add new data */
96:
97: /* copy from data field */
98: for(i=1, ttrp2 = srecord+fl ; i<((dl/2) +1);i++)
99: *ttrp++ = *ttrp2++; /* copy data */
100: *ttrp++ = '\0';
101: *ttrp++ = '\0';
102: *ttrp++ = '\n';
103: write(outf, record, (dl+fl+3));
104: }
105: else if(pr == 0) /* not sequential */
106: /* they don't ave sequential addresses so just write the record as is */
107: {
108: if(ss >0)
109: write(outf, record, ss);
110: if(fs >0)
111: write(outf, srecord, fs);
112: continue;
113: }
114: } /*end of large file if */
115: else if(rs < l) /* if less than expected read dump as is */
116: {
117: /* printf("< if\n");
118: */
119: if(ss >0)
120: write(outf, record, ss);
121: if(fs >0)
122: write(outf, srecord, fs);
123: continue;
124: }
125: } /* end of while loop */
126: exit(0);
127: }
128:
129: /************************************************************************
130: * *
131: * converts address field and compares to see if they're sequential *
132: * *
133: * *
134: ************************************************************************/
135:
136: int
137: acnv(a,b,aoff)
138: char *a, *b; /* pointers to the two records */
139: int aoff; /* address offset */
140:
141: {
142: char g[5], h[5];
143: int i, ch, cg;
144:
145: a=a+3; b=b+3;
146: for(i=0; i<4; i++,a++,b++)
147: {
148: g[i] = *a;
149: h[i] = *b;
150: }
151: g[4] = '\0';
152: h[4] = '\0';
153: cg = cnv(g);
154: ch = cnv(h) - aoff;
155: if( ch == cg)
156: {
157: /* printf("out of order \n");
158: */
159: return 1;
160: }
161: else if(ch != cg)
162: return 0;
163:
164: }
165:
166: /************************************************************************
167: * cnv - converts four ascii digits to an integer *
168: * returns - the integer value *
169: * *
170: ************************************************************************/
171: int
172: cnv(sp)
173: char *sp;
174:
175: {
176: register int c, d, i, b;
177:
178: b = c = 0;
179:
180: for(i=0 ; i<4; i++, sp++)
181: {
182: if (*sp >= '0' && *sp <= '9')
183: b = *sp - '0';
184: else if (*sp >= 'A' && *sp <= 'F')
185: b = *sp - 'A' + 10;
186: else if (*sp >= 'a' && *sp <= 'f')
187: b = *sp - 'a' + 10;
188: switch (i)
189: {
190: case 3:
191: c = b + c;
192: case 2:
193: c = (b * 16) + c;
194: break;
195: case 1:
196: c = (b * 256) + c;
197: break;
198: case 0:
199: c = (b * 4096) + c;
200: break;
201: }
202: }
203: return c;
204: }
205:
206: /************************************************************************
207: * *
208: * getrec - Get a record to transmit. *
209: * *
210: * Returns: *
211: * -1 Error in file format. *
212: * 0 End of file reached. *
213: * > 0 Size of record to transmit. *
214: * *
215: ************************************************************************/
216:
217: int
218: getrec (fd, rp)
219:
220: FILE * fd;
221: char * rp;
222:
223: {
224:
225: int c;
226: int nc; /* number of characters */
227: int l; /* length of record bytes */
228: int cc; /* checksum */
229: int i; /* counter */
230: int a; /* address piece */
231:
232: while ((c = getc (fd)) != ':') /* Look for start of record */
233: if (c == EOF)
234: return 0; /* End of file */
235:
236: /***** Start record off. */
237:
238: /* printf("At record start\n"); */
239: *rp++ = ':';
240: nc = 1;
241:
242: /***** Get number of hex bytes in record. */
243:
244: if ((l = getxb (fd, rp)) < 0)
245: return -1;
246:
247: if(l == 1)
248: {
249: /* printf("01 record \n");
250: */
251: rp += 2;
252: for(i=1; i < 11; i += 2, rp +=2)
253: {
254: /* printf(" %u\n", i);
255: */
256: getxb(fd,rp);
257: }
258: *(rp) = '\n';
259: return 14;
260: }
261:
262: else if(l == 0)
263: {
264: printf("00 record \n");
265: rp += 2;
266: for(i=1; i < 8; i += 2, rp += 2)
267: {
268: printf(" %u\n",i);
269: getxb(fd,rp);
270: }
271: *++rp = '\n';
272: return 10;
273: }
274:
275: else
276: {
277: /* printf("normal record \n");
278: printf("%d data bytes\n", l);
279: */
280: cc = l; /* Start checksum */
281: rp += 2; /* Past two characters */
282: nc += 2; /* Two more characters */
283:
284: /***** Get address portion of data record. */
285:
286: for (i = 2 ; i > 0 ; i--) /* Two hex bytes */
287: {
288: if ((a = getxb (fd, rp)) < 0)
289: return -1;
290:
291: cc += a; /* Figure address into checksum */
292: rp += 2; /* Past two characters */
293: nc += 2; /* Two more characters */
294: }
295:
296: /***** Read type byte, which should be zero. */
297:
298: if ((i = getxb (fd, rp)) != 0)
299: return -1;
300:
301: cc += i; /* Figure type into checksum */
302: rp += 2; /* Past two characters */
303: nc += 2; /* Two more characters */
304:
305: /***** Read in the data record. */
306:
307: while (l-- > 0) /* Count down */
308: {
309: if ((i = getxb (fd, rp)) < 0)
310: return -1;
311:
312: /* printf ("Read %d\n", i); */
313: cc += i; /* Checksum */
314: rp += 2; /* Pointer */
315: nc += 2; /* Number of characters */
316: }
317:
318: cc = (-cc) & 0377; /* Two's complement byte */
319:
320: /* printf ("Checksum = %x\n", cc); */
321: *rp = cc >> 4;
322: *rp += *rp < 10 ? '0' : 'A' - 10;
323: *++rp = cc & 0xF;
324: *rp += *rp < 10 ? '0' : 'A' - 10;
325:
326: /* printf ("record size = %d\n", nc + 2); */
327: *++rp = '\n';
328: return nc + 3;
329:
330: } /* normal records */
331: }
332:
333: /************************************************************************
334: * *
335: * getxb - Get a hex byte. *
336: * *
337: * Returns: *
338: * -1 Error in file format or end of file reached. *
339: * >= 0 Integer value of byte. *
340: * *
341: ************************************************************************/
342:
343: int
344: getxb (fd, sp)
345:
346: FILE * fd;
347: char * sp;
348:
349: {
350:
351: register int i, j;
352:
353: if ((i = getxn (fd, sp++)) < 0 || (j = getxn (fd, sp)) < 0)
354: return -1;
355:
356: return (i << 4) | j;
357:
358: }
359:
360: /************************************************************************
361: * *
362: * getxn - Get a hex nibble. *
363: * *
364: * Returns: *
365: * -1 Error in file format or end of file reached. *
366: * >= 0 Integer value of nibble. *
367: * *
368: ************************************************************************/
369:
370: int
371: getxn (fd, sp)
372:
373: FILE * fd;
374: char * sp;
375:
376: {
377:
378: register int c;
379:
380: *sp = c = getc (fd);
381:
382: if (c >= '0' && c <= '9')
383: return c - '0';
384: else if (c >= 'A' && c <= 'F')
385: return c - 'A' + 10;
386: else if (c >= 'a' && c <= 'f')
387: return c - 'a' + 10;
388:
389: return -1;
390:
391: }
392:
393:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.