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