Return to bio.c CVS log

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

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

1.1       root        1: #include "definitions"
                      2: 
                      3: /*     I/O ROUTINES TO CPU2 CONSOLE    */
                      4: writec(c)
                      5: char c;
                      6: {
                      7:        putchar(c);
                      8: }
                      9: writes(s)
                     10: char *s;
                     11: {
                     12:        putstr(s);
                     13: }
                     14: writeh(ix)     /* 32 bits HEX */
                     15: long ix;
                     16: {      register long count, mask, indx;
                     17:        char c, str[9];
                     18: 
                     19:        if (ix==0) { writec('0'); return; }
                     20:        indx = 0; count = 28;
                     21:        mask = 0xf0000000;
                     22:        str[8]='\0';
                     23:        while (mask)  {
                     24:                c = ( (ix&mask) >> count )&0xf;
                     25:                count -= 4;
                     26:                if (indx==0) mask = 0xf000000;
                     27:                        else mask = mask >> 4;
                     28:                if ((c>=0)&&(c<=9)) c=c+'0';
                     29:                        else c=c+'7';
                     30:                str[indx++] = c;
                     31:                }
                     32:        indx = 0;
                     33:        /* replace leading 0 with space */
                     34:        /* for (indx=0; indx<8; indx++) {
                     35:                if (str[indx]!='0') break;
                     36:                         else str[indx]=' ';
                     37:                }
                     38:        */
                     39:        writes(&str[indx]);
                     40: }
                     41: /*     Function to write a 32_bit decimal to Console
                     42: */
                     43: writed(ix)
                     44: long ix;
                     45: {      char c;
                     46:        register long div, lead0;
                     47: 
                     48:        if (ix==0) { writec('0'); return; }
                     49:        if (ix<0) { writec('-'); ix = (~ix)+1; }
                     50:        lead0 = 1;
                     51:        div = 1000000000;
                     52:        while (div) {
                     53:                c = (ix/div)+'0';
                     54:                ix = ix%div;            /* Mod */
                     55:                div /= 10;
                     56:                if ((c=='0')&&(lead0)) c=' ';
                     57:                        else lead0 = 0;
                     58:                if (c != ' ') writec(c);
                     59:                }
                     60: }
                     61: /*     Function read 1 char from Console
                     62: */
                     63: char readc()
                     64: {      char c, rdchar();
                     65: 
                     66:        writec(c=rdchar());
                     67:        return(c);
                     68: }
                     69: /*     This function read a string of characters.
                     70:        calling sequence : nochar = reads(s);
                     71:        input argument   : char *s;
                     72:        return value     : no. of char read; excluding NULL or CR.
                     73: */
                     74: reads(s)
                     75: char *s;
                     76: {      register long ix;
                     77: 
                     78:        for(ix=0;;ix++) {
                     79:                *s = readc();
                     80:                if (*s == '015')
                     81:                        { *s = NULL; return(ix); }
                     82:                     else s++;
                     83:                }
                     84: }
                     85: /*     This function read a string of HEX digit and
                     86:        convert it to integer value.
                     87:        calling sequence : stat = readh(ix);
                     88:        input parameter  : long *ix;
                     89:        return value     : (stat < 0) if error else (stat = 0);
                     90: */
                     91: /*
                     92: readh(ix)      
                     93: long *ix;
                     94: {      char line[ALINE], *getnum(), *del;
                     95:        int nochar;
                     96: 
                     97:        if ( (nochar = reads(line)) > 8 ) return(-1);
                     98:        if ( (del = getnum(line,ix,del,HEX)) < 0 ) return(-1);
                     99:                else return(0);
                    100: }
                    101: */
                    102: /*     This function read a string of DEC digit and
                    103:        convert it to integer value.
                    104:        calling sequence : stat = readd(ix);
                    105:        input parameter  : long *ix;
                    106:        return value     : (stat < 0) if error else (stat = 0);
                    107: */
                    108: /*
                    109: readd(ix)      
                    110: long *ix;
                    111: {      char line[ALINE], *getnum(), *del;
                    112:        int nochar;
                    113: 
                    114:        if ( (nochar = reads(line)) > 11 ) return(-1);
                    115:        if ( (del = getnum(line,ix,del,DEC)) < 0 ) return(-1);
                    116:                else return(0);
                    117: }
                    118: */
                    119: 

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