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