Return to tcpy.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / c / common

Annotation of coherent/b/bin/c/common/tcpy.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #ifdef vax
                      3: #include "INC$LIB:mch.h"
                      4: #include "INC$LIB:stream.h"
                      5: #include "INC$LIB:ops.h"
                      6: #else
                      7: #include "mch.h"
                      8: #include "stream.h"
                      9: #include "ops.h"
                     10: #endif
                     11: 
                     12: /*
                     13:  * Copy debug label information.
                     14:  */
                     15: 
                     16: ival_t icpy();
                     17: 
                     18: tcpy(class)
                     19: {
                     20:        register int n;
                     21:        register int nline;
                     22:        register int c;
                     23:        register sizeof_t z;
                     24:        extern int line;
                     25: 
                     26:        /* Write class */
                     27:        bput(class);
                     28: 
                     29:        /* Read line number */
                     30:        nline = icpy();
                     31: 
                     32:        /* Get value */
                     33:        if (class < DC_LINE)
                     34:                ;
                     35:        else if (class < DC_AUTO)
                     36:                line = nline;
                     37:        else if (class < DC_MOS)
                     38:                icpy();
                     39:        else {
                     40:                bcpy();
                     41:                bcpy();
                     42:                icpy();
                     43:        }
                     44: 
                     45:        /* Get name */
                     46:        while (bcpy() != 0);
                     47: 
                     48:        /* Get type */
                     49:        for (;;) {
                     50:                c = bcpy();
                     51:                z = zget();
                     52:                zput(z);
                     53:                switch (c) {
                     54:                case DT_NONE:
                     55:                case DT_CHAR:
                     56:                case DT_UCHAR:
                     57:                case DT_SHORT:
                     58:                case DT_USHORT:
                     59:                case DT_INT:
                     60:                case DT_UINT:
                     61:                case DT_LONG:
                     62:                case DT_ULONG:
                     63:                case DT_FLOAT:
                     64:                case DT_DOUBLE:
                     65:                case DT_VOID:
                     66:                        break;
                     67:                case DT_STRUCT:
                     68:                case DT_UNION:
                     69:                case DT_ENUM:
                     70:                case DD_PTR:
                     71:                case DD_FUNC:
                     72:                case DD_ARRAY:
                     73:                        continue;
                     74:                case DX_MEMBS:
                     75:                        n = z;
                     76:                        while (--n >= 0) tcpy(bget());
                     77:                        break;
                     78:                case DX_NAME:
                     79:                        while (bcpy() != 0);
                     80:                        break;
                     81:                default:
                     82:                        cbotch("bad type in tcpy: %d", n);
                     83:                }
                     84:                break;
                     85:        }
                     86: }
                     87: 
                     88: static
                     89: bcpy()
                     90: {
                     91:        register int n;
                     92: 
                     93:        n = bget();
                     94:        bput(n);
                     95:        return (n);
                     96: }
                     97: 
                     98: static ival_t
                     99: icpy()
                    100: {
                    101:        register ival_t i;
                    102: 
                    103:        i = iget();
                    104:        iput(i);
                    105:        return (i);
                    106: }

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