Return to asmlex.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / as

Annotation of coherent/d/bin/as/asmlex.c, revision 1.1.1.1

1.1       root        1: #include "asm.h"
                      2: 
                      3: getnb()
                      4: {
                      5:        register c;
                      6: 
                      7:        do {
                      8:                if ((c = *ip) != 0)
                      9:                        ++ip;
                     10:        } while (c==' ' || c=='\t');
                     11:        return (c);
                     12: }
                     13: 
                     14: get()
                     15: {
                     16:        register c;
                     17: 
                     18:        if ((c = *ip) != 0)
                     19:                ++ip;
                     20:        return (c);
                     21: }
                     22: 
                     23: nxtc(c)
                     24: {
                     25:        if (c == *ip) {
                     26:                ++ip;
                     27:                return (1);
                     28:        }
                     29:        return (0);
                     30: }
                     31: 
                     32: unget(c)
                     33: {
                     34:        if (c != 0)
                     35:                --ip;
                     36: }
                     37: 
                     38: getmap(d)
                     39: {
                     40:        register c, v, n;
                     41: 
                     42:        if ((c = get()) == '\0')
                     43:                qerr("unexpected end of line");
                     44:        if (c == d)
                     45:                return (-1);
                     46:        if (c == '\\') {
                     47:                c = get();
                     48:                switch (c) {
                     49: 
                     50:                case 'b':
                     51:                        c = '\b';
                     52:                        break;
                     53: 
                     54:                case 'f':
                     55:                        c = '\f';
                     56:                        break;
                     57: 
                     58:                case 'n':
                     59:                        c = '\n';
                     60:                        break;
                     61: 
                     62:                case 'r':
                     63:                        c = '\r';
                     64:                        break;
                     65: 
                     66:                case 't':
                     67:                        c = '\t';
                     68:                        break;
                     69: 
                     70:                case 'v':                                       /* 150 */
                     71:                        c = 013;        /* vertical tab */      /* 150 */
                     72:                        break;                                  /* 150 */
                     73:                case 'x':
                     74:                        for(n = v = 0; n < 2; n++) {    /* hex stuff */
                     75:                                v = (v << 4) + (c = get());
                     76:                                if(c >= '0' && c <= '9')
                     77:                                        v -= '0';
                     78:                                else if(c >= 'a' && c <= 'f')
                     79:                                        v -= ('a' - 10);
                     80:                                else if(c >= 'A' && c <= 'F')
                     81:                                        v -= ('A' - 10);
                     82:                                else
                     83:                                        qerr("Invalid hex expression");
                     84:                        }
                     85:                        c = v;
                     86:                        break;          
                     87:                case '0':
                     88:                case '1':
                     89:                case '2':
                     90:                case '3':
                     91:                case '4':
                     92:                case '5':
                     93:                case '6':
                     94:                case '7':
                     95:                        n = 0;
                     96:                        v = 0;
                     97:                        while (++n<=3 && c>='0' && c<='7') {
                     98:                                v = (v<<3) + c - '0';
                     99:                                c = get();
                    100:                        }
                    101:                        unget(c);
                    102:                        c = v;
                    103:                        break;
                    104:                }
                    105:        }
                    106:        return (c);
                    107: }
                    108: 
                    109: more()
                    110: {
                    111:        register c;
                    112: 
                    113:        c = getnb();
                    114:        unget(c);
                    115:        if (c == '\0' || c == '/' || c == ';')
                    116:                return (0);
                    117:        return (1);
                    118: }

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