Return to bio.c CVS log

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

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

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

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