Return to aplmap.h CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / apl / src

Annotation of 43BSD/contrib/apl/src/aplmap.h, revision 1.1

1.1     ! root        1: static char aplmap_h_Sccsid[] = "aplmap.h @(#)aplmap.h 1.2     10/1/82 Berkeley ";
        !             2: #ifdef PURDUE_EE
        !             3: /*
        !             4:  *     Mapping arrays
        !             5:  *
        !             6:  * The following arrays perform character mapping between the APL
        !             7:  * character set (LSI modified by Peter Hallenbeck) and the ASCII
        !             8:  * character set.
        !             9:  *
        !            10:  */
        !            11: 
        !            12:        /* Map to the APL character set from ASCII */
        !            13: 
        !            14: char map_apl[] = {
        !            15:        '!',    /* does not map */
        !            16:        ' ',    /* does not map */
        !            17:        '(',    /* mapped pound sign (not equals) */
        !            18:        '$',    /* dollar sign maps to itself (.le.) */
        !            19:        '=',    /* mapped percent (division) */
        !            20:        '&',    /* & becomes .ge. automatically */
        !            21:        'K',    /* mapped single quote mark */
        !            22:        '+',    /* mapped opening parenthesis */
        !            23:        '`',    /* mapped closing parenthesis */
        !            24:        'P',    /* mapped asterisk */
        !            25:        ':',    /* mapped plus */
        !            26:        ',',    /* , maps to itself */
        !            27:        '*',    /* mapped minus */
        !            28:        '.',    /* . maps to itself */
        !            29:        '/',    /* / maps to itself */
        !            30:        '0','1','2','3','4','5','6','7','8','9',  /* all digits ok */
        !            31:        '>',    /* mapped colon */
        !            32:        '<',    /* mapped semi-colon */
        !            33:        '#',    /* mapped less-than */
        !            34:        '%',    /* mapped equals */
        !            35:        '\'',   /* mapped greater-than */
        !            36:        'Q',    /* mapped question-mark */
        !            37:        ' ',    /* @ does not map */
        !            38:        'A',    /* capital a maps to itself (alpha) */
        !            39:        'B',    /* capital b equals decode */
        !            40:        'C',    /* capital c equals inverted U */
        !            41:        'D',    /* capital d equals floot */
        !            42:        'E',    /* capital e equals epsilon */
        !            43:        'F',    /* capital f maps to itself (underscore) */
        !            44:        'G',    /* capital g equals del */
        !            45:        'H',    /* capital h equals interted del */
        !            46:        'I',    /* capital i equals iota */
        !            47:        'J',    /* capital j equals circle */
        !            48:        ' ',    /* capital k does not map */
        !            49:        'L',    /* capital l equals quad */
        !            50:        '-',    /* mapped multiply */
        !            51:        'N',    /* capital n equals encode */
        !            52:        'O',    /* capital o equals big circle */
        !            53:        '=',    /* mapped divide */
        !            54:        ')',    /* mapped "or" */
        !            55:        'R',    /* capital r equals rho */
        !            56:        'S',    /* capital s equals ceiling */
        !            57:        ' ',    /* capital t does not map */
        !            58:        'U',    /* capital u equals drop */
        !            59:        ')',    /* mapped "or" */
        !            60:        'W',    /* capital w equals omega */
        !            61:        '-',    /* capital x equals times sign */
        !            62:        'Y',    /* capital y equals take */
        !            63:        'Z',    /* capital z equals inverted subset symbol */
        !            64:        ';',    /* mapped open brace */
        !            65:        '?',    /* mapped backslash */
        !            66:        '@',    /* mapped closing brace */
        !            67:        '{',    /* mapped caret */
        !            68:        '\\',   /* mapped underscore */
        !            69:        '"',    /* raised minus */
        !            70:        'a','b','c','d','e','f','g','h','i','j','k','l','m',
        !            71:        'n','o','p','q','r','s','t','u','v','w','x','y','z',
        !            72:        '\\',   /* mapped open brace */
        !            73:        'M',    /* mapped mod (abs) */
        !            74:        '|',    /* mapped closing brace */
        !            75:        'T',    /* mapped "not" */
        !            76:        '\177'  /* delete maps to itself */
        !            77: };
        !            78: 
        !            79:        /* Map to ASCII from the APL character set */
        !            80: 
        !            81: char map_ascii[] = {
        !            82:        '!',
        !            83:        '`',
        !            84:        '<',
        !            85:        '$',
        !            86:        '=',
        !            87:        '&',
        !            88:        '>',
        !            89:        '#',
        !            90:        'V',
        !            91:        '-',
        !            92:        '(',
        !            93:        ',',
        !            94:        'X',
        !            95:        '.',
        !            96:        '/',
        !            97:        '0','1','2','3','4','5','6','7','8','9',
        !            98:        '+',
        !            99:        '[',
        !           100:        ';',
        !           101:        '%',
        !           102:        ':',
        !           103:        '\\',
        !           104:        ']',
        !           105:        'A',
        !           106:        'B',
        !           107:        'C',
        !           108:        'D',
        !           109:        'E',
        !           110:        'F',
        !           111:        'G',
        !           112:        'H',
        !           113:        'I',
        !           114:        'J',
        !           115:        '\'',
        !           116:        'L',
        !           117:        '|',
        !           118:        'N',
        !           119:        'O',
        !           120:        '*',
        !           121:        '?',
        !           122:        'R',
        !           123:        'S',
        !           124:        '~',
        !           125:        'U',
        !           126:        'V',
        !           127:        'W',
        !           128:        'X',
        !           129:        'Y',
        !           130:        'Z',
        !           131:        '$',
        !           132:        '{',
        !           133:        ']',
        !           134:        '\10',
        !           135:        '_',
        !           136:        ')',
        !           137:        'a','b','c','d','e','f','g','h','i','j','k','l','m',
        !           138:        'n','o','p','q','r','s','t','u','v','w','x','y','z',
        !           139:        '^',
        !           140:        '}',
        !           141:        '}',
        !           142:        ' ',
        !           143:        '\177',
        !           144: };
        !           145: #else
        !           146: /*
        !           147:  *     Mapping arrays
        !           148:  *
        !           149:  * The following arrays perform character mapping between the APL
        !           150:  * character set (Datamedia elite 1520) and the ASCII character
        !           151:  * set.  This is a typewriter-paired keyboard.
        !           152:  */
        !           153: 
        !           154:        /* Map to the APL character set from ASCII */
        !           155: 
        !           156: char map_apl[] = {
        !           157:        '!',    /* does not map */
        !           158:        ' ',    /* does not map */
        !           159:        '*',    /* mapped pound sign (not equals) */
        !           160:        '$',    /* dollar sign maps to itself (.le.) */
        !           161:        '+',    /* mapped percent (division) */
        !           162:        '^',    /* & becomes .ge. */
        !           163:        'K',    /* mapped single quote mark */
        !           164:        ':',    /* mapped opening parenthesis */
        !           165:        '"',    /* mapped closing parenthesis */
        !           166:        'P',    /* mapped asterisk */
        !           167:        '-',    /* mapped plus */
        !           168:        ',',    /* , maps to itself */
        !           169:        '_',    /* mapped minus */
        !           170:        '.',    /* . maps to itself */
        !           171:        '/',    /* / maps to itself */
        !           172:        '0','1','2','3','4','5','6','7','8','9',  /* all digits ok */
        !           173:        '>',    /* mapped colon */
        !           174:        '<',    /* mapped semi-colon */
        !           175:        '#',    /* mapped less-than */
        !           176:        '%',    /* mapped equals */
        !           177:        '&',    /* mapped greater-than */
        !           178:        'Q',    /* mapped question-mark */
        !           179:        ' ',    /* @ does not map */
        !           180:        'A',    /* capital a maps to itself (alpha) */
        !           181:        'B',    /* capital b equals decode */
        !           182:        'C',    /* capital c equals inverted U */
        !           183:        'D',    /* capital d equals floot */
        !           184:        'E',    /* capital e equals epsilon */
        !           185:        'F',    /* capital f maps to itself (underscore) */
        !           186:        'G',    /* capital g equals del */
        !           187:        'H',    /* capital h equals interted del */
        !           188:        'I',    /* capital i equals iota */
        !           189:        'J',    /* capital j equals circle */
        !           190:        ' ',    /* capital k does not map */
        !           191:        'L',    /* capital l equals quad */
        !           192:        '=',    /* mapped multiply */
        !           193:        'N',    /* capital n equals encode */
        !           194:        'O',    /* capital o equals big circle */
        !           195:        '+',    /* mapped divide */
        !           196:        '(',    /* mapped "or" */
        !           197:        'R',    /* capital r equals rho */
        !           198:        'S',    /* capital s equals ceiling */
        !           199:        ' ',    /* capital t does not map */
        !           200:        'U',    /* capital u equals drop */
        !           201:        '(',    /* mapped "or" */
        !           202:        'W',    /* capital w equals omega */
        !           203:        '=',    /* capital x equals times sign */
        !           204:        'Y',    /* capital y equals take */
        !           205:        'Z',    /* capital z equals inverted subset symbol */
        !           206:        ';',    /* mapped open bracket */
        !           207:        '?',    /* mapped backslash */
        !           208:        '\'',   /* mapped closing bracket */
        !           209:        ')',    /* mapped caret */
        !           210:        '[',    /* mapped underscore */
        !           211:        '@',    /* raised minus */
        !           212:        'a','b','c','d','e','f','g','h','i','j','k','l','m',
        !           213:        'n','o','p','q','r','s','t','u','v','w','x','y','z',
        !           214:        '[',    /* mapped open brace */
        !           215:        'M',    /* mapped mod (abs) */
        !           216:        ']',    /* mapped closing brace */
        !           217:        'T',    /* mapped "not" */
        !           218:        '\177'  /* delete maps to itself */
        !           219: };
        !           220: 
        !           221:        /* Map to ASCII from the APL character set */
        !           222: 
        !           223: char map_ascii[] = {
        !           224:        '!',
        !           225:        ')',
        !           226:        '<',
        !           227:        '$',
        !           228:        '=',
        !           229:        '>',
        !           230:        ']',
        !           231:        'V',
        !           232:        '^',
        !           233:        '#',
        !           234:        '%',
        !           235:        ',',
        !           236:        '+',
        !           237:        '.',
        !           238:        '/',
        !           239:        '0','1','2','3','4','5','6','7','8','9',
        !           240:        '(',
        !           241:        '[',
        !           242:        ';',
        !           243:        'X',
        !           244:        ':',
        !           245:        '\\',
        !           246:        '`',
        !           247:        'A',
        !           248:        'B',
        !           249:        'C',
        !           250:        'D',
        !           251:        'E',
        !           252:        'F',
        !           253:        'G',
        !           254:        'H',
        !           255:        'I',
        !           256:        'J',
        !           257:        '\'',
        !           258:        'L',
        !           259:        '|',
        !           260:        'N',
        !           261:        'O',
        !           262:        '*',
        !           263:        '?',
        !           264:        'R',
        !           265:        'S',
        !           266:        '~',
        !           267:        'U',
        !           268:        'V',
        !           269:        'W',
        !           270:        'X',
        !           271:        'Y',
        !           272:        'Z',
        !           273:        '{',
        !           274:        '{',
        !           275:        '}',
        !           276:        '&',
        !           277:        '-',
        !           278:        'J',
        !           279:        'a','b','c','d','e','f','g','h','i','j','k','l','m',
        !           280:        'n','o','p','q','r','s','t','u','v','w','x','y','z',
        !           281:        '{',
        !           282:        '}',
        !           283:        '}',
        !           284:        '$',
        !           285:        '\177',
        !           286: };
        !           287: #endif

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