|
101
|
1 /*
|
|
|
2 * os9 driver
|
|
|
3 */
|
|
|
4
|
|
|
5 #asm
|
|
|
6 ifp1
|
|
|
7 use defsfile
|
|
|
8 endc
|
|
|
9 #endasm
|
|
|
10
|
|
|
11 typedef struct {
|
|
|
12 int fd; /* 0 */
|
|
|
13 int mode; /* 2 */
|
|
|
14 int len; /* 4 */
|
|
|
15 char *name; /* 6 */
|
|
|
16 unsigned char*ptr; /* 8 */
|
|
|
17 unsigned char buf[256]; /* 10 */
|
|
|
18 } FILE ;
|
|
|
19
|
|
|
20 #define FCBSIZE (sizeof(FILE))
|
|
|
21
|
|
99
|
22 #define NFILES 8
|
|
|
23
|
|
|
24 #define NULL 0
|
|
|
25 #define EOF (-1)
|
|
|
26
|
|
|
27 #define stdin _fcbtbl[0]
|
|
|
28 #define stdout _fcbtbl[1]
|
|
|
29 #define stderr _fcbtbl[2]
|
|
|
30
|
|
|
31 FILE *_fcbtbl[NFILES];
|
|
|
32
|
|
101
|
33 FILE _s0[3];
|
|
|
34
|
|
|
35 #define STDIN (&_s0[0])
|
|
|
36 #define STDOUT (&_s0[1])
|
|
|
37 #define STDERR (&_s0[2])
|
|
|
38
|
|
|
39 _main(args)
|
|
|
40 char *args;
|
|
99
|
41 {int i;
|
|
101
|
42 char **argv,*p;
|
|
|
43 int argc,n,quote,c;
|
|
|
44 stdin = STDIN; stdin->fd = 0;
|
|
|
45 stdout = STDOUT; stdout->fd = 1;
|
|
|
46 stderr = STDERR; stderr->fd = 2;
|
|
99
|
47 initheap();
|
|
|
48 for ( i = 3; i < NFILES; i++ ) _fcbtbl[i] = NULL;
|
|
101
|
49 /* create argv here */
|
|
|
50 argc = 0;
|
|
|
51 argv = 0;
|
|
|
52 n = 0;
|
|
|
53 quote = 0;
|
|
|
54 for( i = 0; i < 2 ; i++ ) {
|
|
|
55 if (i==1 && argc) { argv = (char**)malloc(sizeof(char*)*argc; }
|
|
|
56 p = args;
|
|
|
57 while((c = *p++)) {
|
|
|
58 if (i==1) argv[n] = args;
|
|
|
59 if (c=='\'') {
|
|
|
60 if (!quote) {
|
|
|
61 if (i==1) argv[n]++;
|
|
|
62 quote = 1;
|
|
|
63 continue;
|
|
|
64 } else {
|
|
|
65 if (i==1) p[-1]=0;
|
|
|
66 quote = 0;
|
|
|
67 }
|
|
|
68 } else if (c=='\\') {
|
|
|
69 p++;
|
|
|
70 continue;
|
|
|
71 } else if (c==' ') {
|
|
|
72 if (quote)
|
|
|
73 continue;
|
|
|
74 if (i==1) p[-1]=0;
|
|
|
75 }
|
|
|
76 n++;
|
|
|
77 }
|
|
|
78 p[-1]=0;
|
|
|
79 }
|
|
99
|
80 main(argc,argv);
|
|
|
81 }
|
|
|
82
|
|
|
83 FILE *fopen(name,mode)
|
|
|
84 char *name,*mode;
|
|
|
85 {FILE *fcbp;
|
|
|
86 char *p;
|
|
|
87 int rd,wt,cm;
|
|
|
88 rd = wt = cm = 0;
|
|
|
89 for ( p = mode; *p; p++ ) {
|
|
|
90 switch ( *p ) {
|
|
|
91 case 'r':
|
|
|
92 rd = 1; break;
|
|
|
93 case 'w':
|
|
|
94 wt = 1; break;
|
|
|
95 case 'c':
|
|
|
96 cm = 1; break;
|
|
|
97 default:
|
|
|
98 return NULL;
|
|
|
99 }
|
|
|
100 }
|
|
|
101 if ( !(rd ^ wt) ) return NULL;
|
|
|
102 if ( rd ) return _open(name,cm);
|
|
|
103 else return _create(name,cm);
|
|
|
104 }
|
|
|
105
|
|
|
106 FILE *_open(name,cm)
|
|
|
107 char *name;
|
|
|
108 int cm;
|
|
|
109 {FILE *fcbp;
|
|
|
110 int i;
|
|
|
111 for ( i = 0; i < NFILES; i++)
|
|
|
112 if ( _fcbtbl[i] == NULL ) break;
|
|
|
113 if ( i >= NFILES) return NULL;
|
|
|
114 if ( (fcbp = malloc(FCBSIZE)) == NULL ) return NULL;
|
|
|
115 if ( _setname(name,fcbp) == 0 ) return NULL;
|
|
101
|
116 #asm
|
|
|
117 pshs x,y,u
|
|
|
118 ldx -4,u
|
|
|
119 lda 2,x mode
|
|
|
120 ldb 3,x src attribute
|
|
|
121 leax 6,x name
|
|
|
122 os9 I$Open
|
|
|
123 bcc _LC0001
|
|
|
124 ldx -4,u
|
|
|
125 clrb
|
|
|
126 std ,x
|
|
|
127 bra _LC0002
|
|
|
128 _LC0001
|
|
|
129 ldx -4,u
|
|
|
130 clra
|
|
|
131 stD 2,x err code
|
|
|
132 ldd #-1
|
|
|
133 std ,x
|
|
|
134 _LC0002
|
|
|
135 puls x,y,u
|
|
|
136 #endasm
|
|
|
137 if fcbp->fd < 0 ) return NULL;
|
|
|
138 fcbp->ptr = fcpp->buf;
|
|
|
139 fcbp->len = 0;
|
|
99
|
140 return (_fcbtbl[i] = fcbp);
|
|
|
141 }
|
|
|
142
|
|
|
143 FILE *_create(name,cm)
|
|
|
144 char *name;
|
|
|
145 int cm;
|
|
|
146 {FILE *fcbp;
|
|
|
147 int i;
|
|
|
148 for ( i = 0; i < NFILES; i++)
|
|
|
149 if ( _fcbtbl[i] == NULL ) break;
|
|
|
150 if ( i >= NFILES) return NULL;
|
|
|
151 if ( (fcbp = malloc(FCBSIZE)) == NULL ) return NULL;
|
|
|
152 if ( _setname(name,fcbp) == 0 ) return NULL;
|
|
101
|
153 #asm
|
|
|
154 pshs x,y,u
|
|
|
155 ldx -4,u
|
|
|
156 lda 2,x mode
|
|
|
157 ldb 3,x src attribute
|
|
|
158 leax 6,x name
|
|
|
159 os9 F$Create
|
|
|
160 bcc _LC0001
|
|
|
161 ldx -4,u
|
|
|
162 clrb
|
|
|
163 std ,x
|
|
|
164 bra _LC0002
|
|
|
165 _LC0001
|
|
|
166 ldx -4,u
|
|
|
167 clra
|
|
|
168 stD 2,x err code
|
|
|
169 ldd #-1
|
|
|
170 std ,x
|
|
|
171 _LC0002
|
|
|
172 puls x,y,u
|
|
|
173 #endasm
|
|
|
174 if fcbp->fd < 0 ) return NULL;
|
|
|
175 fcbp->ptr = fcpp->buf;
|
|
|
176 fcbp->len = 0;
|
|
99
|
177 return (_fcbtbl[i] = fcbp);
|
|
|
178 }
|
|
|
179
|
|
|
180 fclose(fcbp)
|
|
|
181 FILE *fcbp;
|
|
|
182 {int i;
|
|
|
183 for ( i = 0; i < NFILES; i++ )
|
|
|
184 if ( fcbp == _fcbtbl[i] ) break;
|
|
|
185 if ( i >= NFILES ) return EOF;
|
|
|
186 _fcbtbl[i] = NULL;
|
|
|
187 if ( (fcbp == STDIN) || (fcbp == STDOUT) || (fcbp == STDERR) ) return 0;
|
|
101
|
188 #asm
|
|
|
189 pshs x,y,u
|
|
|
190 ldx -4,u
|
|
|
191 lda ,x
|
|
|
192 os9 I$Close
|
|
|
193 puls x,y,u
|
|
|
194 #endasm
|
|
99
|
195 mfree(fcbp);
|
|
|
196 return 0;
|
|
|
197 }
|
|
|
198
|
|
|
199 _setname(name,fcbp)
|
|
|
200 char *name,*fcbp;
|
|
|
201 {int i;
|
|
|
202 while(isspace(*name)) ++name;
|
|
|
203 if (isdigit(*name))
|
|
|
204 { fcbp[3] = *name++ - '0';
|
|
|
205 if (*name++ != '.') return 0;
|
|
|
206 }
|
|
|
207 else fcbp[3] = 0xff;
|
|
|
208 for (i = 4; i < 15; ++i) fcbp[i] = 0;
|
|
|
209 if (!isalpha(*name)) return -1;
|
|
|
210 for (i = 4; i < 12; ++i)
|
|
|
211 { if (!*name || (*name == '.')) break;
|
|
|
212 fcbp[i] = *name++;
|
|
|
213 }
|
|
|
214 while (*name && (*name != '.')) ++name;
|
|
|
215 if (*name == '.')
|
|
|
216 { ++name;
|
|
|
217 for (i = 12; i < 15; ++i)
|
|
|
218 { if (!*name) break;
|
|
|
219 fcbp[i] = *name++;
|
|
|
220 }
|
|
|
221 }
|
|
|
222 return 1;
|
|
|
223 }
|
|
|
224
|
|
|
225
|
|
|
226 getc(fcbp)
|
|
|
227 char *fcbp;
|
|
|
228 {
|
|
101
|
229 int c;
|
|
|
230 #asm
|
|
|
231 pshs x,y,u
|
|
|
232 ldd ,u c
|
|
|
233 PSHS A,B
|
|
|
234 ldx 2,u
|
|
|
235 lda 1,x file descriptor
|
|
|
236 leax 1,S
|
|
|
237 clr ,s
|
|
|
238 ldy #1
|
|
|
239 os9 I$Read
|
|
|
240 bcc _LC0003
|
|
|
241 ldd #-1
|
|
|
242 std ,s
|
|
|
243 _LC0003
|
|
|
244 puls d,x,y,u
|
|
|
245 #endasm
|
|
99
|
246 }
|
|
|
247
|
|
|
248 putc(c,fcbp)
|
|
|
249 char c,*fcbp;
|
|
101
|
250 {
|
|
|
251 int ret;
|
|
|
252 #asm
|
|
|
253 pshs x,y,u
|
|
|
254 ldd ,u c
|
|
|
255 PSHS A,B
|
|
|
256 ldx 2,u
|
|
|
257 lda 1,x file descriptor
|
|
|
258 leax 1,S
|
|
|
259 ldy #1
|
|
|
260 os9 I$Write
|
|
|
261 puls d,x,y,u
|
|
|
262 #endasm
|
|
|
263 return c;
|
|
99
|
264 }
|
|
|
265
|
|
|
266 getchar()
|
|
|
267 { return getc(stdin);
|
|
|
268 }
|
|
|
269
|
|
|
270 putchar(c)
|
|
|
271 char c;
|
|
|
272 { return putc(c,stdout);
|
|
|
273 }
|
|
|
274
|
|
|
275 printf(s)
|
|
|
276 char *s;
|
|
|
277 { _fprintf(stdout,s,(int *)&s+1);
|
|
|
278 }
|
|
|
279
|
|
|
280 fprintf(f,s)
|
|
|
281 char *f,*s;
|
|
|
282 { _fprintf(f,s,(int *)&s+1);
|
|
|
283 }
|
|
|
284
|
|
|
285 _fprintf(f,s,p)
|
|
|
286 char *f,*s;
|
|
|
287 int *p;
|
|
|
288 {int l,m,n;
|
|
|
289 char c,buf[8];
|
|
|
290 while(c = *s++)
|
|
|
291 if (c != '%') putc(c,f);
|
|
|
292 else
|
|
|
293 { if (l=(*s == '-')) ++s;
|
|
|
294 if (isdigit(*s)) s += _getint(&m,s);
|
|
|
295 else m = 0;
|
|
|
296 if (*s == '.') ++s;
|
|
|
297 if (isdigit(*s)) s += _getint(&n,s);
|
|
|
298 else n = 32767;
|
|
|
299 switch(*s++)
|
|
|
300 {case 'd':
|
|
|
301 itoa(*p++,buf);
|
|
|
302 break;
|
|
|
303 case 'o':
|
|
|
304 itooa(*p++,buf);
|
|
|
305 break;
|
|
|
306 case 'x':
|
|
|
307 itoxa(*p++,buf);
|
|
|
308 break;
|
|
|
309 case 'u':
|
|
|
310 itoua(*p++,buf);
|
|
|
311 break;
|
|
|
312 case 'c':
|
|
|
313 ctos(*p++,buf);
|
|
|
314 break;
|
|
|
315 case 's':
|
|
|
316 _putstr(f,*p++,l,m,n);
|
|
|
317 continue;
|
|
|
318 case '\0':
|
|
|
319 return;
|
|
|
320 default:
|
|
|
321 ctos(c,buf);
|
|
|
322 break;
|
|
|
323 }
|
|
|
324 _putstr(f,buf,l,m,n);
|
|
|
325 }
|
|
|
326 }
|
|
|
327
|
|
|
328 _getint(p,s)
|
|
|
329 int *p;
|
|
|
330 char *s;
|
|
|
331 {int i;
|
|
|
332 for(*p=i=0; isdigit(*s); ++i) *p = *p * 10 + *s++ - '0';
|
|
|
333 return i;
|
|
|
334 }
|
|
|
335
|
|
|
336 _putstr(f,s,l,m,n)
|
|
|
337 char *f,*s;
|
|
|
338 int l,m,n;
|
|
|
339 {int k;
|
|
|
340 k = (strlen(s) < n ? strlen(s) : n);
|
|
|
341 m = (k < m ? m-k : 0);
|
|
|
342 if (l)
|
|
|
343 { _putsn(f,s,n);
|
|
|
344 _putspc(f,m);
|
|
|
345 }
|
|
|
346 else
|
|
|
347 { _putspc(f,m);
|
|
|
348 _putsn(f,s,n);
|
|
|
349 }
|
|
|
350 }
|
|
|
351
|
|
|
352 _putsn(f,s,n)
|
|
|
353 char *f,*s;
|
|
|
354 int n;
|
|
|
355 { while(*s)
|
|
|
356 if (--n >= 0) putc(*s++,f);
|
|
|
357 else break;
|
|
|
358 }
|
|
|
359
|
|
|
360 _putspc(f,n)
|
|
|
361 char *f;
|
|
|
362 int n;
|
|
|
363 { while(--n >= 0) putc(' ',f);
|
|
|
364 }
|
|
|
365
|
|
|
366 puts(s)
|
|
|
367 char *s;
|
|
|
368 { while(*s) putchar(*s++);
|
|
|
369 }
|
|
|
370
|
|
|
371 itoa(n,s)
|
|
|
372 int n;
|
|
|
373 char *s;
|
|
|
374 { if (n < 0)
|
|
|
375 { *s++ = '-';
|
|
|
376 return (itoua(-n,s)+1);
|
|
|
377 }
|
|
|
378 return itoua(n,s);
|
|
|
379 }
|
|
|
380
|
|
|
381 itoua(n,s)
|
|
|
382 int n;
|
|
|
383 char *s;
|
|
|
384 { return _itoda(n,s,10);
|
|
|
385 }
|
|
|
386
|
|
|
387 itooa(n,s)
|
|
|
388 int n;
|
|
|
389 char *s;
|
|
|
390 { return _itoda(n,s,8);
|
|
|
391 }
|
|
|
392
|
|
|
393 itoxa(n,s)
|
|
|
394 int n;
|
|
|
395 char *s;
|
|
|
396 { return _itoda(n,s,16);
|
|
|
397 }
|
|
|
398
|
|
|
399 _itoac(n)
|
|
|
400 int n;
|
|
|
401 { return (n + ((n < 10) ? '0' : ('A'-10)));
|
|
|
402 }
|
|
|
403
|
|
|
404 _itoda(n,s,r)
|
|
|
405 unsigned n;
|
|
|
406 int r;
|
|
|
407 char *s;
|
|
|
408 {int i;
|
|
|
409 char t[8],*u;
|
|
|
410 u = t;
|
|
|
411 *u++ = '\0';
|
|
|
412 do *u++ = _itoac(n % r); while(n /= r);
|
|
|
413 for (i=0; *s++ = *--u; ++i);
|
|
|
414 return i;
|
|
|
415 }
|
|
|
416
|
|
|
417 char *ctos(c,s)
|
|
|
418 char c,*s;
|
|
|
419 { s[0] = c;
|
|
|
420 s[1] = '\0';
|
|
|
421 return s;
|
|
|
422 }
|
|
|
423
|
|
|
424 strlen(s)
|
|
|
425 char *s;
|
|
|
426 {int i;
|
|
|
427 for(i = 0; *s++; ++i);
|
|
|
428 return i;
|
|
|
429 }
|
|
|
430
|
|
|
431 isdigit(c)
|
|
|
432 char c;
|
|
|
433 { return '0' <= c && c <= '9';
|
|
|
434 }
|
|
|
435
|
|
|
436 isspace(c)
|
|
|
437 char c;
|
|
|
438 { return (c == ' ' || c == '\t' || c == '\n');
|
|
|
439 }
|
|
|
440
|
|
|
441 isalpha(c)
|
|
|
442 char c;
|
|
|
443 { return (isupper(c) || islower(c) || c == '_');
|
|
|
444 }
|
|
|
445
|
|
|
446 isupper(c)
|
|
|
447 char c;
|
|
|
448 { return ('A' <= c && c <= 'Z');
|
|
|
449 }
|
|
|
450
|
|
|
451 islower(c)
|
|
|
452 char c;
|
|
|
453 { return ('a' <= c && c <= 'z');
|
|
|
454 }
|
|
|
455
|
|
|
456 toupper(c)
|
|
|
457 char c;
|
|
|
458 { return (islower(c) ? c + ('A'-'a') : c);
|
|
|
459 }
|
|
|
460
|
|
|
461 tolower(c)
|
|
|
462 char c;
|
|
|
463 { return (isupper(c) ? c + ('a'-'A') : c);
|
|
|
464 }
|
|
|
465
|
|
|
466 atoi(s)
|
|
|
467 char *s;
|
|
|
468 {int i;
|
|
|
469 while (isspace(*s)) ++s;
|
|
|
470 for (i = 0; isdigit(*s);) i = i * 10 + *s++ - '0';
|
|
|
471 return i;
|
|
|
472 }
|
|
|
473
|
|
|
474 typedef struct header
|
|
|
475 { struct header *bptr;
|
|
|
476 unsigned bsize;
|
|
|
477 } HEADER;
|
|
|
478
|
|
|
479 HEADER base,*allocp,*heapp;
|
|
|
480
|
|
|
481 char *malloc(s)
|
|
|
482 unsigned s;
|
|
|
483 {HEADER *p,*q;
|
|
|
484 int nunits;
|
|
|
485 nunits = 1 + (s + sizeof(HEADER) - 1) / sizeof(HEADER);
|
|
|
486 if ((q = allocp) == NULL)
|
|
|
487 { base.bptr = allocp = q = &base;
|
|
|
488 base.bsize = 0;
|
|
|
489 }
|
|
|
490 for (p = q->bptr; ; q = p,p = p->bptr)
|
|
|
491 { if (p->bsize >= nunits)
|
|
|
492 { if (p->bsize == nunits)
|
|
|
493 q->bptr = p->bptr;
|
|
|
494 else
|
|
|
495 { p->bsize -= nunits;
|
|
|
496 p += p->bsize;
|
|
|
497 p->bsize = nunits;
|
|
|
498 }
|
|
|
499 allocp = q;
|
|
|
500 clearblock(p);
|
|
|
501 return ((char *)(p + 1));
|
|
|
502 }
|
|
|
503 if (p == allocp)
|
|
|
504 if ((p = morecore(nunits)) == NULL)
|
|
|
505 return(NULL);
|
|
|
506 }
|
|
|
507 }
|
|
|
508
|
|
|
509 clearblock(p)
|
|
|
510 HEADER *p;
|
|
|
511 {char *s,*t;
|
|
|
512 s = (char *)(p + 1);
|
|
|
513 t = (char *)(p + p->bsize);
|
|
|
514 while (s < t) *s++ = 0;
|
|
|
515 }
|
|
|
516
|
|
|
517 #define NALLOC 128
|
|
|
518
|
|
|
519 HEADER *morecore(nu)
|
|
|
520 unsigned nu;
|
|
|
521 {char *cp;
|
|
|
522 HEADER *up;
|
|
|
523 int rnu;
|
|
|
524 rnu = NALLOC * ((nu + NALLOC - 1) / NALLOC);
|
|
|
525 cp = sbrk(rnu * sizeof(HEADER));
|
|
|
526 if ((int)cp == -1) return NULL;
|
|
|
527 up = (HEADER *) cp;
|
|
|
528 up->bsize = rnu;
|
|
|
529 mfree((char *)(up+1));
|
|
|
530 return allocp;
|
|
|
531 }
|
|
|
532
|
|
|
533 #asm
|
|
|
534 sbrk PSHS U
|
|
|
535 LEAU ,S
|
|
|
536
|
|
|
537 LDD heapp,Y
|
|
|
538 BNE _mc0
|
|
|
539 BSR initheap
|
|
|
540 _mc0 PSHS D
|
|
|
541 TFR S,D
|
|
|
542 SUBD ,S++
|
|
|
543 CMPD 4,U
|
|
|
544 BCC _mc1
|
|
|
545 LDD #-1
|
|
|
546 LEAS ,U
|
|
|
547 PULS U,PC
|
|
|
548
|
|
|
549 _mc1 LDD 4,U
|
|
|
550 LDX heapp,Y
|
|
|
551 LEAX D,X
|
|
|
552 LDD heapp,Y
|
|
|
553 STX heapp,Y
|
|
|
554 LEAS ,U
|
|
|
555 PULS U,PC
|
|
|
556
|
|
|
557 initheap
|
|
|
558 PSHS U
|
|
|
559 LEAU ,S
|
|
|
560 TFR Y,D
|
|
|
561 ADDD #_GLOBALS
|
|
|
562 STD heapp,Y
|
|
|
563 LEAS ,U
|
|
|
564 PULS U,PC
|
|
|
565 #endasm
|
|
|
566
|
|
|
567 mfree(ap)
|
|
|
568 char *ap;
|
|
|
569 {HEADER *p,*q;
|
|
|
570 p = (HEADER *)ap - 1;
|
|
|
571 for (q = allocp; !(p > q && p < q->bptr); q = q->bptr)
|
|
|
572 if (q >= q->bptr && (p > q || p < q->bptr)) break;
|
|
|
573 if (p + p->bsize == q->bptr)
|
|
|
574 { p->bsize += q->bptr->bsize;
|
|
|
575 p->bptr = q->bptr->bptr;
|
|
|
576 }
|
|
|
577 else p->bptr = q->bptr;
|
|
|
578 if (q + q->bsize == p)
|
|
|
579 { q->bsize += p->bsize;
|
|
|
580 q->bptr = p->bptr;
|
|
|
581 }
|
|
|
582 else q->bptr = p;
|
|
|
583 allocp = q;
|
|
|
584 }
|
|
|
585
|
|
|
586 unsigned freesize()
|
|
|
587 {int i;
|
|
|
588 if (!heapp) initheap();
|
|
|
589 return ((char *)&i - (char *)heapp);
|
|
|
590 }
|
