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