[Chapter Sixteen][Previous] [Next] [Art of Assembly][Randall Hyde]

Art of Assembly: Chapter Sixteen


16.8.2 - Processing Dates

16.8.2 Processing Dates


Another useful program that converts English text to numeric form is a date processor. A date processor takes strings like "Jan 23, 1997" and converts it to three integer values representing the month, day, and year. Of course, while we're at it, it's easy enough to modify the grammar for date strings to allow the input string to take any of the following common date formats:




		Jan 23, 1997
		January 23, 1997
		23 Jan, 1997
		23 January, 1997
		1/23/97
		1-23-97
		1/23/1997
		1-23-1997

In each of these cases the date processing routines should store one into the variable month, 23 into the variable day, and 1997 into the year variable (we will assume all years are in the range 1900-1999 if the string supplies only two digits for the year). Of course, we could also allow dates like "January twenty-third, nineteen hundred and ninety seven" by using an number processing parser similar to the one presented in the previous section. However, that is an exercise left to the reader.

The grammar to process dates is





Date 		EngMon Integer Integer |

		Integer EngMon Integer |

		Integer / Integer / Integer |

		Integer - Integer - Integer



EngMon 		JAN | JANUARY | FEB | FEBRUARY |  | DEC | DECEMBER

Integer 		digit Integer | digit

digit  		0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

We will use some semantic rules to place some restrictions on these strings. For example, the grammar above allows integers of any size; however, months must fall in the range 1-12 and days must fall in the range 1-28, 1-29, 1-30, or 1-31 depending on the year and month. Years must fall in the range 0-99 or 1900-1999.

Here is the 80x86 code for this grammar:





; datepat.asm
;
; This program converts dates of various formats to a three integer
; component value- month, day, and year.

                .xlist
                .286
                include                 stdlib.a
                includelib              stdlib.lib
                matchfuncs
                .list
                .lall


dseg            segment para public 'data'

; The following three variables hold the result of the conversion.

month           word    0
day             word    0
year            word    0

; StrPtr is a double word value that points at the string under test.
; The output routines use this variable. It is declared as two word
; values so it is easier to store es:di into it.

strptr          word    0,0

; Value is a generic variable the ConvertInt routine uses

value           word    0



; Number of valid days in each month (Feb is handled specially)

DaysInMonth     byte    31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31



; Some sample strings to test the date conversion routines.

Str0            byte    "Feb 4, 1956",0
Str1            byte    "July 20, 1960",0
Str2            byte    "Jul 8, 1964",0
Str3            byte    "1/1/97",0
Str4            byte    "1-1-1997",0
Str5            byte    "12-25-74",0
Str6            byte    "3/28/1981",0
Str7            byte    "January 1, 1999",0
Str8            byte    "Feb 29, 1996",0
Str9            byte    "30 June, 1990",0
Str10           byte    "August 7, 1945",0
Str11           byte    "30 September, 1992",0
Str12           byte    "Feb 29, 1990",0
Str13           byte    "29 Feb, 1992",0



; The following grammar is what we use to process the dates
;
; Date  ->      EngMon Integer Integer
;       |       Integer EngMon Integer
;       |       Integer "/" Integer "/" Integer
;       |       Integer "-" Integer "-" Integer
;
; EngMon->      Jan | January | Feb | February | ... | Dec | December
; Integer->     digit integer | digit
; digit ->      0 | 1 | ... | 9
;
; Some semantic rules this code has to check:
;
; If the year is in the range 0-99, this code has to add 1900 to it.
; If the year is not in the range 0-99 or 1900-1999 then return an error.
; The month must be in the range 1-12, else return an error.
; The day must be between one and 28, 29, 30, or 31. The exact maximum
; day depends on the month.


separators      pattern {spancset, delimiters}


; DatePat processes dates of the form "MonInEnglish Day Year"

DatePat         pattern {sl_match2, EngMon, DatePat2, DayYear}
DayYear         pattern {sl_match2, DayInteger, 0, YearPat}
YearPat         pattern {sl_match2, YearInteger}

; DatePat2 processes dates of the form "Day MonInEng Year"

DatePat2        pattern {sl_match2, DayInteger, DatePat3, MonthYear}
MonthYear       pattern {sl_match2, EngMon, 0, YearPat}

; DatePat3 processes dates of the form "mm-dd-yy"

DatePat3        pattern {sl_match2, MonInteger, DatePat4, DatePat3a}
DatePat3a       pattern {sl_match2, separators, DatePat3b, DatePat3b}
DatePat3b       pattern {matchchar, '-', 0, DatePat3c}
DatePat3c       pattern {sl_match2, DayInteger, 0, DatePat3d}
DatePat3d       pattern {sl_match2, separators, DatePat3e, DatePat3e}
DatePat3e       pattern {matchchar, '-', 0, DatePat3f}
DatePat3f       pattern {sl_match2, YearInteger}

; DatePat4 processes dates of the form "mm/dd/yy"

