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