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