Return to bio.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / demand

Annotation of cci/d/demand/bio.c, revision 1.1.1.1

1.1       root        1: 
                      2: #include "definitions"
                      3: 
                      4: /*     I/O ROUTINES TO CPU2 CONSOLE    */
                      5: 
                      6: #define MAXC           1000            /* MAX 1000 chars per line */
                      7: #define OUTADR         0x20000         /* Address of output buffer */
                      8: #define INADR          0x20100         /* Address of input buffer  */
                      9: 
                     10: long ocnt = 0;                         /* Next location in output buffer */
                     11: long icnt = 0;                         /* Next location in input buffer */
                     12: extern long savvec7;
                     13: 
                     14: writec(c)              /* VERSION to run on the simmulator */
                     15: char c;
                     16: {
                     17: 
                     18: /*     asm("mfpr $MME,_savvec7");
                     19:        asm("movl *$0x418,_savvec7");
                     20:        savvec7 = savvec7 & 0x1;
                     21:        asm("mtpr $0,$MME");
                     22: */
                     23: 
                     24:        putchar(c);
                     25: /*     asm("mtpr _savvec7,$MME");       Restore MME */
                     26: }
                     27: 
                     28: readc(c)
                     29: char *c;
                     30: {      char *cptr;
                     31: 
                     32: /*     asm("mfpr $MME,_savvec7");      */
                     33:        asm("movl *$0x414,_savvec7");   /* Cheat mfpr MME */
                     34:        savvec7 = savvec7 & 0x1;
                     35:        asm("mtpr $0,$MME");            /* Disable MME */
                     36:        cptr = (char *)(INADR+ icnt++);
                     37:        *c = *cptr;
                     38:        asm("mtpr _savvec7,$MME");      /* Restore MME */
                     39: }
                     40: 
                     41: writes(s)
                     42: char *s;
                     43: {      char *str;
                     44:        int ix;
                     45: 
                     46:        str = s;
                     47:        for(ix=0;;ix++)
                     48:        {
                     49:        if (str[ix]==NULL) break;
                     50:                else writec(str[ix]);
                     51:        }
                     52: }
                     53: 
                     54: /*     This function read a string of characters.
                     55:        calling sequence : nochar = reads(s);
                     56:        input argument   : char *s;
                     57:        return value     : no. of char read; excluding NULL or CR.
                     58: */
                     59: reads(s)
                     60: char *s;
                     61: {      char *str;
                     62:        int ix;
                     63: 
                     64:        str = s;
                     65:        for(ix=0;ix<ALINE;ix++)
                     66:        {
                     67:                readc(str);
                     68:                if ((*str==NULL)||(*str==CR)) 
                     69:                        { *str = NULL;
                     70:                          break;
                     71:                        }
                     72:                     else str++;
                     73:        }
                     74:        icnt = 0;               /* For simulator only */
                     75: 
                     76:        return(ix);
                     77: }
                     78: /*     This function read a string of HEX digit and
                     79:        convert it to integer value.
                     80:        calling sequence : stat = readh(ix);
                     81:        input parameter  : long *ix;
                     82:        return value     : (stat < 0) if error else (stat = 0);
                     83: */
                     84: 
                     85: /*
                     86: readh(ix)      
                     87: long *ix;
                     88: {      char line[ALINE], *getnum(), *del;
                     89:        int nochar;
                     90: 
                     91:        if ( (nochar = reads(line)) > 8 ) return(-1);
                     92:        if ( (del = getnum(line,ix,del,HEX)) < 0 ) return(-1);
                     93:                else return(0);
                     94: }
                     95: 
                     96: */
                     97: 
                     98: 
                     99: 
                    100: writeh(ix)     /* 32 bits HEX */
                    101: long ix;
                    102: {      long iy, temp, mask;
                    103:        int count;
                    104:        char c;
                    105: 
                    106:        iy=1; count = 28;
                    107:        mask = 0xf0000000;
                    108:        while (mask)
                    109:        {
                    110:                c = ( (ix&mask) >> count )&0xf;
                    111:                count -= 4;
                    112:                mask = mask >> 4;
                    113:                if (iy) 
                    114:                        { mask = 0xf000000; 
                    115:                          iy=0;
                    116:                        }
                    117:                if ((c>=0)&&(c<=9)) c=c+'0';
                    118:                        else c=c+'7';
                    119:                writec(c);
                    120:        }
                    121: }
                    122: 
                    123: /*     This function read a string of DEC digit and
                    124:        convert it to integer value.
                    125:        calling sequence : stat = readd(ix);
                    126:        input parameter  : long *ix;
                    127:        return value     : (stat < 0) if error else (stat = 0);
                    128: */
                    129: 
                    130: /*
                    131: readd(ix)      
                    132: long *ix;
                    133: {      char line[ALINE], *getnum(), *del;
                    134:        int nochar;
                    135: 
                    136:        if ( (nochar = reads(line)) > 11 ) return(-1);
                    137:        if ( (del = getnum(line,ix,del,DEC)) < 0 ) return(-1);
                    138:                else return(0);
                    139: }
                    140: */
                    141: 
                    142: 
                    143: writed(ix)     /* 32 bits DECIMAL */
                    144: long ix;
                    145: {      char c;
                    146:        long div;
                    147:        float divi;
                    148:        int lead0;
                    149: 
                    150: /*
                    151:        if (ix<0) 
                    152:                {  writes("********");
                    153:                   return(0);        }
                    154:        lead0 = 1;
                    155:        divi = 1000000000;
                    156:        div = divi;
                    157:        while (div)
                    158:        {
                    159:                c = (ix/div)+'0';
                    160:                ix = ix%div;
                    161:                divi = divi/10;
                    162:                div = divi;
                    163:                if ((c=='0')&&(lead0)) c=SPACE;
                    164:                        else lead0 = 0;
                    165:                writec(c);
                    166:        }
                    167: */
                    168: 
                    169: }
                    170: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.