Return to map.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / icon / functions

Annotation of 43BSD/contrib/icon/functions/map.c, revision 1.1.1.1

1.1       root        1: #include "../h/rt.h"
                      2: 
                      3: /*
                      4:  * map(s1,s2,s3) - map s1, using s2 and s3.
                      5:  */
                      6: Xmap(nargs, arg3, arg2, arg1, arg0)
                      7: int nargs;
                      8: struct descrip arg3, arg2, arg1, arg0;
                      9:    {
                     10:    register int i;
                     11:    register char *s1, *s2, *s3;
                     12:    char sbuf1[MAXSTRING], sbuf2[MAXSTRING], sbuf3[MAXSTRING];
                     13:    static char maptab[MAXSTRING];
                     14:    extern char *alcstr();
                     15: 
                     16:    /*
                     17:     * s1 must be a string; s2 and s3 default to &ucase and &lcase,
                     18:     *  respectively.
                     19:     */
                     20:    if (cvstr(&arg1, sbuf1) == NULL)
                     21:       runerr(103, &arg1);
                     22:    defany(&arg2, &ucase);
                     23:    defany(&arg3, &lcase);
                     24: 
                     25:    /*
                     26:     * If s2 and s3 are the same as for the last call of map,
                     27:     *  the some old values, namely maps2, maps3, and maptab
                     28:     *  can be reused.  Otherwise, the information must be
                     29:     *  recomputed.
                     30:     */
                     31:    if (maps2.type != arg2.type || maps3.type != arg3.type ||
                     32:        BLKLOC(maps2) != BLKLOC(arg2) || BLKLOC(maps3) != BLKLOC(arg3)) {
                     33:       maps2 = arg2;
                     34:       maps3 = arg3;
                     35:       /*
                     36:        * s2 and s3 must be strings and of the same length.
                     37:        */
                     38:       if (cvstr(&arg2, sbuf2) == NULL)
                     39:          runerr(103, &arg2);
                     40:       if (cvstr(&arg3, sbuf3) == NULL)
                     41:          runerr(103, &arg3);
                     42:       if (STRLEN(arg2) != STRLEN(arg3))
                     43:          runerr(208, NULL);
                     44:       /*
                     45:        * The array maptab is used to perform the mapping.  First, maptab[i]
                     46:        *  is initialized with i for i from 0 to MAXSTRING-1 (256).  Then,
                     47:        *  the for each character in s2, the position in maptab corresponding
                     48:        *  the value of the character is assigned the value of the character
                     49:        *  in s3 that is in the same ordinal position as the character from s2.
                     50:        *  For example, if s2 is "abc", and s3 is "123", the assignments are:
                     51:        *   maptab['a'] = '1'
                     52:        *   maptab['b'] = '2'
                     53:        *   maptab['c'] = '3'
                     54:        *  Note that the 0..256 (really should be 0..255!) initialization
                     55:        *   causes unmapped characters to be themselves, for example,
                     56:        *   maptab['d'] == 'd'.
                     57:        */
                     58:       s2 = STRLOC(arg2);
                     59:       s3 = STRLOC(arg3);
                     60:       for (i = MAXSTRING - 1; i >= 0; i--)
                     61:          maptab[i] = i;
                     62:       for (i = 0; i < STRLEN(arg2); i++)
                     63:          maptab[s2[i]&0377] = s3[i];
                     64:       }
                     65: 
                     66:    if (STRLEN(arg1) == 0) {
                     67:       arg0.type = D_NULL;
                     68:       INTVAL(arg0) = 1;
                     69:       return;
                     70:       }
                     71: 
                     72:    /*
                     73:     * The result is a string the size of s1, so ensure that much space.
                     74:     */
                     75:    i = STRLEN(arg1);
                     76:    sneed(i);
                     77:    s1 = STRLOC(arg1);
                     78: 
                     79:    /*
                     80:     * Create the result string, but specify no value for it.
                     81:     */
                     82:    STRLEN(arg0) = i;
                     83:    STRLOC(arg0) = s2 = alcstr(NULL, i);
                     84:    /*
                     85:     * Buzz through the string using values in maptab to do the mapping.
                     86:     */
                     87:    while (i-- > 0)
                     88:       *s2++ = maptab[(*s1++)&0377];
                     89:    }
                     90: 
                     91: Procblock(map,3)

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