FreeUDFLibC/FreeUDFLibC.def010064400017510000016000000014360703640203200167020ustar00gdeatzsysadmin00002170145441LIBRARY FreeUDFLibC DESCRIPTION 'FreeUDFLibC.dll' READ WRITE EXPORTS add_month add_year age_in_months age_in_weeks cdow_long cdow_short cmonth_long cmonth_short day_of_month day_of_week day_of_year is_leap_year max_date min_date month quarter strip_date strip_time str_to_time week_of_year woy year year_of_year convert_from_33 convert_to_33 convert_from_base convert_to_base convert_to_dollar double_abs fixed_point integer_abs modulo round truncate character crlf encrypt_md5 find_word find_word_index left line_wrap l_trim lr_trim mid pad_left pad_right proper_case replace right r_trim string_length strip_string substr soundex FreeUDFLibC/Makefile010064400017510000016000000057020703640203100157070ustar00gdeatzsysadmin00002170145441# --------------------------------------------------------------------- # FreeUDFLibC - copyright (c) 1999 Gregory Deatz # --------------------------------------------------------------------- # --------------------------------------------------------------------- # InterBase Installation Directory # # CHANGE this definition to point to your InterBase installation directory # --------------------------------------------------------------------- IBASE= /usr/interbase IB_VERSION=IB55 #IB_VERSION=IB50 (for 5.0 and lower) #IB_VERSION=IB60 (for 6.0 and higher) # --------------------------------------------------------------------- # General InterBase Defines for SOLARIS # --------------------------------------------------------------------- GPRE= $(IBASE)/bin/gpre -c -n GPRE_M= $(IBASE)/bin/gpre -c -n -m ISQL= $(IBASE)/bin/isql # --------------------------------------------------------------------- # General Compiler and linker Defines for SOLARIS # --------------------------------------------------------------------- CC= gcc LINK= gcc LIB_LINK= ld CFLAGS= -D$(IB_VERSION) -munaligned-doubles -fpic -O -c -w -I$(IBASE)/include LINK_FLAGS= -lgdsmt -lsocket -lthread -lnsl -ldl LIB_LINK_FLAGS= -G -Bsymbolic -lgdsmt -lib_util -lm -lc RM= rm -f # --------------------------------------------------------------------- # Generic Compilation Rules # # Do NOT change anything below this point. # --------------------------------------------------------------------- .SUFFIXES: .o .c .e .e.c: ${GPRE} $< -d ${DB} .c.o: ${CC} $< ${CFLAGS} -o $@ .o: ${LINK} -o $@ $< ${LINK_FLAGS} # --------------------------------------------------------------------- # The UDF objects and the MD5 Test objects # --------------------------------------------------------------------- MD5Test_OBJs = md5c.o mddriver.o UDF_OBJs = date_functions.o math_functions.o string_functions.o md5c.o install: FreeUDFLibC @echo "------------------------------------------------------" @echo "You need to copy FreeUDFLib to the interbase lib " @echo "directory in order for the server to load it. " @echo "------------------------------------------------------" @echo "I can do this automagically for you, but you'll need" @echo "to type the password for root below. If you don't" @echo "trust me, then just bomb out of this and to install" @echo "type something like this (while logged in as root):" @echo " cp FreeUDFLibC /usr/interbase/lib" @echo "------------------------------------------------------" @echo echo 'cp FreeUDFLibC ${IBASE}/lib' | su all: FreeUDFLibC MD5Test FreeUDFLibC: ${UDF_OBJs} ${LIB_LINK} ${UDF_OBJs} -o $@ ${LIB_LINK_FLAGS} MD5Test: ${MD5Test_OBJs} ${LINK} ${MD5Test_OBJs} -o $@ ${LINK_FLAGS} clean: rm -f MD5Test.exe MD5Test FreeUDFLibC *.o *~ date_functions.o: date_functions.h global.h math_functions.o: math_functions.h global.h string_functions.o: string_functions.h global.h md5_global.h md5.h md5c.o: md5.h md5_global.h mddriver.o: md5.h global.h FreeUDFLibC/Makefile.Linux010064400017510000016000000056400703640203200170070ustar00gdeatzsysadmin00002170145441# --------------------------------------------------------------------- # FreeUDFLibC - copyright (c) 1999 Gregory Deatz # --------------------------------------------------------------------- # --------------------------------------------------------------------- # InterBase Installation Directory # # CHANGE this definition to point to your InterBase installation directory # --------------------------------------------------------------------- IBASE=/usr/interbase # (for 5.5 and higher) #IB_VERSION=IB55 # (for 5.0 and lower) IB_VERSION=IB50 # (for 6.0 and lower) #IB_VERSION=IB60 # --------------------------------------------------------------------- # General InterBase Defines for SOLARIS # --------------------------------------------------------------------- GPRE=$(IBASE)/bin/gpre -c -n GPRE_M=$(IBASE)/bin/gpre -c -n -m ISQL=$(IBASE)/bin/isql # --------------------------------------------------------------------- # General Compiler and linker Defines for SOLARIS # --------------------------------------------------------------------- CC=gcc LINK=gcc LIB_LINK=ld CFLAGS=-D$(IB_VERSION) -fpic -O -c -w -I$(IBASE)/include LINK_FLAGS=-lgds -lsocket -lthread -lnsl -ldl LIB_LINK_FLAGS=-G -Bsymbolic -lgds -lm -lc RM=rm -f # --------------------------------------------------------------------- # Generic Compilation Rules # # Do NOT change anything below this point. # --------------------------------------------------------------------- .SUFFIXES: .o .c .e .e.c: $(GPRE) $< -d $(DB) .c.o: $(CC) $< $(CFLAGS) -o $@ .o: $(LINK) -o $@ $< $(LINK_FLAGS) # --------------------------------------------------------------------- # The UDF objects and the MD5 Test objects # --------------------------------------------------------------------- MD5Test_OBJs = md5c.o mddriver.o UDF_OBJs = date_functions.o math_functions.o string_functions.o md5c.o install: FreeUDFLibC @echo "------------------------------------------------------" @echo "You need to copy FreeUDFLib to the interbase lib " @echo "directory in order for the server to load it. " @echo "------------------------------------------------------" @echo "I can do this automagically for you, but you'll need" @echo "to type the password for root below. If you don't" @echo "trust me, then just bomb out of this and to install" @echo "type something like this (while logged in as root):" @echo " cp FreeUDFLibC /usr/interbase/lib" @echo "------------------------------------------------------" @echo echo 'cp FreeUDFLibC $(IBASE)/lib' | su all: FreeUDFLibC MD5Test FreeUDFLibC: $(UDF_OBJs) $(LIB_LINK) $(UDF_OBJs) -o $@ $(LIB_LINK_FLAGS) MD5Test: $(MD5Test_OBJs) $(LINK) $(MD5Test_OBJs) -o $@ $(LINK_FLAGS) clean: rm -f MD5Test.exe MD5Test FreeUDFLibC *.o *~ date_functions.o: date_functions.h global.h math_functions.o: math_functions.h global.h string_functions.o: string_functions.h global.h md5_global.h md5.h md5c.o: md5.h md5_global.h mddriver.o: md5.h global.hFreeUDFLibC/Makefile.Solaris010064400017510000016000000057020703640203100173220ustar00gdeatzsysadmin00002170145441# --------------------------------------------------------------------- # FreeUDFLibC - copyright (c) 1999 Gregory Deatz # --------------------------------------------------------------------- # --------------------------------------------------------------------- # InterBase Installation Directory # # CHANGE this definition to point to your InterBase installation directory # --------------------------------------------------------------------- IBASE= /usr/interbase IB_VERSION=IB55 #IB_VERSION=IB50 (for 5.0 and lower) #IB_VERSION=IB60 (for 6.0 and higher) # --------------------------------------------------------------------- # General InterBase Defines for SOLARIS # --------------------------------------------------------------------- GPRE= $(IBASE)/bin/gpre -c -n GPRE_M= $(IBASE)/bin/gpre -c -n -m ISQL= $(IBASE)/bin/isql # --------------------------------------------------------------------- # General Compiler and linker Defines for SOLARIS # --------------------------------------------------------------------- CC= gcc LINK= gcc LIB_LINK= ld CFLAGS= -D$(IB_VERSION) -munaligned-doubles -fpic -O -c -w -I$(IBASE)/include LINK_FLAGS= -lgdsmt -lsocket -lthread -lnsl -ldl LIB_LINK_FLAGS= -G -Bsymbolic -lgdsmt -lib_util -lm -lc RM= rm -f # --------------------------------------------------------------------- # Generic Compilation Rules # # Do NOT change anything below this point. # --------------------------------------------------------------------- .SUFFIXES: .o .c .e .e.c: ${GPRE} $< -d ${DB} .c.o: ${CC} $< ${CFLAGS} -o $@ .o: ${LINK} -o $@ $< ${LINK_FLAGS} # --------------------------------------------------------------------- # The UDF objects and the MD5 Test objects # --------------------------------------------------------------------- MD5Test_OBJs = md5c.o mddriver.o UDF_OBJs = date_functions.o math_functions.o string_functions.o md5c.o install: FreeUDFLibC @echo "------------------------------------------------------" @echo "You need to copy FreeUDFLib to the interbase lib " @echo "directory in order for the server to load it. " @echo "------------------------------------------------------" @echo "I can do this automagically for you, but you'll need" @echo "to type the password for root below. If you don't" @echo "trust me, then just bomb out of this and to install" @echo "type something like this (while logged in as root):" @echo " cp FreeUDFLibC /usr/interbase/lib" @echo "------------------------------------------------------" @echo echo 'cp FreeUDFLibC ${IBASE}/lib' | su all: FreeUDFLibC MD5Test FreeUDFLibC: ${UDF_OBJs} ${LIB_LINK} ${UDF_OBJs} -o $@ ${LIB_LINK_FLAGS} MD5Test: ${MD5Test_OBJs} ${LINK} ${MD5Test_OBJs} -o $@ ${LINK_FLAGS} clean: rm -f MD5Test.exe MD5Test FreeUDFLibC *.o *~ date_functions.o: date_functions.h global.h math_functions.o: math_functions.h global.h string_functions.o: string_functions.h global.h md5_global.h md5.h md5c.o: md5.h md5_global.h mddriver.o: md5.h global.h FreeUDFLibC/date_functions.c010064400017510000016000000300410703640217200174200ustar00gdeatzsysadmin00002170145441/* * FreeUDFLibC - copyright (c) 1999 Gregory Deatz * * date_functions.c * Date and time routines: * add_month - add some number of months to a date * add_year - add some number of years to a date * age_in_months - Between "date" and "ref_date", how many months? * age_in_weeks - Between "date" and "ref_date", how many weeks? * cdow_long - Convert the date to a "long" pretty version * cdow_short - Convert the date to a "short" pretty version * cmonth_long - What is the long name of the month? * cmonth_short - What is the short name of the month? * day_of_month - What is the day of the month? * day_of_week - What is the day of the week? * day_of_year - What is the day of the year? * is_leap_year - Is it leap year? * max_date - Compare two dates and return the maximum. * min_date - Compare two dates and return the minimum. * month - What is the month? * quarter - What is the quarter? * strip_date - Strip the date portion of the date * strip_time - Strip the time portion of the date * str_to_time - Given a time string (hh:mm:ss AM/PM) return date of it * week_of_year - What is the week of the year? * woy - Return the year and the week concatenated (199901) * year - What is the year? * year_of_year - Given a date, return the year as it would * be returned from the week_of_year function. * hour, minute, second - Given a date, return the "hour", "minute", * "second" of the date. */ #include #include "global.h" #include "date_functions.h" static ISC_QUAD * gen_ib_date PROTO_LIST ((struct tm *)); static void i_week_of_year PROTO_LIST ((ISC_QUAD *, int *, int *)); #define SUNDAY 0 #define MONDAY 1 #define TUESDAY 2 #define WEDNESDAY 3 #define THURSDAY 4 #define FRIDAY 5 #define SATURDAY 6 #define JANUARY 0 #define FEBRUARY 1 #define MARCH 2 #define APRIL 3 #define MAY 4 #define JUNE 5 #define JULY 6 #define AUGUST 7 #define SEPTEMBER 8 #define OCTOBER 9 #define NOVEMBER 10 #define DECEMBER 11 static char * LONGDOW[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; static char * SHORTDOW[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; static char * LONGMONTH[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; static char * SHORTMONTH[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; ISC_QUAD * add_month (ib_date, months_to_add) ISC_QUAD *ib_date; int *months_to_add; { struct tm t; int tm_mon, tm_year; isc_decode_date (ib_date, &t); tm_mon = t.tm_mon + (*months_to_add % 12); tm_year = t.tm_year + (*months_to_add / 12); if ((*months_to_add > 0) && (tm_mon < t.tm_mon)) tm_year++; else if ((*months_to_add < 0) && (tm_mon > t.tm_mon)) tm_year--; /* * Now, check that the month day is correctly adjusted. * 30 days has Sep, Apr, Jun, Nov all the rest have 31 except Feb */ if (tm_mon != FEBRUARY) { if (t.tm_mday > 30) switch (tm_mon) { case APRIL: case JUNE: case SEPTEMBER: case NOVEMBER: t.tm_mday = 30; } } else if (t.tm_mday > 28) t.tm_mday = isleap(tm_year) ? 29 : 28; t.tm_mon = tm_mon; t.tm_year = tm_year; return (ISC_QUAD *) gen_ib_date(&t); } ISC_QUAD * add_year (ib_date, years_to_add) ISC_QUAD *ib_date; int *years_to_add; { struct tm t; isc_decode_date(ib_date, &t); t.tm_year += *years_to_add; /* * If it's February, and the day of the month is 29, and * it's *not* a leap year, then adjust the day */ if (t.tm_mon == FEBRUARY && t.tm_mday > 28 && !isleap(t.tm_year)) t.tm_mday = 28; return (ISC_QUAD *) gen_ib_date(&t); } int age_in_months (ib_date, ib_ref_date) ISC_QUAD *ib_date; ISC_QUAD *ib_ref_date; { struct tm t, t_ref; isc_decode_date(ib_date, &t); isc_decode_date(ib_ref_date, &t_ref); return ((t.tm_year - t_ref.tm_year) * 12) + t.tm_mon - t_ref.tm_mon; } /* * Bases it's computation on the fact that they year has * an *average* of 52 weeks. So this is most certainly an * approximate function, but I'm quite confident that it is * a reasonably precise function. */ int age_in_weeks (ib_date, ib_ref_date) ISC_QUAD *ib_date; ISC_QUAD *ib_ref_date; { struct tm t, t_ref; isc_decode_date(ib_date, &t); isc_decode_date(ib_ref_date, &t_ref); return ((t.tm_year - t_ref.tm_year) * 52) + (((t.tm_yday - t.tm_wday) - (t_ref.tm_yday - t_ref.tm_wday)) / 7); } char * cdow_long (ib_date) ISC_QUAD *ib_date; { struct tm t; char * result = (char *) MALLOC (LOC_STRING_SIZE); isc_decode_date(ib_date, &t); sprintf(result, "%s", LONGDOW[t.tm_wday]); return (char *) result; } char * cdow_short (ib_date) ISC_QUAD *ib_date; { struct tm t; char * result = (char *) MALLOC (LOC_STRING_SIZE); isc_decode_date(ib_date, &t); sprintf(result, "%s", SHORTDOW[t.tm_wday]); return (char *) result; } char * cmonth_long (ib_date) ISC_QUAD *ib_date; { struct tm t; char * result = (char *) MALLOC (LOC_STRING_SIZE); isc_decode_date(ib_date, &t); sprintf(result, "%s", LONGMONTH[t.tm_mon]); return (char *) result; } char * cmonth_short (ib_date) ISC_QUAD *ib_date; { struct tm t; char * result = (char *) MALLOC (LOC_STRING_SIZE); isc_decode_date(ib_date, &t); sprintf(result, "%s", SHORTMONTH[t.tm_mon]); return (char *) result; } int day_of_month (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return t.tm_mday; } int day_of_week (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return t.tm_wday + 1; } int day_of_year (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return t.tm_yday + 1; } int is_leap_year (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return isleap(t.tm_year); } ISC_QUAD * max_date (ib_date_1, ib_date_2) ISC_QUAD *ib_date_1; ISC_QUAD *ib_date_2; { ISC_QUAD * result = (ISC_QUAD *) MALLOC(sizeof(ISC_QUAD)); if ((ib_date_1->isc_quad_high > ib_date_2->isc_quad_high) || ((ib_date_1->isc_quad_high == ib_date_2->isc_quad_high) && (ib_date_1->isc_quad_low > ib_date_2->isc_quad_low))) *result = *ib_date_1; else *result = *ib_date_2; return result; } ISC_QUAD * min_date (ib_date_1, ib_date_2) ISC_QUAD *ib_date_1; ISC_QUAD *ib_date_2; { ISC_QUAD * result = (ISC_QUAD *) MALLOC(sizeof(ISC_QUAD)); if ((ib_date_1->isc_quad_high < ib_date_2->isc_quad_high) || ((ib_date_1->isc_quad_high == ib_date_2->isc_quad_high) && (ib_date_1->isc_quad_low < ib_date_2->isc_quad_low))) *result = *ib_date_1; else *result = *ib_date_2; return result; } int month (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return t.tm_mon + 1; } int quarter (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return (t.tm_mon / 4) + 1; } ISC_QUAD * strip_date (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); t.tm_mday = 0; t.tm_mon = 0; t.tm_year = 0; t.tm_wday = 0; t.tm_yday = 0; return gen_ib_date(&t); } ISC_QUAD * strip_time (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); t.tm_sec = 0; t.tm_min = 0; t.tm_hour = 0; t.tm_isdst = 0; return gen_ib_date(&t); } ISC_QUAD * str_to_time (sz) char *sz; { struct tm t; char *sz_work; int len = strlen(sz); int h, m, s, pm, i; ISC_QUAD * result = (ISC_QUAD *) MALLOC(sizeof(ISC_QUAD)); i = 0; h = strtol(sz, NULL, 10); while (i < len && (sz[i] != ':')) i++; i++; if (i < len) { m = strtol(&sz[i], NULL, 10); while (i < len && (sz[i] != ':')) i++; i++; } else m = 0; if (i < len) s = strtol(&sz[i], NULL, 10); else s = 0; pm = len >= 2 ? (strcmp(&sz[len - 2], "AM")) : 0; t.tm_sec = s; t.tm_min = m; if (pm) t.tm_hour = (h + ((h == 12) ? 0 : 12)) % 24; else t.tm_hour = (h + ((h == 12) ? 12 : 0)) % 24; t.tm_mday = 0; t.tm_mon = 0; t.tm_year = 0; t.tm_wday = 0; t.tm_yday = 0; t.tm_isdst = 0; isc_encode_date(&t, result); return result; } int week (ib_date) ISC_QUAD *ib_date; { struct tm t; int dow_ybeg, yr, wk; isc_decode_date(ib_date, &t); yr = t.tm_year + 1900; /* On what day of the week did the year begin? */ dow_ybeg = ((t.tm_wday + 7) - (t.tm_yday % 7)) % 7; wk = ((t.tm_yday - t.tm_wday + 7) / 7) + 1; if (dow_ybeg == SUNDAY) return wk - 1; else return wk; } int week_of_year (ib_date) ISC_QUAD *ib_date; { int week, year; i_week_of_year(ib_date, &week, &year); return week; } char * woy (ib_date) ISC_QUAD *ib_date; { char * result = (char *) MALLOC (LOC_STRING_SIZE + 1); int week, year; i_week_of_year(ib_date, &week, &year); sprintf(result, "%d%2d", year, week); return result; } int year (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return t.tm_year + 1900; } int year_of_year (ib_date) ISC_QUAD *ib_date; { int week, year; i_week_of_year(ib_date, &week, &year); return year; } int hour (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return t.tm_hour; } int minute (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return t.tm_min; } int second (ib_date) ISC_QUAD *ib_date; { struct tm t; isc_decode_date(ib_date, &t); return t.tm_sec; } static ISC_QUAD * gen_ib_date (t) struct tm *t; { ISC_QUAD *ibd = (ISC_QUAD *) MALLOC (sizeof(ISC_QUAD)); isc_encode_date(t, ibd); return ibd; } /* * Simple observations: * 7 * 52 = 364 = a common year + 1 (or 2 if it is a leap year) * There are 365-366 days in the year. * A week is Sunday - Saturday. * So.... * * if the year begins on a Sun - Wed, then Jan 1 is considered to begin * Week #1. * if the year begins on Thu - Sat, then Jan 1 is considered to still * be part of the last week of the previous year. * if the year begins on a Wed OR * the year begins on a Tue or Wed and its a leap year THEN * the year has 53 weeks in it... */ static void i_week_of_year (ib_date, week, year) ISC_QUAD * ib_date; int * week; int * year; { struct tm t; int dow_ybeg, yr, wk; isc_decode_date(ib_date, &t); yr = t.tm_year + 1900; /* When did the year begin? */ dow_ybeg = ((t.tm_wday + 7) - (t.tm_yday % 7)) % 7; /* Get the Sunday beginning this week. */ wk = (t.tm_yday - t.tm_wday); /* * If the Sunday beginning this week was last year, then * if this year begins on a Wednesday or previous, then * this is most certainly the first week of the year. * if this year begins on a thursday or * last year was a leap year and this year begins on a friday, then * this week is 53 of last year. * Otherwise this week is 52 of last year. */ if (wk < 0) { if (dow_ybeg <= WEDNESDAY) wk = 1; else if ((dow_ybeg == THURSDAY) || (isleap((yr - 1)) && (dow_ybeg == FRIDAY))) { wk = 53; yr--; } else { wk = 52; yr--; } } else { /* If the Sunday beginning this week falls in this year * if the year begins on a Sun, Mon, Tue or Wed then * This week # is (Week + 7) div 7 * otherwise this week is * Week div 7 + 1. * if the week is > 52 then * if this year began on a wed or this year is leap year and it * began on a tuesday, then set the week to 53. * otherwise set the week to 1 of *next* year. */ if (dow_ybeg <= WEDNESDAY) wk = (wk + 7 + dow_ybeg) / 7; else wk = (wk / 7) + 1; if (wk > 52) { if ((dow_ybeg == WEDNESDAY) || (isleap(yr) && (dow_ybeg == TUESDAY))) wk = 53; else { wk = 1; yr++; } } } *week = wk; *year = yr; } ((t.tm_year - t_ref.tm_year) * 52) + (((t.tm_yday - t.tm_wday) - (t_ref.tm_yday - t_ref.tm_wday)) / 7); } char * cdow_long (ib_date) ISC_QUAD *ib_date; { struct tm t; char * result = (char *) MALLOC (LOC_STRING_SIZE); isc_decode_date(ib_date, &t); sprintf(result, "%s", LONGDOW[t.tm_wday]); return (char *) result; } char * cdow_short (ib_date) ISC_QUAD *ib_date; { struct tm t; char * result = (char *) MALLOC (LOC_STRING_SIZE); FreeUDFLibC/date_functions.h010064400017510000016000000057150703640203200174320ustar00gdeatzsysadmin00002170145441/* * FreeUDFLibC - copyright (c) 1999 Gregory Deatz * * date_functions.c * Date and time routines: * add_month - add some number of months to a date * add_year - add some number of years to a date * age_in_months - Between "date" and "ref_date", how many months? * age_in_weeks - Between "date" and "ref_date", how many weeks? * cdow_long - Convert the date to a "long" pretty version * cdow_short - Convert the date to a "short" pretty version * cmonth_long - What is the long name of the month? * cmonth_short - What is the short name of the month? * day_of_month - What is the day of the month? * day_of_week - What is the day of the week? * day_of_year - What is the day of the year? * is_leap_year - Is it leap year? * max_date - Compare two dates and return the maximum. * min_date - Compare two dates and return the minimum. * month - What is the month? * quarter - What is the quarter? * strip_date - Strip the date portion of the date * strip_time - Strip the time portion of the date * str_to_time - Given a time string (hh:mm:ss AM/PM) return date of it * week - What is the week of the year? * Jan 1 is *always* in week 1. * week_of_year - What is the week of the year? * Jan 1 might sometimes be in week 52 of prev. year. * woy - Return the year and the week concatenated (199901) * year - What is the year? * year_of_year - Given a date, return the year as it would * be returned from the week_of_year function. * hour, minute, second - Given a date, return the "hour", "minute", * "second" of the date. */ ISC_QUAD * add_month PROTO_LIST ((ISC_QUAD *, int *)); ISC_QUAD * add_year PROTO_LIST ((ISC_QUAD *, int *)); int age_in_months PROTO_LIST ((ISC_QUAD *, ISC_QUAD *)); int age_in_weeks PROTO_LIST ((ISC_QUAD *, ISC_QUAD *)); char * cdow_long PROTO_LIST ((ISC_QUAD *)); char * cdow_short PROTO_LIST ((ISC_QUAD *)); char * cmonth_long PROTO_LIST ((ISC_QUAD *)); char * cmonth_short PROTO_LIST ((ISC_QUAD *)); int day_of_month PROTO_LIST ((ISC_QUAD *)); int day_of_week PROTO_LIST ((ISC_QUAD *)); int day_of_year PROTO_LIST ((ISC_QUAD *)); int is_leap_year PROTO_LIST ((ISC_QUAD *)); ISC_QUAD * max_date PROTO_LIST ((ISC_QUAD *, ISC_QUAD *)); ISC_QUAD * min_date PROTO_LIST ((ISC_QUAD *, ISC_QUAD *)); int month PROTO_LIST ((ISC_QUAD *)); int quarter PROTO_LIST ((ISC_QUAD *)); ISC_QUAD * strip_date PROTO_LIST ((ISC_QUAD *)); ISC_QUAD * strip_time PROTO_LIST ((ISC_QUAD *)); ISC_QUAD * str_to_time PROTO_LIST ((char *)); int week PROTO_LIST((ISC_QUAD *)); int week_of_year PROTO_LIST ((ISC_QUAD *)); char * woy PROTO_LIST ((ISC_QUAD *)); int year PROTO_LIST ((ISC_QUAD *)); int year_of_year PROTO_LIST ((ISC_QUAD *)); int hour PROTO_LIST ((ISC_QUAD *)); int minute PROTO_LIST ((ISC_QUAD *)); int second PROTO_LIST ((ISC_QUAD *)); FreeUDFLibC/global.h010064400017510000016000000014720703640202700156650ustar00gdeatzsysadmin00002170145441/* * FreeUDFLibC - copyright (c) 1999 Gregory Deatz * * global.h */ #include "ibase.h" #ifdef IB55 #include "ib_util.h" #define MALLOC ib_util_malloc #else #ifdef IB60 #include "ib_util.h" #define MALLOC ib_util_malloc #else #define MALLOC malloc #endif #endif #define LOC_STRING_SIZE 256 #define VERSION "0.6" #define RELEASE "1999-Jul-12" /* PROTOTYPES should be set to one if and only if the compiler supports function argument prototyping. The following makes PROTOTYPES default to 0 if it has not already been defined with C compiler flags. */ #ifndef PROTOTYPES #define PROTOTYPES 0 #endif #ifndef PROTO_LIST #if PROTOTYPES #define PROTO_LIST(list) list #else #define PROTO_LIST(list) () #endif #endif #ifndef isleap #define isleap(y) (((y) % 4) == 0 && ((y) % 100) != 0 || ((y) % 400) == 0) #endif FreeUDFLibC/ib_declarations.sql010064400017510000016000000176260703640202700201270ustar00gdeatzsysadmin00002170145441/* * FreeUDFLibC - copyright (c) 1999 Gregory Deatz * * Declarations script for all FreeUDFLib UDFs. */ /* String functions */ declare external function f_character integer returns cstring(2) free_it entry_point 'character' module_name 'FreeUDFLibC'; declare external function f_crlf returns cstring(3) free_it entry_point 'crlf' module_name 'FreeUDFLibC'; declare external function f_encrypt_md5 cstring(128) returns cstring(33) free_it entry_point 'encrypt_md5' module_name 'FreeUDFLibC'; declare external function f_find_word cstring(256), integer returns cstring(33) free_it entry_point 'find_word' module_name 'FreeUDFLibC'; declare external function f_find_word_index cstring(256), integer returns integer by value entry_point 'find_word_index' module_name 'FreeUDFLibC'; declare external function f_left cstring(256), integer returns cstring(256) free_it entry_point 'left' module_name 'FreeUDFLibC'; declare external function f_line_wrap cstring(256), integer, integer returns cstring(256) free_it entry_point 'line_wrap' module_name 'FreeUDFLibC'; declare external function f_l_trim cstring(256) returns cstring(256) free_it entry_point 'l_trim' module_name 'FreeUDFLibC'; declare external function f_lr_trim cstring(256) returns cstring(256) free_it entry_point 'lr_trim' module_name 'FreeUDFLibC'; declare external function f_mid cstring(256), integer, integer returns cstring(256) free_it entry_point 'mid' module_name 'FreeUDFLibC'; declare external function f_pad_left cstring(256), cstring(16), integer returns cstring(256) free_it entry_point 'pad_left' module_name 'FreeUDFLibC'; declare external function f_pad_right cstring(256), cstring(16), integer returns cstring(256) free_it entry_point 'pad_right' module_name 'FreeUDFLibC'; declare external function f_proper_case cstring(256) returns cstring(256) free_it entry_point 'proper_case' module_name 'FreeUDFLibC'; declare external function f_replace cstring(256), cstring(16), cstring(16) returns cstring(256) free_it entry_point 'replace' module_name 'FreeUDFLibC'; declare external function f_right cstring(256), integer returns cstring(256) free_it entry_point 'right' module_name 'FreeUDFLibC'; declare external function f_r_trim cstring(256) returns cstring(256) free_it entry_point 'r_trim' module_name 'FreeUDFLibC'; declare external function f_soundex cstring(256) returns cstring(6) free_it entry_point 'soundex' module_name 'FreeUDFLibC'; declare external function f_string_length cstring(256) returns integer by value entry_point 'string_length' module_name 'FreeUDFLibC'; declare external function f_strip_string cstring(256), cstring(64) returns cstring(256) free_it entry_point 'strip_string' module_name 'FreeUDFLibC'; declare external function f_substr cstring(256), cstring(32) returns integer by value entry_point 'substr' module_name 'FreeUDFLibC'; /* * Math routines */ declare external function f_convert_from_33 cstring(32) returns integer by value entry_point 'convert_from_33' module_name 'FreeUDFLibC'; declare external function f_convert_to_33 integer returns cstring(32) free_it entry_point 'convert_to_33' module_name 'FreeUDFLibC'; declare external function f_convert_from_base cstring(32), integer, cstring(8) returns integer by value entry_point 'convert_from_base' module_name 'FreeUDFLibC'; declare external function f_convert_to_base integer, integer, cstring(8) returns cstring(32) free_it entry_point 'convert_to_base' module_name 'FreeUDFLibC'; declare external function f_convert_to_dollar double precision returns cstring(32) free_it entry_point 'convert_to_dollar' module_name 'FreeUDFLibC'; declare external function f_double_abs double precision returns double precision by value entry_point 'double_abs' module_name 'FreeUDFLibC'; declare external function f_fixed_point double precision, integer returns cstring(32) free_it entry_point 'fixed_point' module_name 'FreeUDFLibC'; declare external function f_integer_abs integer returns integer by value entry_point 'integer_abs' module_name 'FreeUDFLibC'; declare external function f_modulo integer, integer returns integer by value entry_point 'modulo' module_name 'FreeUDFLibC'; declare external function f_round double precision returns integer by value entry_point 'round' module_name 'FreeUDFLibC'; declare external function f_truncate double precision returns integer by value entry_point 'truncate' module_name 'FreeUDFLibC'; /* * Date and time routines */ declare external function f_add_month date, integer returns date free_it entry_point 'add_month' module_name 'FreeUDFLibC'; declare external function f_add_year date, integer returns date free_it entry_point 'add_year' module_name 'FreeUDFLibC'; declare external function f_age_in_months date, date returns integer by value entry_point 'age_in_months' module_name 'FreeUDFLibC'; declare external function f_age_in_weeks date, date returns integer by value entry_point 'age_in_weeks' module_name 'FreeUDFLibC'; declare external function f_cdow_long date returns cstring(16) free_it entry_point 'cdow_long' module_name 'FreeUDFLibC'; declare external function f_cdow_short date returns cstring(4) free_it entry_point 'cdow_short' module_name 'FreeUDFLibC'; declare external function f_cmonth_long date returns cstring(16) free_it entry_point 'cmonth_long' module_name 'FreeUDFLibC'; declare external function f_cmonth_short date returns cstring(4) free_it entry_point 'cmonth_short' module_name 'FreeUDFLibC'; declare external function f_day_of_month date returns integer by value entry_point 'day_of_month' module_name 'FreeUDFLibC'; declare external function f_day_of_week date returns integer by value entry_point 'day_of_week' module_name 'FreeUDFLibC'; declare external function f_day_of_year date returns integer by value entry_point 'day_of_year' module_name 'FreeUDFLibC'; declare external function f_is_leap_year date returns integer by value entry_point 'is_leap_year' module_name 'FreeUDFLibC'; declare external function f_max_date date, date returns date free_it entry_point 'max_date' module_name 'FreeUDFLibC'; declare external function f_min_date date, date returns date free_it entry_point 'min_date' module_name 'FreeUDFLibC'; declare external function f_month date returns integer by value entry_point 'month' module_name 'FreeUDFLibC'; declare external function f_quarter date returns integer by value entry_point 'quarter' module_name 'FreeUDFLibC'; declare external function f_strip_date date returns date free_it entry_point 'strip_date' module_name 'FreeUDFLibC'; declare external function f_strip_time date returns date free_it entry_point 'strip_time' module_name 'FreeUDFLibC'; declare external function f_str_to_time cstring(12) returns date free_it entry_point 'str_to_time' module_name 'FreeUDFLibC'; declare external function f_week date returns integer by value entry_point 'week' module_name 'FreeUDFLibC'; declare external function f_week_of_year date returns integer by value entry_point 'week_of_year' module_name 'FreeUDFLibC'; declare external function f_woy date returns cstring(8) free_it entry_point 'woy' module_name 'FreeUDFLibC'; declare external function f_year date returns integer by value entry_point 'year' module_name 'FreeUDFLibC'; declare external function f_year_of_year date returns integer by value entry_point 'year_of_year' module_name 'FreeUDFLibC'; declare external function f_hour date returns integer by value entry_point 'hour' module_name 'FreeUDFLibC'; declare external function f_minute date returns integer by value entry_point 'minute' module_name 'FreeUDFLibC'; declare external function f_second date returns integer by value entry_point 'second' module_name 'FreeUDFLibC'; FreeUDFLibC/ib_test.sql010064400017510000016000000107160703640203100164220ustar00gdeatzsysadmin00002170145441/* * FreeUDFLibC - copyright (c) 1999 Gregory Deatz * * Test all UDFs with some standard calls. */ /* String functions */ /* f_character */ select 'c', f_character(99) from rdb$database; /* f_crlf */ select f_crlf() from rdb$database; /* f_encrypt_md5 */ select '0cc175b9c0f1b6a831c399e269772661', f_encrypt_md5('a') from rdb$database; /* f_find_word */ select 'hello', f_find_word('hello world', 0) from rdb$database; /* f_find_word_index */ select 0, f_find_word_index('hello world', 0) from rdb$database; /* f_left */ select 'hello', f_left('hello world', 5) from rdb$database; /* f_line_wrap */ select 'hello', f_line_wrap('hello world', 0, 6) from rdb$database; /* f_l_trim */ select 'hello world', f_l_trim(' hello world') from rdb$database; /* f_lr_trim */ select 'hello world', f_lr_trim(' hello world ') from rdb$database; /* f_mid */ select 'wor', f_mid('hello world', 6, 3) from rdb$database; /* f_pad_left */ select '0150', f_pad_left('150', '0', 4) from rdb$database; /* f_pad_right */ select '1500', f_pad_right('150', '0', 4) from rdb$database; /* f_proper_case */ select 'Hello World', f_proper_case('hello world') from rdb$database; /* f_replace */ select 'h59llo world', f_replace('hello world', 'e', '59') from rdb$database; /* f_right */ select 'world', f_right('hello world', 5) from rdb$database; /* f_r_trim */ select 'hello world', f_r_trim('hello world ') from rdb$database; /* f_soundex */ select 'H4000', f_soundex('hello') from rdb$database; /* f_string_length */ select 11, f_string_length('hello world') from rdb$database; /* f_strip_string */ select 'o word', f_strip_string('hello world', 'hel') from rdb$database; /* f_substr */ select 6, f_substr('hello world', 'wor') from rdb$database; /* * Math routines */ /* f_convert_from_33 */ select 1000, f_convert_from_33('WB') from rdb$database; /* f_convert_to_33 */ select 'WB', f_convert_to_33(1000) from rdb$database; /* f_convert_from_base */ select 42, f_convert_from_base('101010', 2, '01') from rdb$database; /* f_convert_to_base */ select '101010', f_convert_to_base(42, 2, '01') from rdb$database; /* f_convert_to_dollar */ select '$15.29', f_convert_to_dollar(15.29) from rdb$database; /* f_double_abs */ select 15, f_double_abs(-15) from rdb$database; /* f_fixed_point */ select '15.379', f_fixed_point(15.3789, 3) from rdb$database; /* f_integer_abs */ select 15, f_integer_abs(-15) from rdb$database; /* f_modulo */ select 1, f_modulo(3, 2) from rdb$database; /* f_round */ select 16, f_round(15.5) from rdb$database; /* f_truncate */ select 15, f_truncate(15.5) from rdb$database; /* * Date and time routines * 6/22/99 is a Tuesday */ /* f_add_month */ select '8/22/99', f_add_month('6/22/99', 2) from rdb$database; /* f_add_year */ select '6/22/97', f_add_year('6/22/99', -2) from rdb$database; /* f_age_in_months */ select 5, f_age_in_months('6/22/99', '1/1/99') from rdb$database; /* f_age_in_weeks */ select 1, f_age_in_weeks('6/22/99', '6/15/99') from rdb$database; /* f_cdow_long */ select 'Tuesday', f_cdow_long('6/22/99') from rdb$database; /* f_cdow_short */ select 'Tue', f_cdow_short('6/22/99') from rdb$database; /* f_cmonth_long */ select 'June', f_cmonth_long('6/22/99') from rdb$database; /* f_cmonth_short */ select 'Jun', f_cmonth_short('6/22/99') from rdb$database; /* f_day_of_month */ select 22, f_day_of_month('6/22/99') from rdb$database; /* f_day_of_week */ select 3, f_day_of_week('6/22/99') from rdb$database; /* f_day_of_year */ select 173, f_day_of_year('6/22/99') from rdb$database; /* f_is_leap_year */ select 0, f_is_leap_year('6/22/99') from rdb$database; /* f_is_leap_year */ select 0, f_is_leap_year('6/22/2000') from rdb$database; /* f_is_leap_year */ select 1, f_is_leap_year('6/22/96') from rdb$database; /* f_max_date */ select '6/22/99', f_max_date('6/22/99', '6/22/98') from rdb$database; /* f_min_date */ select '6/22/98', f_min_date('6/22/99', '6/22/98') from rdb$database; /* f_month */ select 6, f_month('6/22/99') from rdb$database; /* f_quarter */ select 2, f_quarter('6/22/99') from rdb$database; /* f_strip_date */ select '12/31/1899', f_strip_date('6/22/99') from rdb$database; /* f_strip_time */ select '6/22/99', f_strip_time('6/22/99') from rdb$database; /* f_week_of_year */ select 25, f_week_of_year('6/22/99') from rdb$database; /* f_woy */ select '199925', f_woy('6/22/99') from rdb$database; /* f_year */ select 1999, f_year('6/22/99') from rdb$database; /* f_year_of_year */ select 1999, f_year_of_year('6/22/99') from rdb$database; FreeUDFLibC/known_bugs.txt010064400017510000016000000004200703640203200171550ustar00gdeatzsysadmin00002170145441June 6, 1999 - find_word, find_word_index - (fixed) The find word algorithms weren't finding word boundaries as nicely as they should. The new algorithm defines a word as any series of consecutive alpha-numerics and the possibility of an included apostrophe. FreeUDFLibC/license.txt010064400017510000016000000160650703640202700164430ustar00gdeatzsysadmin00002170145441GENERAL SOFTWARE LICENSE AGREEMENT CAUTION: THE COPYING, MODIFICATION, TRANSLATION OR DISTRIBUTION OF THE OBJECT CODE, PROGRAM, SOFTWARE OR SOURCE CODE IMPLIES ACCEPTANCE OF THE TERMS OF THIS GENERAL SOFTWARE PROGRAM LICENSE AGREEMENT. YOU SHOULD READ CAREFULLY THE FOLLOWING TERMS AND CONDITIONS BEFORE YOU COPY, MODIFY, TRANSLATE OR DISTRIBUTE THE OBJECT CODE, PROGRAM, SOFTWARE OR SOURCE CODE. 1.0 DEFINITIONS 1.1 Licensee - The person who has the privilege to copy, modify, translate or distribute the object code, program, software and source code, subject to the terms and conditions of this General Software License Agreement. 1.2 Object Code - The version of a computer program in machine language, and therefore, ready to be executed by the computer. 1.3 Program - A sequence of instructions for executions by a computer. 1.4 Software - The computer program plus program documentation, if applicable. 1.5 Source Code - The version of a computer program in assembly language or high-level language, and therefore, not ready to be executed by the computer. 1.6 Work - All forms of tangible or intangible property, based whole, in part or derived from the object code, program, software or source code. 1.7 You - The person who has the privilege to copy, modify, translate or distribute the object code, program, software and source code, subject to the terms and conditions of this General Software License Agreement. 2.0 LICENSE 2.1 The copyright holder hereby extends a license to you to use its copyrighted object code, program, software and source code, subject to the terms and conditions of this General Software License Agreement. 2.2 This license is applicable to the object code, program, software and source code distributed under the terms of this General Software License Agreement, any work containing the object code, program, software or source code distributed under the terms of this General Software License Agreement, any modification of the object code, program, software or source code distributed under the terms of this General Software License Agreement, any translation of the object code, program, software or source code distributed under the terms of this General Software License Agreement and any work containing a modification or translation of the object code, program, software or source code distributed pursuant to the terms and conditions of this General Software License Agreement. 2.3 You may copy, modify, translate and distribute the object code, program, software or source code distributed under the terms of this General Software License Agreement, subject to the terms and conditions of this General Software License Agreement. 2.4 If you copy, modify, translate or distribute the object code, program, software or source code distributed under the terms of this General Software License Agreement, you must publish and make known in a clear and conspicuous manner on each copy, modification, translation or distribution of the object code, program, software or source code that the copy, modification, translation or distribution of the object code, program, software or source code is subject to the terms and conditions of this General Software License Agreement and provide a copy of this General Software License Agreement with each copy, modification, translation or distribution of the object code, program, software or source code. 2.5 If you derive, publish or distribute any work that is based whole or in part on the object code, program, software or source code distributed under the terms of this General Software License Agreement, or any modification or translation thereof, you must publish and make known in a clear and conspicuous manner on each such work that the work is subject to the terms and conditions of this General Software License Agreement and provide a copy of this General Software License Agreement with each work. 2.6 If you copy, modify, translate or distribute the object code, program, software or source code distributed under the terms and conditions of this General Software License Agreement, you must provide clear and conspicuous notice that you have copied, modified, translated or distributed the object code, program, software or source code distributed under the terms of this General Software License Agreement, and indicate the date of each such copy, modification, translation or distribution. 2.7 If you copy, modify, translate or distribute the object code, program, software or source code distributed under the terms of this General Software License Agreement, or publish or distribute any work that is derived, in whole or in part, from any copy, modification, translation or distribution of the object code, program, software or source code distributed under the terms of this General Software License Agreement, you cannot impose any further obligations or restrictions on any third person or entity other than what is contained in this General Software License Agreement. 3.0 NO WARRANTY 3.1 THE OBJECT CODE, PROGRAM, SOFTWARE AND SOURCE CODE ARE PROVIDED "AS IS" WITHOUT ANY WARRANT OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR USE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE OBJECT CODE, PROGRAM, SOFTWARE AND SOURCE CODE IS WITH YOU. SHOULD THE OBJECT CODE, PROGRAM, SOFTWARE AND SOURCE CODE PROVE DEFECTIVE, YOU ASSUME THE ENTIRE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 4.0 LIMITATION OF DAMAGES 4.1 IN NO EVENT WILL THE COPYRIGHT HOLDER OR ANY OTHER PERSON OR ENTITY BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING ANY LOST PROFITS, LOST SAVINGS, COMPENSATORY, GENERAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR THE INABILITY TO USE THE OBJECT CODE, PROGRAM, SOFTWARE AND SOURCE CODE, EVEN IF THE COPYRIGHT HOLDER OR ANY OTHER PERSON OR ENTITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. 5.0 MISCELLANEOUS 5.1 The article and paragraph headings appearing in this General Software License Agreement have been asserted for the purpose of convenience and ready reference. They do not purport to, and shall not be deemed to define, limit, or extend the scope or intent of the articles and paragraphs to which they pertain. 5.2 This General Software License Agreement embodies the entire agreement respecting its subject matter. There are no promises, terms, conditions or obligations other than those expressly set forth herein. Unless otherwise expressly set forth herein, this General Software License Agreement supersedes all previous communications, representations, agreements, either verbal or written, warranties, promises, covenants or undertakings. 5.3 This General Software License Agreement shall not be modified, altered, amended or supplemented, except in writing signed by all parties hereto. 5.4 This General Software License Agreement shall be governed by the laws of the State of New Jersey.bject code, program, software or source code distributed under the terms of this General Software License Agreement, any translation of the object code, program, software or source code distributed under the terms of this General Software License Agreement and any work containing a modification or translation of the object code, program, software or source code distributed pursuant to the terms and conditions of this General Software License Agreement. FreeUDFLibC/math_functions.c010064400017510000016000000062670703640202700174500ustar00gdeatzsysadmin00002170145441/* * FreeUDFLibC - copyright (c) 1999 Gregory Deatz * * math_functions.c * Math routines declarations: * convert_from_33 - convert a string (base33) to an integer * convert_to_33 - convert an integer to base33 string * convert_from_base - convert a string (base) to an integer * convert_to_base - convert an integer to a base string * convert_to_dollar - convert a double to a dollar string ($xxxx.xx) * double_abs - get the absolute value of a double * fixed_point - convert a double to a string with decimal points * integer_abs - get the absolute value of an integer * modulo - perform modulo arithmetic * round - round a double to the nearest integer * truncate - return the integer part of a double */ #include #include #include #include "global.h" #include "math_functions.h" static int get_value_of (char, char *); static int get_value_of (c, digits) char c; char * digits; { int i; for (i = 0 ; (digits[i] != (char) 0) && (digits[i] != c) ; i++) ; return i; } int convert_from_33 (sz) char * sz; { int base = 33; return convert_from_base (sz, &base, "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ"); } char * convert_to_33 (value) int * value; { int base = 33; return convert_to_base (value, &base, "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ"); } int convert_from_base (sz, base, digits) char * sz; int * base; char * digits; { int i; int res = 0; int len = strlen(sz); for (i = 0 ; i < len ; i++) res = (*base * res) + get_value_of(sz[i], digits); return res; } char * convert_to_base (value, base, digits) int * value; int * base; char * digits; { char sz_res[LOC_STRING_SIZE + 1]; char * sz_result = (char *) MALLOC (LOC_STRING_SIZE + 1); int i = 0; int j, r, len_sz_res; int first_time = 1; for ( j = *value ; (j != 0) || first_time; j = j / *base, first_time = 0){ r = j % *base; sz_res[i++] = digits[r]; } sz_res[i] = (char) 0; sz_result[i] = (char) 0; len_sz_res = i; for (i = 0 ; i < len_sz_res ; i++) sz_result[i] = sz_res[len_sz_res - i - 1]; return sz_result; } char * convert_to_dollar (value) double * value; { char * sz_result = (char *) MALLOC (LOC_STRING_SIZE + 1); sprintf(sz_result, "$%.2f", (*value)); return sz_result; } double double_abs (value) double * value; { if (*value < 0) return -*value; else return *value; } char * fixed_point (value, decimals) double * value; int * decimals; { char * sz_result = MALLOC (LOC_STRING_SIZE + 1); sprintf(sz_result, "%.*f", *decimals, *value); return sz_result; } int integer_abs (value) int * value; { if (*value < 0) return -*value; else return *value; } int modulo (numerator, denominator) int * numerator; int * denominator; { if (*denominator == 0) return 0; else return *numerator % *denominator; } int round (value) double * value; { if (*value < 0) return (int)(*value - 0.5); else return (int)(*value + 0.5); } int truncate (value) double * value; { return (int) (*value); } FreeUDFLibC/math_functions.h010064400017510000016000000024330703640203000174360ustar00gdeatzsysadmin00002170145441/* * FreeUDFLibC - copyright (c) 1999 Gregory Deatz * * math_functions.h * Math routines declarations: * convert_from_33 - convert a string (base33) to an integer * convert_to_33 - convert an integer to base33 string * convert_from_base - convert a string (base) to an integer * convert_to_base - convert an integer to a base string * convert_to_dollar - convert a double to a dollar string ($xxxx.xx) * double_abs - get the absolute value of a double * fixed_point - convert a double to a string with decimal points * integer_abs - get the absolute value of an integer * modulo - perform modulo arithmetic * round - round a double to the nearest integer * truncate - return the integer part of a double */ int convert_from_33 PROTO_LIST ((char *)); char * convert_to_33 PROTO_LIST ((int *)); int convert_from_base PROTO_LIST ((char *, int *, char *)); char * convert_to_base PROTO_LIST ((int *, int *, char *)); char * convert_to_dollar PROTO_LIST ((double *)); double double_abs PROTO_LIST ((double *)); char * fixed_point PROTO_LIST ((double *, int *)); int integer_abs PROTO_LIST ((int *)); int modulo PROTO_LIST ((int *, int *)); int round PROTO_LIST ((double *)); int truncate PROTO_LIST ((double *)); FreeUDFLibC/md5.h010064400017510000016000000025710703640203000151050ustar00gdeatzsysadmin00002170145441/* MD5.H - header file for MD5C.C */ /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved. License to copy and use this software is granted provided that it is identified as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing this software or this function. License is also granted to make and use derivative works provided that such works are identified as "derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing the derived work. RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided "as is" without express or implied warranty of any kind. These notices must be retained in any copies of any part of this documentation and/or software. */ /* MD5 context. */ typedef struct { UINT4 state[4]; /* state (ABCD) */ UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */ unsigned char buffer[64]; /* input buffer */ } MD5_CTX; void MD5Init PROTO_LIST ((MD5_CTX *)); void MD5Update PROTO_LIST ((MD5_CTX *, unsigned char *, unsigned int)); void MD5Final PROTO_LIST ((unsigned char [16], MD5_CTX *)); granted to make and use derivative works provided that such works are identified as "derived from the RSA Data Security, Inc. MDFreeUDFLibC/md5_global.h010064400017510000016000000014240703640203000164210ustar00gdeatzsysadmin00002170145441/* GLOBAL.H - RSAREF types and constants */ /* PROTOTYPES should be set to one if and only if the compiler supports function argument prototyping. The following makes PROTOTYPES default to 0 if it has not already been defined with C compiler flags. */ #ifndef PROTOTYPES #define PROTOTYPES 0 #endif /* POINTER defines a generic pointer type */ typedef unsigned char *POINTER; /* UINT2 defines a two byte word */ typedef unsigned short int UINT2; /* UINT4 defines a four byte word */ typedef unsigned long int UINT4; /* PROTO_LIST is defined depending on how PROTOTYPES is defined above. If using PROTOTYPES, then PROTO_LIST returns the list, otherwise it returns an empty list. */ #if PROTOTYPES #define PROTO_LIST(list) list #else #define PROTO_LIST(list) () #endif FreeUDFLibC/md5c.c010064400017510000016000000244210703640203000152410ustar00gdeatzsysadmin00002170145441/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm */ /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved. License to copy and use this software is granted provided that it is identified as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing this software or this function. License is also granted to make and use derivative works provided that such works are identified as "derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing the derived work. RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided "as is" without express or implied warranty of any kind. These notices must be retained in any copies of any part of this documentation and/or software. */ #include "md5_global.h" #include "md5.h" /* Constants for MD5Transform routine. */ #define S11 7 #define S12 12 #define S13 17 #define S14 22 #define S21 5 #define S22 9 #define S23 14 #define S24 20 #define S31 4 #define S32 11 #define S33 16 #define S34 23 #define S41 6 #define S42 10 #define S43 15 #define S44 21 static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64])); static void Encode PROTO_LIST ((unsigned char *, UINT4 *, unsigned int)); static void Decode PROTO_LIST ((UINT4 *, unsigned char *, unsigned int)); static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int)); static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int)); static unsigned char PADDING[64] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; /* F, G, H and I are basic MD5 functions. */ #define F(x, y, z) (((x) & (y)) | ((~x) & (z))) #define G(x, y, z) (((x) & (z)) | ((y) & (~z))) #define H(x, y, z) ((x) ^ (y) ^ (z)) #define I(x, y, z) ((y) ^ ((x) | (~z))) /* ROTATE_LEFT rotates x left n bits. */ #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. Rotation is separate from addition to prevent recomputation. */ #define FF(a, b, c, d, x, s, ac) { \ (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } #define GG(a, b, c, d, x, s, ac) { \ (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } #define HH(a, b, c, d, x, s, ac) { \ (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } #define II(a, b, c, d, x, s, ac) { \ (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } /* MD5 initialization. Begins an MD5 operation, writing a new context. */ void MD5Init (context) MD5_CTX *context; /* context */ { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. */ context->state[0] = 0x67452301; context->state[1] = 0xefcdab89; context->state[2] = 0x98badcfe; context->state[3] = 0x10325476; } /* MD5 block update operation. Continues an MD5 message-digest operation, processing another message block, and updating the context. */ void MD5Update (context, input, inputLen) MD5_CTX *context; /* context */ unsigned char *input; /* input block */ unsigned int inputLen; /* length of input block */ { unsigned int i, index, partLen; /* Compute number of bytes mod 64 */ index = (unsigned int)((context->count[0] >> 3) & 0x3F); /* Update number of bits */ if ((context->count[0] += ((UINT4)inputLen << 3)) < ((UINT4)inputLen << 3)) context->count[1]++; context->count[1] += ((UINT4)inputLen >> 29); partLen = 64 - index; /* Transform as many times as possible. */ if (inputLen >= partLen) { MD5_memcpy ((POINTER)&context->buffer[index], (POINTER)input, partLen); MD5Transform (context->state, context->buffer); for (i = partLen; i + 63 < inputLen; i += 64) MD5Transform (context->state, &input[i]); index = 0; } else i = 0; /* Buffer remaining input */ MD5_memcpy ((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i); } /* MD5 finalization. Ends an MD5 message-digest operation, writing the the message digest and zeroizing the context. */ void MD5Final (digest, context) unsigned char digest[16]; /* message digest */ MD5_CTX *context; /* context */ { unsigned char bits[8]; unsigned int index, padLen; /* Save number of bits */ Encode (bits, context->count, 8); /* Pad out to 56 mod 64. */ index = (unsigned int)((context->count[0] >> 3) & 0x3f); padLen = (index < 56) ? (56 - index) : (120 - index); MD5Update (context, PADDING, padLen); /* Append length (before padding) */ MD5Update (context, bits, 8); /* Store state in digest */ Encode (digest, context->state, 16); /* Zeroize sensitive information. */ MD5_memset ((POINTER)context, 0, sizeof (*context)); } /* MD5 basic transformation. Transforms state based on block. */ static void MD5Transform (state, block) UINT4 state[4]; unsigned char block[64]; { UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; Decode (x, block, 64); /* Round 1 */ FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ /* Round 2 */ GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ /* Round 3 */ HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ /* Round 4 */ II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ state[0] += a; state[1] += b; state[2] += c; state[3] += d; /* Zeroize sensitive information. */ MD5_memset ((POINTER)x, 0, sizeof (x)); } /* Encodes input (UINT4) into output (unsigned char). Assumes len is a multiple of 4. */ static void Encode (output, input, len) unsigned char *output; UINT4 *input; unsigned int len; { unsigned int i, j; for (i = 0, j = 0; j < len; i++, j += 4) { output[j] = (unsigned char)(input[i] & 0xff); output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); } } /* Decodes input (unsigned char) into output (UINT4). Assumes len is a multiple of 4. */ static void Decode (output, input, len) UINT4 *output; unsigned char *input; unsigned int len; { unsigned int i, j; for (i = 0, j = 0; j < len; i++, j += 4) output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) | (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24); } /* Note: Replace "for loop" with standard memcpy if possible. */ static void MD5_memcpy (output, input, len) POINTER output; POINTER input; unsigned int len; { unsigned int i; for (i = 0; i < len; i++) output[i] = input[i]; } /* Note: Replace "for loop" with standard memset if possible. */ static void MD5_memset (output, value, len) POINTER output; int value; unsigned int len; { unsigned int i; for (i = 0; i < len; i++) ((char *)output)[i] = (char)value; } += I ((b), (c), (d)) + (x) + (UINT4)(ac); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } /* MD5 initialization. Begins an MD5 operation, writing a new context. */ void MD5Init (context) MD5_CTX *context; FreeUDFLibC/mddriver.c010064400017510000016000000132670703640203000162330ustar00gdeatzsysadmin00002170145441/* MDDRIVER.C - test driver for MD2, MD4 and MD5 */ /* Copyright (C) 1990-2, RSA Data Security, Inc. Created 1990. All rights reserved. RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided "as is" without express or implied warranty of any kind. These notices must be retained in any copies of any part of this documentation and/or software. */ /* The following makes MD default to MD5 if it has not already been defined with C compiler flags. */ #ifndef MD #define MD 5 #endif #include #include #include #include "md5_global.h" #if MD == 2 #include "md2.h" #endif #if MD == 4 #include "md4.h" #endif #if MD == 5 #include "md5.h" #endif /* Length of test block, number of test blocks. */ #define TEST_BLOCK_LEN 1000 #define TEST_BLOCK_COUNT 1000 static void MDString PROTO_LIST ((char *)); static void MDTimeTrial PROTO_LIST ((void)); static void MDTestSuite PROTO_LIST ((void)); static void MDFile PROTO_LIST ((char *)); static void MDFilter PROTO_LIST ((void)); static void MDPrint PROTO_LIST ((unsigned char [16])); #if MD == 2 #define MD_CTX MD2_CTX #define MDInit MD2Init #define MDUpdate MD2Update #define MDFinal MD2Final #endif #if MD == 4 #define MD_CTX MD4_CTX #define MDInit MD4Init #define MDUpdate MD4Update #define MDFinal MD4Final #endif #if MD == 5 #define MD_CTX MD5_CTX #define MDInit MD5Init #define MDUpdate MD5Update #define MDFinal MD5Final #endif /* Main driver. Arguments (may be any combination): -sstring - digests string -t - runs time trial -x - runs test script filename - digests file (none) - digests standard input */ int main (argc, argv) int argc; char *argv[]; { int i; if (argc > 1) for (i = 1; i < argc; i++) if (argv[i][0] == '-' && argv[i][1] == 's') MDString (argv[i] + 2); else if (strcmp (argv[i], "-t") == 0) MDTimeTrial (); else if (strcmp (argv[i], "-x") == 0) MDTestSuite (); else MDFile (argv[i]); else MDFilter (); return (0); } /* Digests a string and prints the result. */ static void MDString (string) char *string; { MD_CTX context; unsigned char digest[16]; unsigned int len = strlen (string); MDInit (&context); MDUpdate (&context, string, len); MDFinal (digest, &context); printf ("MD%d (\"%s\") = ", MD, string); MDPrint (digest); printf ("\n"); } /* Measures the time to digest TEST_BLOCK_COUNT TEST_BLOCK_LEN-byte blocks. */ static void MDTimeTrial () { MD_CTX context; time_t endTime, startTime; unsigned char block[TEST_BLOCK_LEN], digest[16]; unsigned int i; printf ("MD%d time trial. Digesting %d %d-byte blocks ...", MD, TEST_BLOCK_LEN, TEST_BLOCK_COUNT); /* Initialize block */ for (i = 0; i < TEST_BLOCK_LEN; i++) block[i] = (unsigned char)(i & 0xff); /* Start timer */ time (&startTime); /* Digest blocks */ MDInit (&context); for (i = 0; i < TEST_BLOCK_COUNT; i++) MDUpdate (&context, block, TEST_BLOCK_LEN); MDFinal (digest, &context); /* Stop timer */ time (&endTime); printf (" done\n"); printf ("Digest = "); MDPrint (digest); printf ("\nTime = %ld seconds\n", (long)(endTime-startTime)); printf ("Speed = %ld bytes/second\n", (long)TEST_BLOCK_LEN * (long)TEST_BLOCK_COUNT/(endTime-startTime)); } /* Digests a reference suite of strings and prints the results. */ static void MDTestSuite () { printf ("MD%d test suite:\n", MD); MDString (""); MDString ("a"); MDString ("abc"); MDString ("message digest"); MDString ("abcdefghijklmnopqrstuvwxyz"); MDString ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"); MDString ("1234567890123456789012345678901234567890\ 1234567890123456789012345678901234567890"); } /* Digests a file and prints the result. */ static void MDFile (filename) char *filename; { FILE *file; MD_CTX context; int len; unsigned char buffer[1024], digest[16]; if ((file = fopen (filename, "rb")) == NULL) printf ("%s can't be opened\n", filename); else { MDInit (&context); while (len = fread (buffer, 1, 1024, file)) MDUpdate (&context, buffer, len); MDFinal (digest, &context); fclose (file); printf ("MD%d (%s) = ", MD, filename); MDPrint (digest); printf ("\n"); } } /* Digests the standard input and prints the result. */ static void MDFilter () { MD_CTX context; int len; unsigned char buffer[16], digest[16]; MDInit (&context); while (len = fread (buffer, 1, 16, stdin)) MDUpdate (&context, buffer, len); MDFinal (digest, &context); MDPrint (digest); printf ("\n"); } /* Prints a message digest in hexadecimal. */ static void MDPrint (digest) unsigned char digest[16]; { unsigned int i; for (i = 0; i < 16; i++) printf ("%02x", digest[i]); } /* A.5 Test suite The MD5 test suite (driver option "-x") should print the following results: MD5 test suite: MD5 ("") = d41d8cd98f00b204e9800998ecf8427e MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661 MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72 MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0 MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b MD5 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f MD5 ("123456789012345678901234567890123456789012345678901234567890123456 78901234567890") = 57edf4a22be3c955ac49da2e2107b67a */ /* Author's Address Ronald L. Rivest Massachusetts Institute of Technology Laboratory for Computer Science NE43-324 545 Technology Square Cambridge, MA 02139-1986 Phone: (617) 253-5880 EMail: rivest@theory.lcs.mit.edu */ FreeUDFLibC/readme.txt010064400017510000016000000044150703640203100162450ustar00gdeatzsysadmin00002170145441FreeUDFLibC - copyright (c) 1999 Gregory Deatz Subject to the terms of the license provided in the file license.txt. --- FreeUDFLibC was written as a C port of FreeUDFLib, which was originally written in Delphi (a Windows variant of Pascal). Many functions have been omitted, and others have been included. The main reason for porting FreeUDFLib to C is so that FreeUDFLib is more platform independent. Although FreeUDFLibC is initially being distributed with Makefile's for only Solaris and Linux, there is no reason why someone can't create one for Windows, and send it to me. Not much documentation is provided with this, but I think that most of this stuff should be reasonably self-explanatory. Assuming that you have GNU C installed on your system, which virtually *all* Linux boxes have, and GNU C is quite easily obtained for Solaris (go to the Solaris Package Archive: http://metalab.unc.edu/pub/packages/solaris/sparc/).... This is what you need to do to install: 1. gunzip FreeUDFLibC.tar.gz 2. tar xvf FreeUDFLibC.tar.gz 3. a. On Linux, cp Makefile.Linux Makefile b. On Solaris, cp Makefile.Solaris Makefile 4. a. Check that the IB_VERSION variable in your Makefile has the right value. b. If you are using IB50 or lower, then go to the line in the Makefile that reads "LIB_LINK_FLAGS= ...". Remove the entry for -lib_util. 5. Make sure that the IBASE variable points the right directory for your InterBase root. 6. make install If you'd like to test the functions, then take a look at ib_test.sql. It performs some minor tests to validate the correctness of the routines. I have also included a "def" file for use with MS installations, I have heard that there are no difficulties compiling FreeUDFLibC under windows using MSVC. Unfortunately, I don't have a C compiler for Windows, so I can't attest to that fact. Also, I don't have a Makefile or appropriate instructions for installing/compiling under Windows. At some point in the future, I will distribute this with pre-compiled binaries for Windows, Solaris & Linux. But not yet... The file ib_declarations.sql can be run against an existing database to declare the functions. So there! Any problems, bugs, etc... please let me know, and I'll try to fix them. Enjoy, Greg Deatz gdeatz@hlmdd.comFreeUDFLibC/string_functions.c010064400017510000016000000253500703640203200200130ustar00gdeatzsysadmin00002170145441/* * FreeUDFLibC - copyright (c) 1999 Gregory Deatz * * string_functions.c * String routines: * character - return the character based on the passed integer code. * crlf - return the carriage-return string * encrypt_md5 - hash the passed string using the md5 algorithm * find_word - return the word in a string starting at some index * find_word_index - find the index of a word starting at some index * left - return the leftmost characters of a string * line_wrap - based on lines characters long, return the ith line * l_trim - trim whitespace from the left side of the string * lr_trim - trim whitespace from both sides of the string * mid - return a substring of a string * pad_left - pad the left side of a string with some other string * pad_right - pad the right side of a string with some other string * proper_case - proper case the passed string (every word capitalized) * replace - replace character with character in the string * right - return the rightmost characters of a string * r_trim - Trim the right side of a string of whitespace * string_length - How long is this string? * strip_string - Strip a string of unwanted characters * substr - Find a substring within a string * soundex - return the soundex of a string */ #include #include #include "md5_global.h" #include "global.h" #include "md5.h" #include "string_functions.h" #define iswordchar(sz, i, start) \ (isalnum(sz[i]) || \ ((i > start) && \ !isspace(sz[i-1]) && \ (sz[i] == '\''))) \ static int find_char PROTO_LIST ((char, char *)); /* Implementations */ char * character (c) int * c; { char *sz = (char *) MALLOC (2); sz[0] = (char) *c; sz[1] = (char) 0; return sz; } char * crlf () { char * sz = (char *) MALLOC (3); sz[0] = (char) 13; sz[1] = (char) 10; sz[2] = (char) 0; return sz; } char * encrypt_md5 (sz) char * sz; { MD5_CTX context; unsigned char digest[16]; unsigned int len = strlen (sz); unsigned int i; char * sz_return = (char *) MALLOC (33); sz_return[32] = (char) 0; /* Compute the hash */ MD5Init (&context); MD5Update (&context, sz, len); MD5Final (digest, &context); for (i = 0; i < 16; i++) sprintf (&sz_return[i*2], "%02x", digest[i]); return sz_return; } char * find_word (sz, index) char * sz; int * index; { char sz_res[LOC_STRING_SIZE]; char * sz_result; int i; int j = 0; int len = strlen(sz); i = find_word_index (sz, index); while (i < len && j < LOC_STRING_SIZE - 1 && iswordchar(sz, i, *index)) { sz_res[j] = sz[i]; j++; i++; } sz_res[j] = (char) 0; sz_result = (char *) MALLOC(j + 1); sprintf(sz_result, "%s", sz_res); return sz_result; } int find_word_index (sz, index) char * sz; int * index; { char sz_res[LOC_STRING_SIZE]; int i = *index; int j = 0; int len = strlen(sz); while (i < len && j < LOC_STRING_SIZE - 1 && !iswordchar(sz, i, *index)) { sz_res[j] = sz[i]; j++; i++; } return (i >= len) ? -1 : i; } char * left (sz, count) char * sz; int * count; { int i; int len = (strlen(sz) < *count) ? strlen(sz) : *count; char * sz_result = (char *) MALLOC (len + 1); for (i = 0 ; i < len ; i++) sz_result[i] = sz[i]; sz_result[i] = (char) 0; return sz_result; } /* * line_wrap algorithm * 1. Get the length of the string. * 2. If "the rest" of the string is smaller than col_width, just return * it. * 3. Otherwise, let 'j' be the end of the column, and decrement j to * a word boundary. * a. Find a word boundary. * b. If j = i (meaning the word is too long), then the word has * has to be chopped. */ char * line_wrap (sz, index, col_width) char * sz; int *index, *col_width; { int len = strlen(sz); /* (1) */ int i = *index; int j; char * sz_result; if ((len - i) <= *col_width) /* (2) */ j = len - i; else { j = i + *col_width - 1; while (j > i && !isspace(sz[j])) j--; /* (2a) */ if (j == i) j = *col_width; else j = j - i + 1; } sz_result = (char *) MALLOC(j + 1); for (i = 0 ; i < j ; i++) sz_result[i] = sz[i + *index]; sz_result[j] = '\0'; return sz_result; } char * l_trim (sz) char * sz; { int len = strlen(sz); char * sz_result = (char *) MALLOC (len + 1); int i; for (i = 0 ; (i < len) && isspace(sz[i]) ; i++) ; sprintf(sz_result, "%s", &sz[i]); return sz_result; } char * lr_trim (sz) char * sz; { int len = strlen(sz); char * sz_result = (char *) MALLOC (len + 1); int i, j, k; for (i = 0 ; (i < len) && isspace(sz[i]) ; i++) ; for (j = len - 1 ; (j >= 0) && isspace(sz[j]) ; j--) ; for (k = i ; k <= j ; k++) sz_result[k - i] = sz[k]; sz_result[k - i] = (char) 0; return sz_result; } char * mid (sz, index, count) char * sz; int * index; int * count; { int len = strlen(sz); char * sz_result = (char *) MALLOC (*count + 1); int i, j, k; for (i = *index ; (i < len) && (i - *index < *count) ; i++) sz_result[i - *index] = sz[i]; sz_result[i - *index] = (char) 0; return sz_result; } char * pad_left (sz, sz_pad, size) char * sz; char * sz_pad; int * size; { int len_sz = strlen(sz); int len_sz_pad = strlen(sz_pad); int len_sz_result = *size > len_sz ? *size : len_sz; char * sz_result = (char *) MALLOC (len_sz_result + 1); int i, j; sz_result[len_sz_result] = (char) 0; for (i = len_sz - 1 ; i >= 0 ; i--) sz_result[len_sz_result - (len_sz - i - 1) - 1] = sz[i]; for (i = len_sz_result - (len_sz - i - 1) - 1 ; i >= 0 ; ) { for (j = len_sz_pad - 1 ; (j >= 0) && (i >= 0) ; j--, i--) sz_result[i] = sz_pad[j]; } return sz_result; } char * pad_right (sz, sz_pad, size) char * sz; char * sz_pad; int * size; { int len_sz = strlen(sz); int len_sz_pad = strlen(sz_pad); int len_sz_result = *size > len_sz ? *size : len_sz; char * sz_result = (char *) MALLOC (len_sz_result + 1); int i, j; sz_result[len_sz_result] = (char) 0; for (i = 0 ; i < len_sz ; i++) sz_result[i] = sz[i]; while (i < len_sz_result) for (j = 0 ; (j < len_sz_pad) && (i < len_sz_result) ; j++, i++) sz_result[i] = sz_pad[j]; return sz_result; } char * proper_case (sz) char * sz; { int len = strlen(sz); char * sz_result = (char *) MALLOC (len + 1); int i; int word_begin = 1; for (i = 0 ; i < len ; i++) if (isalnum(sz[i]) && word_begin) { word_begin = 0; sz_result[i] = toupper(sz[i]); } else if (!isalnum(sz[i])) { word_begin = 1; sz_result[i] = sz[i]; } else sz_result[i] = sz[i]; return sz_result; } /* * replace - * I'm sure there is a *much* more efficient way to do this, but * I don't really care that much because this should be fast enough. * If anybody cares to provide me with some faster/more efficient code, * I'd be glad to include it here. */ char * replace (sz, sz_replace, sz_with) char * sz; char * sz_replace; char * sz_with; { int len_sz = strlen(sz); int len_sz_replace = strlen(sz_replace); int len_sz_with = strlen(sz_with); int i, j; int k = 0; char sz_res[LOC_STRING_SIZE + 1]; char * sz_result; for (i = 0 ; i < len_sz ; ) { if (strncmp(&sz[i], sz_replace, len_sz_replace) == 0) { for (j = 0 ; j < len_sz_with ; j++, k++) sz_res[k] = sz_with[j]; i += len_sz_replace; } else { sz_res[k++] = sz[i]; i++; } } sz_res[k] = (char) 0; sz_result = (char *) MALLOC (strlen(sz_res) + 1); sprintf(sz_result, "%s", sz_res); return sz_result; } char * right (sz, count) char * sz; int * count; { int len = strlen(sz); char * sz_result = (char *) MALLOC (*count + 1); int i, j; for (j = 0, i = (*count > len) ? 0 : len - *count ; i < len ; i++, j++) sz_result[j] = sz[i]; sz_result[j] = (char) 0; return sz_result; } char * r_trim (sz) char * sz; { int len = strlen(sz); char * sz_result = (char *) MALLOC (len + 1); int i, j; for (i = len - 1 ; (i >= 0) && isspace(sz[i]) ; i--) ; for (j = 0 ; j <= i ; j++) sz_result[j] = sz[j]; sz_result[j] = (char) 0; return sz_result; } char * soundex (sz) char * sz; { int i, j; char code; int len = strlen(sz); char * sz_result = (char *) MALLOC (6); sz_result[0] = ' '; sz_result[1] = '0'; sz_result[2] = '0'; sz_result[3] = '0'; sz_result[4] = '0'; sz_result[5] = (char) 0; if (strlen(sz) != 0) { sz_result[0] = toupper(sz[0]); j = 1; i = 1; while (i < len && j < 5) { switch(sz[i]) { case 'B': case 'F': case 'P': case 'V': case 'b': case 'f': case 'p': case 'v': code = '1'; break; case 'C': case 'G': case 'J': case 'K': case 'Q': case 'S': case 'X': case 'Z': case 'c': case 'g': case 'j': case 'k': case 'q': case 's': case 'x': case 'z': code = '2'; break; case 'D': case 'T': case 'd': case 't': code = '3'; break; case 'L': case 'l': code = '4'; break; case 'M': case 'N': case 'm': case 'n': code = '5'; break; case 'R': case 'r': code = '6'; break; default: code = '0'; } if (code != '0' && code != sz_result[j - 1]) sz_result[j++] = code; i++; } } return sz_result; } int string_length (sz) char * sz; { return strlen(sz); } char * strip_string (sz, sz_strip_chars) char * sz; char * sz_strip_chars; { int i; int j = 0; int len = strlen(sz); char * sz_result = (char *) MALLOC (len + 1); for (i = 0 ; i < len ; i++) if (!find_char(sz[i], sz_strip_chars)) { sz_result[j] = sz[i]; j++; } sz_result[j] = (char) 0; return sz_result; } /* * substr - * This is most certainly *not* the most efficient way to search for * a string, but I don't really care. */ int substr (sz, sz_search) char * sz; char * sz_search; { int i; int result = -1; int len_sz = strlen(sz); int len_sz_search = strlen(sz_search); for (i = 0 ; (i < len_sz - len_sz_search + 1) && (result == -1) ; i++) if (strncmp(&sz[i], sz_search, len_sz_search) == 0) result = i; return result; } static int find_char (c, sz) char c; char * sz; { int i = 0; int len = strlen(sz); for (i = 0 ; (i < len) && (c != sz[i]) ; i++) ; if (i == len) return 0; else return -1; } b. If j = i (meaning the word is too long), then the word has * has to be chopped. */ char * line_wrap (sz, index, col_width) char * sz; int *index, *col_width; { int len = strlen(sz); /* (1) */ int i = *index; int j; char * sz_result; if ((len - iFreeUDFLibC/string_functions.h010064400017510000016000000044050703640203100200150ustar00gdeatzsysadmin00002170145441/* * FreeUDFLibC - copyright (c) 1999 Gregory Deatz * * string_functions.h * String routines declarations: * character - return the character based on the passed integer code. * crlf - return the carriage-return string * encrypt_md5 - hash the passed string using the md5 algorithm * find_word - return the word in a string starting at some index * find_word_index - find the index of a word starting at some index * left - return the leftmost characters of a string * line_wrap - based on lines characters long, return the ith line * l_trim - trim whitespace from the left side of the string * lr_trim - trim whitespace from both sides of the string * mid - return a substring of a string * pad_left - pad the left side of a string with some other string * pad_right - pad the right side of a string with some other string * proper_case - proper case the passed string (every word capitalized) * replace - replace character with character in the string * right - return the rightmost characters of a string * r_trim - Trim the right side of a string of whitespace * string_length - How long is this string? * strip_string - Strip a string of unwanted characters * substr - Find a substring within a string * soundex - return the soundex of a string */ char * character PROTO_LIST ((int *)); char * crlf PROTO_LIST (()); char * encrypt_md5 PROTO_LIST ((char *)); char * find_word PROTO_LIST ((char *, int *)); int find_word_index PROTO_LIST ((char *, int *)); char * left PROTO_LIST ((char *, int *)); char * line_wrap PROTO_LIST ((char *, int *, int *)); char * l_trim PROTO_LIST ((char *)); char * lr_trim PROTO_LIST ((char *)); char * mid PROTO_LIST ((char *, int *, int *)); char * pad_left PROTO_LIST ((char *, char *, int *)); char * pad_right PROTO_LIST ((char *, char *, int *)); char * proper_case PROTO_LIST ((char *)); char * replace PROTO_LIST ((char *, char *, char *)); char * right PROTO_LIST ((char *, int *)); char * r_trim PROTO_LIST ((char *)); char * soundex PROTO_LIST ((char *)); int string_length PROTO_LIST ((char *)); char * strip_string PROTO_LIST ((char *, char *)); int substr PROTO_LIST ((char *, char *));