DatePat4        pattern {sl_match2, MonInteger, 0, DatePat4a}
DatePat4a       pattern {sl_match2, separators, DatePat4b, DatePat4b}
DatePat4b       pattern {matchchar, '/', 0, DatePat4c}
DatePat4c       pattern {sl_match2, DayInteger, 0, DatePat4d}
DatePat4d       pattern {sl_match2, separators, DatePat4e, DatePat4e}
DatePat4e       pattern {matchchar, '/', 0, DatePat4f}
DatePat4f       pattern {sl_match2, YearInteger}


; DayInteger matches an decimal string, converts it to an integer, and
; stores the result away in the Day variable.

DayInteger      pattern {sl_match2, Integer, 0, SetDayPat}
SetDayPat       pattern {SetDay}

; MonInteger matches an decimal string, converts it to an integer, and
; stores the result away in the Month variable.

MonInteger      pattern {sl_match2, Integer, 0, SetMonPat}
SetMonPat       pattern {SetMon}

; YearInteger matches an decimal string, converts it to an integer, and
; stores the result away in the Year variable.


YearInteger     pattern {sl_match2, Integer, 0, SetYearPat}
SetYearPat      pattern {SetYear}


; Integer skips any leading delimiter characters and then matches a
; decimal string. The Integer0 pattern matches exactly the decimal
; characters; the code does a patgrab on Integer0 when converting
; this string to an integer.

Integer         pattern {sl_match2, separators, 0, Integer0}
Integer0        pattern {sl_match2, number, 0, Convert2Int}
number          pattern {anycset, digits, 0, number2}
number2         pattern {spancset, digits}
Convert2Int     pattern {ConvertInt}




; A macro to make it easy to declare each of the 24 English month
; patterns (24 because we allow the full month name and an
; abbreviation).

MoPat           macro   name, next, str, str2, value
                local SetMo, string, full, short, string2, doMon

name            pattern {sl_match2, short, next}
short           pattern {matchistr, string2, full, SetMo}
full            pattern {matchistr, string, 0, SetMo}

string          byte str
                byte    0

string2         byte    str2
                byte    0

SetMo           pattern {MonthVal, value}
                endm


; EngMon is a chain of patterns that match one of the strings
; JAN, JANUARY, FEB, FEBRUARY, etc. The last parameter to the
; MoPat macro is the month number.

EngMon          pattern {sl_match2, separators, jan, jan}
                MoPat   jan, feb, "JAN", "JANUARY", 1
                MoPat   feb, mar, "FEB", "FEBRUARY", 2
                MoPat   mar, apr, "MAR", "MARCH", 3
                MoPat   apr, may, "APR", "APRIL", 4
                MoPat   may, jun, "MAY", "MAY", 5
                MoPat   jun, jul, "JUN", "JUNE", 6
                MoPat   jul, aug, "JUL", "JULY", 7
                MoPat   aug, sep, "AUG", "AUGUST", 8
                MoPat   sep, oct, "SEP", "SEPTEMBER", 9
                MoPat   oct, nov, "OCT", "OCTOBER", 10
                MoPat   nov, decem, "NOV", "NOVEMBER", 11
                MoPat   decem, 0, "DEC", "DECEMBER", 12




; We use the "digits" and "delimiters" sets from the standard library.

                include stdsets.a

dseg            ends



cseg            segment para public 'code'
                assume  cs:cseg, ds:dseg


; ConvertInt-   Matches a sequence of digits and converts them to an integer.

ConvertInt      proc    far
                push    ds
                push    es
                push    di
                mov     ax, dseg
                mov     ds, ax

                lesi Integer0           ;Integer0 contains the decimal
                patgrab                 ; string we matched, grab that
                atou                    ; string and convert it to an
                mov     Value, ax       ; integer and save the result.
                free                    ;Free mem allocated by patgrab.

                pop     di
                mov     ax, di          ;Required by sl_match.
                pop     es
                pop     ds
                stc                     ;Always succeed.
                ret

ConvertInt      endp


; SetDay, SetMon, and SetYear simply copy value to the appropriate
; variable.

SetDay          proc    far
                push    ds
                mov     ax, dseg
                mov     ds, ax
                mov     ax, value
                mov     day, ax
                mov     ax, di
                pop     ds
                stc
                ret
SetDay          endp


SetMon          proc    far
                push    ds
                mov     ax, dseg
                mov     ds, ax
                mov     ax, value
                mov     Month, ax
                mov     ax, di
                pop     ds
                stc
                ret
SetMon          endp


SetYear         proc    far
                push    ds
                mov     ax, dseg
                mov     ds, ax
                mov     ax, value
                mov     Year, ax
                mov     ax, di
                pop     ds
                stc
                ret
SetYear         endp


; MonthVal is a pattern used by the English month patterns.
; This pattern function simply copies the matchparm field to
; the month variable (the matchparm field is passed in si).

MonthVal        proc    far
                push    ds
                mov     ax, dseg
                mov     ds, ax
                mov     Month, si
                mov     ax, di
                pop     ds
                stc
                ret
MonthVal        endp



