Return to keywd.c CVS log

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

Annotation of 43BSD/contrib/icon/lib/keywd.c, revision 1.1

1.1     ! root        1: #include "../h/rt.h"
        !             2: #include "../h/keyword.h"
        !             3: #ifdef SYSTIME
        !             4: #include <sys/time.h>
        !             5: #else SYSTIME
        !             6: #include <time.h>
        !             7: #endif SYSTIME
        !             8: #include <sys/types.h>
        !             9: #include <sys/times.h>
        !            10: 
        !            11: static char *day[] = {
        !            12:    "Sunday", "Monday", "Tuesday", "Wednesday",
        !            13:    "Thursday", "Friday", "Saturday"
        !            14:    };
        !            15: 
        !            16: static char *month[] = {
        !            17:    "January", "February", "March", "April", "May", "June",
        !            18:    "July", "August", "September", "October", "November", "December"
        !            19:    };
        !            20: 
        !            21: /*
        !            22:  * keywd - process keyword.
        !            23:  */
        !            24: 
        !            25: keywd(nargs, arg1)
        !            26: int nargs;
        !            27: struct descrip arg1;
        !            28:    {
        !            29:    register int hour, i;
        !            30:    register char *merid;
        !            31:    char sbuf[MAXSTRING];
        !            32:    struct tm *tbuf, *localtime();
        !            33:    struct tms tp;
        !            34:    long time(), clock, runtim;
        !            35:    char *alcstr();
        !            36: 
        !            37:    SetBound;
        !            38: 
        !            39:    /*
        !            40:     * This is just plug and chug code.  For whatever keyword is desired,
        !            41:     *  the appropriate value is dug out of the system and made into
        !            42:     *  a suitable Icon value.
        !            43:     *
        !            44:     * A few special cases are worth noting:
        !            45:     *  &fail - calls fail();
        !            46:     *  &pos, &random, &trace - trapped variables are made for possible
        !            47:     *   subsequent assignments.
        !            48:     */
        !            49:    switch (INTVAL(arg1)) {
        !            50:       case K_ASCII:
        !            51:          arg1.type = D_CSET;
        !            52:          BLKLOC(arg1) = (union block *) &k_ascii;
        !            53:          break;
        !            54:       case K_CLOCK:
        !            55:          sneed(8);
        !            56:          time(&clock);
        !            57:          tbuf = localtime(&clock);
        !            58:          sprintf(sbuf,"%02d:%02d:%02d",tbuf->tm_hour,tbuf->tm_min,tbuf->tm_sec);
        !            59:          STRLEN(arg1) = 8;
        !            60:          STRLOC(arg1) = alcstr(sbuf,8);
        !            61:          break;
        !            62:       case K_CSET:
        !            63:          arg1.type = D_CSET;
        !            64:          BLKLOC(arg1) = (union block *) &k_cset;
        !            65:          break;
        !            66:       case K_DATE:
        !            67:          sneed(10);
        !            68:          time(&clock);
        !            69:          tbuf = localtime(&clock);
        !            70:          sprintf(sbuf, "%04d/%02d/%02d",
        !            71:                       (tbuf->tm_year)+1900,tbuf->tm_mon+1,tbuf->tm_mday);
        !            72:          STRLEN(arg1) = 10;
        !            73:          STRLOC(arg1) = alcstr(sbuf,10);
        !            74:          break;
        !            75:       case K_DATELINE:
        !            76:          time(&clock);
        !            77:          tbuf = localtime(&clock);
        !            78:          if ((hour = tbuf->tm_hour) >= 12) {
        !            79:             merid = "pm";
        !            80:             if (hour > 12)
        !            81:                hour -= 12;
        !            82:             }
        !            83:          else {
        !            84:             merid = "am";
        !            85:             if (hour < 1)
        !            86:                hour += 12;
        !            87:             }
        !            88:          sprintf(sbuf, "%s, %s %d, %d  %d:%02d %s",
        !            89:                  day[tbuf->tm_wday], month[tbuf->tm_mon], tbuf->tm_mday,
        !            90:                  1900 + tbuf->tm_year, hour, tbuf->tm_min, merid);
        !            91:          sneed(i = strlen(sbuf));
        !            92:          STRLEN(arg1) = i;
        !            93:          STRLOC(arg1) = alcstr(sbuf, i);
        !            94:          break;
        !            95:       case K_ERROUT:
        !            96:          arg1.type = D_FILE;
        !            97:          BLKLOC(arg1) = (union block *) &k_errout;
        !            98:          break;
        !            99:       case K_FAIL:
        !           100:          fail();
        !           101:          break;
        !           102:       case K_HOST:
        !           103:          iconhost(sbuf);
        !           104:          sneed(i = strlen(sbuf));
        !           105:          STRLEN(arg1) = i;
        !           106:          STRLOC(arg1) = alcstr(sbuf, i);
        !           107:          break;
        !           108:       case K_INPUT:
        !           109:          arg1.type = D_FILE;
        !           110:          BLKLOC(arg1) = (union block *) &k_input;
        !           111:          break;
        !           112:       case K_LCASE:
        !           113:          arg1.type = D_CSET;
        !           114:          BLKLOC(arg1) = (union block *) &k_lcase;
        !           115:          break;
        !           116:       case K_LEVEL:
        !           117:          arg1.type = D_INTEGER;
        !           118:          INTVAL(arg1) = k_level;
        !           119:          break;
        !           120:       case K_MAIN:
        !           121:          arg1 = k_main;
        !           122:          break;
        !           123:       case K_NULL:
        !           124:          arg1 = nulldesc;
        !           125:          break;
        !           126:       case K_OUTPUT:
        !           127:          arg1.type = D_FILE;
        !           128:          BLKLOC(arg1) = (union block *) &k_output;
        !           129:          break;
        !           130:       case K_POS:
        !           131:          arg1.type = D_TVPOS;
        !           132:          INTVAL(arg1) = k_pos;
        !           133:          break;
        !           134:       case K_RANDOM:
        !           135:          arg1.type = D_TVRAND;
        !           136:          BLKLOC(arg1) = (union block *) &k_random;
        !           137:          break;
        !           138:       case K_SOURCE:
        !           139:          arg1 = BLKLOC(current)->estack.activator;
        !           140:          break;
        !           141:       case K_SUBJECT:
        !           142:          arg1.type = D_VAR;
        !           143:          BLKLOC(arg1) = (union block *) &k_subject;
        !           144:          break;
        !           145:       case K_TIME:
        !           146:          times(&tp);
        !           147:          runtim =
        !           148:            1000 * ((tp.tms_utime - starttime) / (double)HZ);
        !           149:          mkint(runtim, &arg1);
        !           150:          break;
        !           151:       case K_TRACE:
        !           152:          arg1.type = D_TVTRACE;
        !           153:          INTVAL(arg1) = k_trace;
        !           154:          break;
        !           155:       case K_UCASE:
        !           156:          arg1.type = D_CSET;
        !           157:          BLKLOC(arg1) = (union block *) &k_ucase;
        !           158:          break;
        !           159:       case K_VERSION:
        !           160:          sneed(i = strlen(VERSION));
        !           161:          STRLEN(arg1) = i;
        !           162:          STRLOC(arg1) = VERSION;
        !           163:          break;
        !           164:       case K_OPTIONS:
        !           165:          sneed(i = strlen(OPTIONS));
        !           166:          STRLEN(arg1) = i;
        !           167:          STRLOC(arg1) = OPTIONS;
        !           168:          break;
        !           169:       default:
        !           170:          syserr("keyword: unknown keyword type.");
        !           171:       }
        !           172:    ClearBound;
        !           173:    }

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