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