Return to grindy.c CVS log

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

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

1.1       root        1: /*
                      2:  * The routines in this file
                      3:  * completely dominate the execution time
                      4:  * of the assembler. If you write tuned
                      5:  * versions of them in assembly code, the
                      6:  * performance of the assembler will be
                      7:  * much better.
                      8:  */
                      9: #include "asm.h"
                     10: 
                     11: /*
                     12:  * Read in an identifier.
                     13:  * Pack the name, null filled, into
                     14:  * the buffer `id'. The character `c'
                     15:  * is the first character of the name;
                     16:  * if < 0 then a character must be
                     17:  * read.
                     18:  */
                     19: getid(id, c)
                     20: register c;
                     21: char *id;
                     22: {
                     23:        register char *e, *p;
                     24: 
                     25:        if (c < 0) {
                     26:                do {
                     27:                        if ((c = *ip) != 0)
                     28:                                ++ip;
                     29:                } while (c==' ' || c=='\t');
                     30:                if (ctype[c] >= 0)      /* Not LETTER */
                     31:                        qerr("invalid identifier");
                     32:        }
                     33:        p = id;
                     34:        e = p + NCPLN;
                     35:        do {
                     36:                if (p < e)
                     37:                        *p++ = c;
                     38:                if ((c = *ip) != 0)
                     39:                        ++ip;
                     40:        } while (ctype[c] <= 0);        /* LETTER or DIGIT */
                     41:        if (c != 0)
                     42:                --ip;
                     43:        while (p < e)
                     44:                *p++ = 0;
                     45: }
                     46: 
                     47: /*
                     48:  * Read a line from the standard I/O
                     49:  * stream `sfp' into the buffer `ib' and
                     50:  * return true if a line was obtained.
                     51:  */
                     52: getline()
                     53: {
                     54:        register char *p;
                     55:        register c;
                     56: 
                     57:        p = ib;
                     58:        while ((c=getc(sfp))!=EOF && c!='\n')
                     59:                if (p < &ib[NINPUT-1])
                     60:                        *p++ = c;
                     61:        *p = '\0';
                     62:        return (c != EOF);
                     63: }
                     64: 
                     65: /*
                     66:  * Lookup the name `id' in the hashtable.
                     67:  * If it is not found either return a
                     68:  * `NULL' (`f' is false) or a
                     69:  * pointer to a newly created hash table
                     70:  * entry (`f' is true).
                     71:  */
                     72: struct sym *
                     73: lookup(id, f)
                     74: char *id;
                     75: {
                     76:        register struct sym *sp;
                     77:        int ht;
                     78: 
                     79:        {
                     80:                register char *p1;
                     81:                register nc;
                     82: 
                     83:                ht = 0;
                     84:                nc = NCPLN;
                     85:                p1 = id;
                     86:                do {
                     87:                        ht += *p1++;
                     88:                } while (--nc);
                     89:        }
                     90:        if ((sp = symhash[ht&HMASK]) != NULL) {
                     91:                do {
                     92:                        if (sp->s_total==ht && symeq(id, sp->s_id))
                     93:                                return (sp);
                     94:                } while ((sp = sp->s_sp) != NULL);
                     95:        }
                     96:        if (f == 0)
                     97:                return (NULL);
                     98:        sp = (struct sym *) new(sizeof(struct sym));
                     99:        sp->s_total = ht;
                    100:        ht &= HMASK;
                    101:        sp->s_sp = symhash[ht];
                    102:        symhash[ht] = sp;
                    103:        sp->s_kind = S_NEW;
                    104:        sp->s_type = E_ACON;
                    105:        sp->s_flag = S_SYMT;
                    106:        sp->s_addr = 0;
                    107:        symcopy(sp->s_id, id);
                    108:        return (sp);
                    109: }
                    110: 
                    111: /*
                    112:  * Compare two symbol names.
                    113:  */
                    114: symeq(p1, p2)
                    115: register char *p1, *p2;
                    116: {
                    117:        register n;
                    118: 
                    119:        n = NCPLN;
                    120:        do {
                    121:                if (*p1++ != *p2++)
                    122:                        return (0);
                    123:        } while (--n);
                    124:        return (1);
                    125: }

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