; ChkDate-      Checks a date to see if it is valid. Returns with the
;               carry flag set if it is, clear if not.

ChkDate         proc    far
                push    ds
                push    ax
                push    bx

                mov     ax, dseg
                mov     ds, ax

; If the year is in the range 0-99, add 1900 to it.
; Then check to see if it's in the range 1900-1999.

                cmp     Year, 100
                ja      Notb100
                add     Year, 1900
Notb100:        cmp     Year, 2000
                jae     BadDate
                cmp     Year, 1900
                jb      BadDate

; Okay, make sure the month is in the range 1-12

                cmp     Month, 12
                ja      BadDate
                cmp     Month, 1
                jb      BadDate

; See if the number of days is correct for all months except Feb:

                mov     bx, Month
                mov     ax, Day                 ;Make sure Day <> 0.
                test    ax, ax
                je      BadDate
                cmp     ah, 0                   ;Make sure Day < 256.
                jne     BadDate

                cmp     bx, 2                   ;Handle Feb elsewhere.
                je      DoFeb
                cmp     al, DaysInMonth[bx-1]   ;Check against max val.
                ja      BadDate
                jmp     GoodDate

; Kludge to handle leap years. Note that 1900 is *not* a leap year.

DoFeb:          cmp     ax, 29                  ;Only applies if day is
                jb      GoodDate                ; equal to 29.
                ja      BadDate                 ;Error if Day > 29.
                mov     bx, Year                ;1900 is not a leap year
                cmp     bx, 1900                ; so handle that here.
                je      BadDate
                and     bx, 11b                 ;Else, Year mod 4 is a
                jne     BadDate                 ; leap year.

GoodDate:       pop     bx
                pop     ax
                pop     ds
                stc
                ret

BadDate:        pop     bx
                pop     ax
                pop     ds
                clc
                ret
ChkDate         endp


; ConvertDate-  ES:DI contains a pointer to a string containing a valid
;               date. This routine converts that date to the three
;               integer values found in the Month, Day, and Year
;               variables. Then it prints them to verify the pattern
;               matching routine.

ConvertDate     proc    near

                ldxi    DatePat
                xor     cx, cx
                match
                jnc     NoMatch

                mov     strptr, di              ;Save string pointer for
                mov     strptr+2, es            ; use by printf

                call    ChkDate                 ;Validate the date.
                jnc     NoMatch

                printf
                byte    "%-20^s = Month: %2d Day: %2d Year: %4d\n",0
                dword   strptr, Month, Day, Year
                jmp     Done

NoMatch:        printf
                byte    "Illegal date ('%^s')",cr,lf,0
                dword   strptr

Done:           ret
ConvertDate     endp




Main            proc
                mov     ax, dseg
                mov     ds, ax
                mov     es, ax

                meminit                         ;Init memory manager.

; Call ConvertDate to test several different date strings.

                lesi    Str0
                call    ConvertDate
                lesi    Str1
                call    ConvertDate
                lesi    Str2
                call    ConvertDate
                lesi    Str3
                call    ConvertDate
                lesi    Str4
                call    ConvertDate
                lesi    Str5
                call    ConvertDate
                lesi    Str6
                call    ConvertDate
                lesi    Str7
                call    ConvertDate
                lesi    Str8
                call    ConvertDate
                lesi    Str9
                call    ConvertDate
                lesi    Str10
                call    ConvertDate
                lesi    Str11
                call    ConvertDate
                lesi    Str12
                call    ConvertDate
                lesi    Str13
                call    ConvertDate


Quit:           ExitPgm
Main            endp

cseg            ends

sseg            segment para stack 'stack'
stk             db      1024 dup ("stack ")
sseg            ends

zzzzzzseg       segment para public 'zzzzzz'
LastBytes       db      16 dup (?)
zzzzzzseg       ends
                end     Main

Sample Output:





Feb 4, 1956 			= Month:  2 Day:  4 Year: 1956
July 20, 1960 			= Month:  7 Day: 20 Year: 1960
Jul 8, 1964 			= Month:  7 Day:  8 Year: 1964
1/1/97 			= Month:  1 Day:  1 Year: 1997
1-1-1997 			= Month:  1 Day:  1 Year: 1997
12-25-74 			= Month: 12 Day: 25 Year: 1974
3/28/1981 			= Month:  3 Day: 28 Year: 1981
January 1, 1999 			= Month:  1 Day:  1 Year: 1999
Feb 29, 1996 			= Month:  2 Day: 29 Year: 1996
30 June, 1990 			= Month:  6 Day: 30 Year: 1990
August 7, 1945 			= Month:  8 Day:  7 Year: 1945
30 September, 1992 			= Month:  9 Day: 30 Year: 1992
Illegal date ('Feb 29, 1990')
29 Feb, 1992 			= Month:  2 Day: 29 Year: 1992
16.8.2 - Processing Dates


Art of Assembly: Chapter Sixteen - 29 SEP 1996

[Chapter Sixteen][Previous] [Next] [Art of Assembly][Randall Hyde]



Number of Web Site Hits since Jan 1, 2000: