Return to dtimep.lex CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / zotnet / tws

Annotation of 43BSDReno/contrib/mh/zotnet/tws/dtimep.lex, revision 1.1

1.1     ! root        1: %{
        !             2: #ifndef lint
        !             3: static char rcsid[] =
        !             4: #ifdef FLEX_SCANNER
        !             5:     "@(#) $Header: dtimep.lex,v 1.14 89/12/16 00:29:17 leres Locked $ (LBL) (flex generated scanner)";
        !             6: #else
        !             7:     "@(#) $Header: dtimep.lex,v 1.14 89/12/16 00:29:17 leres Locked $ (LBL) (lex generated scanner)";
        !             8: #endif
        !             9: #endif
        !            10: %}
        !            11: /*
        !            12: %e 2000
        !            13: %p 5000
        !            14: %n 1000
        !            15: %a 4000
        !            16:  */
        !            17: 
        !            18: %START Z
        !            19: sun    (sun(day)?)
        !            20: mon    (mon(day)?)
        !            21: tue    (tue(sday)?)
        !            22: wed    (wed(nesday)?)
        !            23: thu    (thu(rsday)?)
        !            24: fri    (fri(day)?)
        !            25: sat    (sat(urday)?)
        !            26: 
        !            27: DAY    ({sun}|{mon}|{tue}|{wed}|{thu}|{fri}|{sat})
        !            28: 
        !            29: jan    (jan(uary)?)
        !            30: feb    (feb(ruary)?)
        !            31: mar    (mar(ch)?)
        !            32: apr    (apr(il)?)
        !            33: may    (may)
        !            34: jun    (jun(e)?)
        !            35: jul    (jul(y)?)
        !            36: aug    (aug(ust)?)
        !            37: sep    (sep(tember)?)
        !            38: oct    (oct(ober)?)
        !            39: nov    (nov(ember)?)
        !            40: dec    (dec(ember)?)
        !            41: 
        !            42: MONTH  ({jan}|{feb}|{mar}|{apr}|{may}|{jun}|{jul}|{aug}|{sep}|{oct}|{nov}|{dec})
        !            43: 
        !            44: w      ([ \t]*)
        !            45: W      ([ \t]+)
        !            46: D      ([0-9]?[0-9])
        !            47: d      [0-9]
        !            48: %{
        !            49: #include "tws.h"
        !            50: #include <ctype.h>
        !            51: 
        !            52: /*
        !            53:  * Patchable flag that says how to interpret NN/NN/NN dates. When
        !            54:  * true, we do it European style: DD/MM/YY. When false, we do it
        !            55:  * American style: MM/DD/YY.
        !            56:  */
        !            57: int europeandate = 0;
        !            58: 
        !            59: /*
        !            60:  * Table to convert month names to numeric month.  We use the
        !            61:  * fact that the low order 5 bits of the sum of the 2nd & 3rd
        !            62:  * characters of the name is a hash with no collisions for the 12
        !            63:  * valid month names.  (The mask to 5 bits maps any combination of
        !            64:  * upper and lower case into the same hash value).
        !            65:  */
        !            66: static int month_map[] = {
        !            67:        0,
        !            68:        6,      /* 1 - Jul */
        !            69:        3,      /* 2 - Apr */
        !            70:        5,      /* 3 - Jun */
        !            71:        0,
        !            72:        10,     /* 5 - Nov */
        !            73:        0,
        !            74:        1,      /* 7 - Feb */
        !            75:        11,     /* 8 - Dec */
        !            76:        0,
        !            77:        0,
        !            78:        0,
        !            79:        0,
        !            80:        0,
        !            81:        0,
        !            82:        0,      /*15 - Jan */
        !            83:        0,
        !            84:        0,
        !            85:        0,
        !            86:        2,      /*19 - Mar */
        !            87:        0,
        !            88:        8,      /*21 - Sep */
        !            89:        0,
        !            90:        9,      /*23 - Oct */
        !            91:        0,
        !            92:        0,
        !            93:        4,      /*26 - May */
        !            94:        0,
        !            95:        7       /*28 - Aug */
        !            96: };
        !            97: /*
        !            98:  * Same trick for day-of-week using the hash function
        !            99:  *  (c1 & 7) + (c2 & 4)
        !           100:  */
        !           101: static int day_map[] = {
        !           102:        0,
        !           103:        0,
        !           104:        0,
        !           105:        6,      /* 3 - Sat */
        !           106:        4,      /* 4 - Thu */
        !           107:        0,
        !           108:        5,      /* 6 - Fri */
        !           109:        0,      /* 7 - Sun */
        !           110:        2,      /* 8 - Tue */
        !           111:        1       /* 9 - Mon */,
        !           112:        0,
        !           113:        3       /*11 - Wed */
        !           114: };
        !           115: #define SETDAY { tw.tw_wday= day_map[(cp[0] & 7) + (cp[1] & 4)];\
        !           116:                tw.tw_flags &= ~TW_SDAY; tw.tw_flags |= TW_SEXP;\
        !           117:                cp += 2; }
        !           118: #define SETMONTH { tw.tw_mon = month_map[(cp[0] + cp[1]) & 0x1f]; gotdate++;\
        !           119:                 cp += 2;\
        !           120:                 SKIPD;}
        !           121: #define CVT2   (i=(*cp++ - '0'),isdigit(*cp)? i*10 + (*cp++ - '0') : i)
        !           122: #define SKIPD  { while ( !isdigit(*cp++) ) ;  --cp; }
        !           123: #define EXPZONE        { tw.tw_flags &= ~TW_SZONE; tw.tw_flags |= TW_SZEXP; }
        !           124: #define ZONE(x)        { tw.tw_zone=(x); EXPZONE; }
        !           125: #define ZONED(x) { ZONE(x); tw.tw_flags |= TW_DST; }
        !           126: #define        LC(c)   (isupper(c) ? tolower(c) : (c))
        !           127: 
        !           128: #ifdef FLEX_SCANNER
        !           129: /* We get passed a string and return a pointer to a static tws struct */
        !           130: #undef YY_DECL
        !           131: #define YY_DECL struct tws *dparsetime(str) char *str;
        !           132: 
        !           133: /* We assume that we're never passed more than max_size characters */
        !           134: #undef YY_INPUT
        !           135: #define YY_INPUT(buf,result,max_size) \
        !           136:        if (gstr) { \
        !           137:                register char *xp; \
        !           138:                xp = gstr; \
        !           139:                while (isspace(*xp)) \
        !           140:                        xp++; \
        !           141:                gstr = xp; \
        !           142:                while (*xp != '\0') \
        !           143:                        ++xp; \
        !           144:                result = xp - gstr; \
        !           145:                bcopy(gstr, buf, result); \
        !           146:                gstr = 0; \
        !           147:        } else \
        !           148:                result = YY_NULL;
        !           149: 
        !           150: /* Date strings aren't usually very long */
        !           151: #undef YY_READ_BUF_SIZE
        !           152: #define YY_READ_BUF_SIZE 128
        !           153: 
        !           154: /* Use mh error reporting routine */
        !           155: #undef YY_FATAL_ERROR
        !           156: #define YY_FATAL_ERROR(s) adios("dparsetime()", s);
        !           157: 
        !           158: /* We need a pointer to the matched text we can modify */
        !           159: #undef YY_USER_ACTION
        !           160: #define YY_USER_ACTION cp = yytext
        !           161: 
        !           162: /* Used to initialize */
        !           163: static struct tws ztw = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        !           164: 
        !           165: /* Global for use by YY_INPUT() macro */
        !           166: static char *gstr;
        !           167: #endif
        !           168: 
        !           169: %}
        !           170: 
        !           171: %%
        !           172:                                        register int i, gotdate;
        !           173:                                        register char *cp;
        !           174:                                        static struct tws tw;
        !           175:                                        static void zonehack();
        !           176: 
        !           177:                                        BEGIN(INITIAL);
        !           178:                                        yy_init = 1;
        !           179:                                        tw = ztw;
        !           180:                                        gstr = str;
        !           181:                                        gotdate = 0;
        !           182: 
        !           183: {DAY}","?{w}                           SETDAY;
        !           184: "("{DAY}")"(","?)                      {
        !           185:                                        cp++;
        !           186:                                        SETDAY;
        !           187:                                        }
        !           188: 
        !           189: {D}"/"{D}"/"(19)?[0-9][0-9]{w}         {
        !           190:                                        if (europeandate) {
        !           191:                                                /* European: DD/MM/YY */
        !           192:                                                tw.tw_mday = CVT2;
        !           193:                                                cp++;
        !           194:                                                tw.tw_mon  = CVT2 - 1;
        !           195:                                        } else {
        !           196:                                                /* American: MM/DD/YY */
        !           197:                                                tw.tw_mon  = CVT2 - 1;
        !           198:                                                cp++;
        !           199:                                                tw.tw_mday = CVT2;
        !           200:                                        }
        !           201:                                        cp++;
        !           202:                                        for (i = 0; isdigit(*cp); )
        !           203:                                                i = i*10 + (*cp++ - '0');
        !           204:                                        tw.tw_year = i % 100;
        !           205:                                        gotdate++;
        !           206:                                        }
        !           207: {D}{w}(-)?{w}{MONTH}{w}(-)?{w}(19)?{D}{w}(\,{w}|at{W})? {
        !           208:                                        tw.tw_mday = CVT2;
        !           209:                                        while (!isalpha(*cp++))
        !           210:                                                ;
        !           211:                                        SETMONTH;
        !           212:                                        for (i = 0; isdigit(*cp); )
        !           213:                                                i = i*10 + (*cp++ - '0');
        !           214:                                        tw.tw_year = i % 100;
        !           215:                                        }
        !           216: {MONTH}{W}{D}","{W}(19)?{D}{w}         {
        !           217:                                        cp++;
        !           218:                                        SETMONTH;
        !           219:                                        tw.tw_mday = CVT2;
        !           220:                                        SKIPD;
        !           221:                                        for (i = 0; isdigit(*cp); )
        !           222:                                                i = i*10 + (*cp++ - '0');
        !           223:                                        tw.tw_year = i % 100;
        !           224:                                        }
        !           225: 
        !           226: {MONTH}{W}{D}{w}                       {
        !           227:                                        cp++;
        !           228:                                        SETMONTH;
        !           229:                                        tw.tw_mday = CVT2;
        !           230:                                        }
        !           231: 
        !           232: {D}:{D}:{D}{w}                         {
        !           233:                                        tw.tw_hour = CVT2; cp++;
        !           234:                                        tw.tw_min  = CVT2; cp++;
        !           235:                                        tw.tw_sec  = CVT2;
        !           236:                                        BEGIN Z;
        !           237:                                        }
        !           238: {D}:{D}{w}                             {
        !           239:                                        tw.tw_hour = CVT2; cp++;
        !           240:                                        tw.tw_min  = CVT2;
        !           241:                                        BEGIN Z;
        !           242:                                        }
        !           243: {D}:{D}{w}am{w}                                {
        !           244:                                        tw.tw_hour = CVT2; cp++;
        !           245:                                        if (tw.tw_hour == 12)
        !           246:                                                tw.tw_hour = 0;
        !           247:                                        tw.tw_min  = CVT2;
        !           248:                                        BEGIN Z;
        !           249:                                        }
        !           250: {D}:{D}{w}pm{w}                                {
        !           251:                                        tw.tw_hour = CVT2; cp++;
        !           252:                                        if (tw.tw_hour != 12)
        !           253:                                                tw.tw_hour += 12;
        !           254:                                        tw.tw_min  = CVT2;
        !           255:                                        BEGIN Z;
        !           256:                                        }
        !           257: [0-2]{d}{d}{d}{d}{d}{w}                        {
        !           258:                                        tw.tw_hour = CVT2;
        !           259:                                        tw.tw_min  = CVT2;
        !           260:                                        tw.tw_sec  = CVT2;
        !           261:                                        BEGIN Z;
        !           262:                                        }
        !           263: 19[6-9]{d}{w}                          {
        !           264:                                        /*
        !           265:                                         * Luckly, 4 digit times in the range
        !           266:                                         * 1960-1999 aren't legal as hour
        !           267:                                         * and minutes. This rule must come
        !           268:                                         * the 4 digit hour and minute rule.
        !           269:                                         */
        !           270:                                        cp += 2;
        !           271:                                        tw.tw_year = CVT2;
        !           272:                                        }
        !           273: [0-2]{d}{d}{d}{w}                      {
        !           274:                                        tw.tw_hour = CVT2;
        !           275:                                        tw.tw_min  = CVT2;
        !           276:                                        BEGIN Z;
        !           277:                                        }
        !           278: <Z>"-"?ut                              ZONE(0 * 60);
        !           279: <Z>"-"?gmt                             ZONE(0 * 60);
        !           280: <Z>"-"?jst                             ZONE(2 * 60);
        !           281: <Z>"-"?jdt                             ZONED(2 * 60);
        !           282: <Z>"-"?est                             ZONE(-5 * 60);
        !           283: <Z>"-"?edt                             ZONED(-5 * 60);
        !           284: <Z>"-"?cst                             ZONE(-6 * 60);
        !           285: <Z>"-"?cdt                             ZONED(-6 * 60);
        !           286: <Z>"-"?mst                             ZONE(-7 * 60);
        !           287: <Z>"-"?mdt                             ZONED(-7 * 60);
        !           288: <Z>"-"?pst                             ZONE(-8 * 60);
        !           289: <Z>"-"?pdt                             ZONED(-8 * 60);
        !           290: <Z>"-"?nst                             ZONE(-(3 * 60 + 30));
        !           291: <Z>"-"?ast                             ZONE(-4 * 60);
        !           292: <Z>"-"?adt                             ZONED(-4 * 60);
        !           293: <Z>"-"?yst                             ZONE(-9 * 60);
        !           294: <Z>"-"?ydt                             ZONED(-9 * 60);
        !           295: <Z>"-"?hst                             ZONE(-10 * 60);
        !           296: <Z>"-"?hdt                             ZONED(-10 * 60);
        !           297: <Z>"-"?bst                             ZONED(-1 * 60);
        !           298: <Z>[a-i]                               {
        !           299:                                        tw.tw_zone = 60 * (('a'-1) - LC(*cp));
        !           300:                                        EXPZONE; 
        !           301:                                        }
        !           302: <Z>[k-m]                               {
        !           303:                                        tw.tw_zone = 60 * ('a' - LC(*cp));
        !           304:                                        EXPZONE; 
        !           305:                                        }
        !           306: <Z>[n-y]                               {
        !           307:                                        tw.tw_zone = 60 * (LC(*cp) - 'm');
        !           308:                                        EXPZONE; 
        !           309:                                        }
        !           310: <Z>"+"[0-1]{d}{d}{d}                   {
        !           311:                                        cp++;
        !           312:                                        tw.tw_zone = ((cp[0] * 10 + cp[1])
        !           313:                                                     -('0' * 10   + '0'))*60
        !           314:                                                    +((cp[2] * 10 + cp[3])
        !           315:                                                     -('0' * 10   + '0'));
        !           316: #ifdef DSTXXX
        !           317:                                        zonehack (&tw);
        !           318: #endif DSTXXX
        !           319:                                        cp += 4;
        !           320:                                        EXPZONE; 
        !           321:                                        }
        !           322: <Z>"-"[0-1]{d}{d}{d}                   {
        !           323:                                        cp++;
        !           324:                                        tw.tw_zone = (('0' * 10   + '0')
        !           325:                                                     -(cp[0] * 10 + cp[1]))*60
        !           326:                                                    +(('0' * 10   + '0')
        !           327:                                                     -(cp[2] * 10 + cp[3]));
        !           328: #ifdef DSTXXX
        !           329:                                        zonehack (&tw);
        !           330: #endif DSTXXX
        !           331:                                        cp += 4;
        !           332:                                        EXPZONE; 
        !           333:                                        }
        !           334: 
        !           335: \n                                     |
        !           336: {W}                                    ;
        !           337: 
        !           338: <INITIAL,Z><<EOF>>                     return(&tw);
        !           339: 
        !           340: .                                      {
        !           341:                                        /*
        !           342:                                         * We jammed; it's an error if we
        !           343:                                         * didn't parse anything.
        !           344:                                         */
        !           345:                                        if (!gotdate || tw.tw_year == 0)
        !           346:                                                return(0);
        !           347:                                        return(&tw);
        !           348:                                        }
        !           349: 
        !           350: %%
        !           351: 
        !           352: #ifdef DSTXXX
        !           353: #include <sys/types.h>
        !           354: #ifndef        BSD42
        !           355: #include <time.h>
        !           356: #else  BSD42
        !           357: #include <sys/time.h>
        !           358: #endif BSD42
        !           359: 
        !           360: static void
        !           361: zonehack(tw)
        !           362:     register struct tws *tw;
        !           363: {
        !           364:     register struct tm *tm;
        !           365: 
        !           366:     if (twclock (tw) == -1L)
        !           367:        return;
        !           368: 
        !           369:     tm = localtime (&tw -> tw_clock);
        !           370:     if (tm -> tm_isdst) {
        !           371:        tw -> tw_flags |= TW_DST;
        !           372:        tw -> tw_zone -= 60;
        !           373:     }
        !           374: }
        !           375: #endif DSTXXX

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