felixfoertsch/remind
1
0
Fork 0
mirror of https://salsa.debian.org/dskoll/remind.git synced 2026-04-17 23:08:40 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Assume standard functions strcasecmp, strncasecmp and strdup are always available.

Browse Source
This commit is contained in:
Dianne Skoll
2025-12-22 15:53:37 -05:00
parent 20a558f817
commit 7ae7edcb42
21 changed files with 90 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
configure vendored
View File

@@ -4322,24 +4322,6 @@ if test "$ac_cv_header_wctype_h" != "yes" ; then
exit 1 exit 1
fi fi
ac_fn_c_check_func "$LINENO" "strdup" "ac_cv_func_strdup"
if test "x$ac_cv_func_strdup" = xyes
then :
printf "%s\n" "#define HAVE_STRDUP 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "strcasecmp" "ac_cv_func_strcasecmp"
if test "x$ac_cv_func_strcasecmp" = xyes
then :
printf "%s\n" "#define HAVE_STRCASECMP 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "strncasecmp" "ac_cv_func_strncasecmp"
if test "x$ac_cv_func_strncasecmp" = xyes
then :
printf "%s\n" "#define HAVE_STRNCASECMP 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "setenv" "ac_cv_func_setenv" ac_fn_c_check_func "$LINENO" "setenv" "ac_cv_func_setenv"
if test "x$ac_cv_func_setenv" = xyes if test "x$ac_cv_func_setenv" = xyes
then : then :

2
configure.ac
View File

@@ -109,7 +109,7 @@ if test "$ac_cv_header_wctype_h" != "yes" ; then
exit 1 exit 1
fi fi
AC_CHECK_FUNCS(strdup strcasecmp strncasecmp setenv unsetenv glob mbstowcs setlocale initgroups inotify_init1 readline) AC_CHECK_FUNCS(setenv unsetenv glob mbstowcs setlocale initgroups inotify_init1 readline)
if test "$ac_cv_func_mbstowcs" != "yes"; then if test "$ac_cv_func_mbstowcs" != "yes"; then
echo "*** Remind requires the mbstowcs function" echo "*** Remind requires the mbstowcs function"

24
src/calendar.c
View File

@@ -2117,7 +2117,7 @@ static int DoCalRem(ParsePtr p, int col)
} }
} }
if (trig.typ == PASSTHRU_TYPE) { if (trig.typ == PASSTHRU_TYPE) {
if (!PsCal && !StrCmpi(trig.passthru, "SHADE")) { if (!PsCal && !strcasecmp(trig.passthru, "SHADE")) {
if (dse == DSEToday) { if (dse == DSEToday) {
DBufInit(&obuf); DBufInit(&obuf);
r = DoSubst(p, &obuf, &trig, &tim, dse, CAL_MODE); r = DoSubst(p, &obuf, &trig, &tim, dse, CAL_MODE);
@@ -2130,7 +2130,7 @@ static int DoCalRem(ParsePtr p, int col)
DBufFree(&obuf); DBufFree(&obuf);
} }
} }
if (!PsCal && !StrCmpi(trig.passthru, "WEEK")) { if (!PsCal && !strcasecmp(trig.passthru, "WEEK")) {
if (dse == DSEToday) { if (dse == DSEToday) {
DBufInit(&obuf); DBufInit(&obuf);
r = DoSubst(p, &obuf, &trig, &tim, dse, CAL_MODE); r = DoSubst(p, &obuf, &trig, &tim, dse, CAL_MODE);
@@ -2143,11 +2143,11 @@ static int DoCalRem(ParsePtr p, int col)
DBufFree(&obuf); DBufFree(&obuf);
} }
} }
if (!PsCal && StrCmpi(trig.passthru, "COLOR") && StrCmpi(trig.passthru, "COLOUR") && StrCmpi(trig.passthru, "MOON")) { if (!PsCal && strcasecmp(trig.passthru, "COLOR") && strcasecmp(trig.passthru, "COLOUR") && strcasecmp(trig.passthru, "MOON")) {
FreeTrig(&trig); FreeTrig(&trig);
return OK; return OK;
} }
if (!PsCal && !StrCmpi(trig.passthru, "MOON")) { if (!PsCal && !strcasecmp(trig.passthru, "MOON")) {
if (dse == DSEToday) { if (dse == DSEToday) {
DBufInit(&obuf); DBufInit(&obuf);
r = DoSubst(p, &obuf, &trig, &tim, dse, CAL_MODE); r = DoSubst(p, &obuf, &trig, &tim, dse, CAL_MODE);
@@ -2160,8 +2160,8 @@ static int DoCalRem(ParsePtr p, int col)
DBufFree(&obuf); DBufFree(&obuf);
} }
} }
if (!StrCmpi(trig.passthru, "COLOR") || if (!strcasecmp(trig.passthru, "COLOR") ||
!StrCmpi(trig.passthru, "COLOUR")) { !strcasecmp(trig.passthru, "COLOUR")) {
is_color = 1; is_color = 1;
/* Strip off the three color numbers */ /* Strip off the three color numbers */
DBufFree(&buf); DBufFree(&buf);
@@ -2225,8 +2225,8 @@ static int DoCalRem(ParsePtr p, int col)
/* Suppress time if it's not today or if it's a non-COLOR special */ /* Suppress time if it's not today or if it's a non-COLOR special */
if (dse != DSEToday || if (dse != DSEToday ||
(trig.typ == PASSTHRU_TYPE && (trig.typ == PASSTHRU_TYPE &&
StrCmpi(trig.passthru, "COLOUR") && strcasecmp(trig.passthru, "COLOUR") &&
StrCmpi(trig.passthru, "COLOR"))) { strcasecmp(trig.passthru, "COLOR"))) {
if (DBufPuts(&obuf, SimpleTime(NO_TIME)) != OK) { if (DBufPuts(&obuf, SimpleTime(NO_TIME)) != OK) {
DBufFree(&obuf); DBufFree(&obuf);
DBufFree(&raw_buf); DBufFree(&raw_buf);
@@ -2335,7 +2335,7 @@ static int DoCalRem(ParsePtr p, int col)
e->if_depth = get_if_pointer() - get_base_if_pointer(); e->if_depth = get_if_pointer() - get_base_if_pointer();
e->trig = trig; e->trig = trig;
if (e->trig.tz) { if (e->trig.tz) {
e->trig.tz = StrDup(e->trig.tz); e->trig.tz = strdup(e->trig.tz);
} }
e->tt = tim; e->tt = tim;
e->wc_pos = NULL; e->wc_pos = NULL;
@@ -2344,8 +2344,8 @@ static int DoCalRem(ParsePtr p, int col)
e->r = col_r; e->r = col_r;
e->g = col_g; e->g = col_g;
e->b = col_b; e->b = col_b;
e->text = StrDup(s); e->text = strdup(s);
e->raw_text = StrDup(DBufValue(&raw_buf)); e->raw_text = strdup(DBufValue(&raw_buf));
DBufFree(&raw_buf); DBufFree(&raw_buf);
DBufFree(&obuf); DBufFree(&obuf);
DBufFree(&pre_buf); DBufFree(&pre_buf);
@@ -2661,7 +2661,7 @@ static void WriteSimpleEntryProtocol2(CalEntry *e)
PrintJSONKeyPairInt("r", e->r); PrintJSONKeyPairInt("r", e->r);
PrintJSONKeyPairInt("g", e->g); PrintJSONKeyPairInt("g", e->g);
PrintJSONKeyPairInt("b", e->b); PrintJSONKeyPairInt("b", e->b);
} else if (!StrCmpi(e->passthru, "SHADE")) { } else if (!strcasecmp(e->passthru, "SHADE")) {
int r, g, b, n; int r, g, b, n;
n = sscanf(e->text, "%d %d %d", &r, &g, &b); n = sscanf(e->text, "%d %d %d", &r, &g, &b);
if (n < 3) { if (n < 3) {

9
src/config.h.in
View File

@@ -45,21 +45,12 @@
/* Define to 1 if you have the `readline' function. */ /* Define to 1 if you have the `readline' function. */
#undef HAVE_READLINE #undef HAVE_READLINE
/* Define to 1 if you have the `strcasecmp' function. */
#undef HAVE_STRCASECMP
/* Define to 1 if you have the `strdup' function. */
#undef HAVE_STRDUP
/* Define to 1 if you have the <strings.h> header file. */ /* Define to 1 if you have the <strings.h> header file. */
#undef HAVE_STRINGS_H #undef HAVE_STRINGS_H
/* Define to 1 if you have the <string.h> header file. */ /* Define to 1 if you have the <string.h> header file. */
#undef HAVE_STRING_H #undef HAVE_STRING_H
/* Define to 1 if you have the `strncasecmp' function. */
#undef HAVE_STRNCASECMP
/* Define to 1 if you have the <sys/inotify.h> header file. */ /* Define to 1 if you have the <sys/inotify.h> header file. */
#undef HAVE_SYS_INOTIFY_H #undef HAVE_SYS_INOTIFY_H

2
src/dedupe.c
View File

@@ -101,7 +101,7 @@ InsertDedupeEntry(int trigger_date, int trigger_time, char const *body)
} }
e->trigger_date = trigger_date; e->trigger_date = trigger_date;
e->trigger_time = trigger_time; e->trigger_time = trigger_time;
e->body = StrDup(body); e->body = strdup(body);
if (!e->body) { if (!e->body) {
free(e); free(e);
return; return;

28
src/dorem.c
View File

@@ -306,11 +306,11 @@ ensure_satnode_mentions_trigdate_aux(expr_node *node, int *mentioned)
} else { } else {
name = node->u.value.v.str; name = node->u.value.v.str;
} }
if (!StrCmpi(name, "T") || if (!strcasecmp(name, "T") ||
!StrCmpi(name, "Td") || !strcasecmp(name, "Td") ||
!StrCmpi(name, "Tm") || !strcasecmp(name, "Tm") ||
!StrCmpi(name, "Tw") || !strcasecmp(name, "Tw") ||
!StrCmpi(name, "Ty")) { !strcasecmp(name, "Ty")) {
*mentioned = 1; *mentioned = 1;
return; return;
} }
@@ -1120,7 +1120,7 @@ int ParseRem(ParsePtr s, Trigger *trig, TimeTrig *tim)
if (r != OK) { if (r != OK) {
return r; return r;
} }
trig->tz = StrDup(DBufValue(&buf)); trig->tz = strdup(DBufValue(&buf));
if (!trig->tz) { if (!trig->tz) {
return E_NO_MEM; return E_NO_MEM;
} }
@@ -1576,14 +1576,14 @@ int TriggerReminder(ParsePtr p, Trigger *t, TimeTrig const *tim, int dse, int is
DBufInit(&calRow); DBufInit(&calRow);
DBufInit(&pre_buf); DBufInit(&pre_buf);
if (t->typ == RUN_TYPE && RunDisabled) return E_RUN_DISABLED; if (t->typ == RUN_TYPE && RunDisabled) return E_RUN_DISABLED;
if ((t->typ == PASSTHRU_TYPE && StrCmpi(t->passthru, "COLOR") && StrCmpi(t->passthru, "COLOUR")) || if ((t->typ == PASSTHRU_TYPE && strcasecmp(t->passthru, "COLOR") && strcasecmp(t->passthru, "COLOUR")) ||
t->typ == CAL_TYPE || t->typ == CAL_TYPE ||
t->typ == PS_TYPE || t->typ == PS_TYPE ||
t->typ == PSF_TYPE) t->typ == PSF_TYPE)
return OK; return OK;
/* Handle COLOR types */ /* Handle COLOR types */
if (t->typ == PASSTHRU_TYPE && (!StrCmpi(t->passthru, "COLOR") || !StrCmpi(t->passthru, "COLOUR"))) { if (t->typ == PASSTHRU_TYPE && (!strcasecmp(t->passthru, "COLOR") || !strcasecmp(t->passthru, "COLOUR"))) {
/* Strip off three tokens */ /* Strip off three tokens */
r = ParseToken(p, &buf); r = ParseToken(p, &buf);
sscanf(DBufValue(&buf), "%d", &red); sscanf(DBufValue(&buf), "%d", &red);
@@ -2291,17 +2291,17 @@ void FixSpecialType(Trigger *t)
} }
/* Convert SPECIAL MSG / MSF / RUN / CAL to just plain MSG / MSF / etc */ /* Convert SPECIAL MSG / MSF / RUN / CAL to just plain MSG / MSF / etc */
if (!StrCmpi(t->passthru, "MSG")) { if (!strcasecmp(t->passthru, "MSG")) {
t->typ = MSG_TYPE; t->typ = MSG_TYPE;
} else if (!StrCmpi(t->passthru, "MSF")) { } else if (!strcasecmp(t->passthru, "MSF")) {
t->typ = MSF_TYPE; t->typ = MSF_TYPE;
} else if (!StrCmpi(t->passthru, "RUN")) { } else if (!strcasecmp(t->passthru, "RUN")) {
t->typ = RUN_TYPE; t->typ = RUN_TYPE;
} else if (!StrCmpi(t->passthru, "CAL")) { } else if (!strcasecmp(t->passthru, "CAL")) {
t->typ = CAL_TYPE; t->typ = CAL_TYPE;
} else if (!StrCmpi(t->passthru, "PS")) { } else if (!strcasecmp(t->passthru, "PS")) {
t->typ = PS_TYPE; t->typ = PS_TYPE;
} else if (!StrCmpi(t->passthru, "PSFILE")) { } else if (!strcasecmp(t->passthru, "PSFILE")) {
t->typ = PSF_TYPE; t->typ = PSF_TYPE;
} }
} }

6
src/expr.c
View File

@@ -2256,7 +2256,7 @@ static int make_atom(expr_node *atom, Var *locals)
/* Variable */ /* Variable */
if (isalpha(*s) || *s == '_') { if (isalpha(*s) || *s == '_') {
while(v) { while(v) {
if (! StrinCmp(s, v->name, VAR_NAME_LEN)) { if (! strncasecmp(s, v->name, VAR_NAME_LEN)) {
atom->type = N_LOCAL_VAR; atom->type = N_LOCAL_VAR;
atom->u.arg = i; atom->u.arg = i;
return OK; return OK;
@@ -3139,7 +3139,7 @@ int CopyValue(Value *dest, const Value *src)
{ {
dest->type = ERR_TYPE; dest->type = ERR_TYPE;
if (src->type == STR_TYPE) { if (src->type == STR_TYPE) {
dest->v.str = StrDup(src->v.str); dest->v.str = strdup(src->v.str);
if (!dest->v.str) return E_NO_MEM; if (!dest->v.str) return E_NO_MEM;
} else { } else {
dest->v.val = src->v.val; dest->v.val = src->v.val;
@@ -3312,7 +3312,7 @@ int DoCoerce(char type, Value *v)
default: return E_CANT_COERCE; default: return E_CANT_COERCE;
} }
v->type = STR_TYPE; v->type = STR_TYPE;
v->v.str = StrDup(coerce_buf); v->v.str = strdup(coerce_buf);
if (!v->v.str) { if (!v->v.str) {
v->type = ERR_TYPE; v->type = ERR_TYPE;
return E_NO_MEM; return E_NO_MEM;

12
src/files.c
View File

@@ -159,7 +159,7 @@ void SetCurrentFilename(char const *fname)
fprintf(ErrFp, "Out of Memory!\n"); fprintf(ErrFp, "Out of Memory!\n");
exit(1); exit(1);
} }
e->fname = StrDup(fname); e->fname = strdup(fname);
if (!e->fname) { if (!e->fname) {
fprintf(ErrFp, "Out of Memory!\n"); fprintf(ErrFp, "Out of Memory!\n");
exit(1); exit(1);
@@ -559,7 +559,7 @@ static int CacheFile(char const *fname, int use_pclose)
return E_NO_MEM; return E_NO_MEM;
} }
cf->cache = NULL; cf->cache = NULL;
cf->filename = StrDup(fname); cf->filename = strdup(fname);
if (!cf->filename) { if (!cf->filename) {
ShouldCache = 0; ShouldCache = 0;
if (use_pclose) { if (use_pclose) {
@@ -627,7 +627,7 @@ static int CacheFile(char const *fname, int use_pclose)
cl->next = NULL; cl->next = NULL;
cl->LineNo = LineNo; cl->LineNo = LineNo;
cl->LineNoStart = LineNoStart; cl->LineNoStart = LineNoStart;
cl->text = StrDup(s); cl->text = strdup(s);
DBufFree(&LineBuffer); DBufFree(&LineBuffer);
if (!cl->text) { if (!cl->text) {
DestroyCache(cf); DestroyCache(cf);
@@ -874,7 +874,7 @@ static int SetupGlobChain(char const *dirname, IncludeStruct *i)
i->chain = NULL; i->chain = NULL;
if (!*dirname) return E_CANT_OPEN; if (!*dirname) return E_CANT_OPEN;
dir = StrDup(dirname); dir = strdup(dirname);
if (!dir) return E_NO_MEM; if (!dir) return E_NO_MEM;
/* Strip trailing slashes off directory */ /* Strip trailing slashes off directory */
@@ -916,7 +916,7 @@ static int SetupGlobChain(char const *dirname, IncludeStruct *i)
if (ShouldCache) { if (ShouldCache) {
dc = malloc(sizeof(DirectoryFilenameChain)); dc = malloc(sizeof(DirectoryFilenameChain));
if (dc) { if (dc) {
dc->dirname = StrDup(dir); dc->dirname = strdup(dir);
if (!dc->dirname) { if (!dc->dirname) {
free(dc); free(dc);
dc = NULL; dc = NULL;
@@ -972,7 +972,7 @@ static int SetupGlobChain(char const *dirname, IncludeStruct *i)
return E_NO_MEM; return E_NO_MEM;
} }
ch->filename = StrDup(glob_buf.gl_pathv[r]); ch->filename = strdup(glob_buf.gl_pathv[r]);
if (!ch->filename) { if (!ch->filename) {
globfree(&glob_buf); globfree(&glob_buf);
FreeChain(i->chain); FreeChain(i->chain);

16
src/funcs.c
View File

@@ -448,7 +448,7 @@ static int RetStrVal(char const *s, func_info *info)
RetVal.v.str = malloc(1); RetVal.v.str = malloc(1);
if (RetVal.v.str) *RetVal.v.str = 0; if (RetVal.v.str) *RetVal.v.str = 0;
} else { } else {
RetVal.v.str = StrDup(s); RetVal.v.str = strdup(s);
} }
if (!RetVal.v.str) { if (!RetVal.v.str) {
@@ -652,11 +652,11 @@ static int FCoerce(func_info *info)
it won't be destroyed */ it won't be destroyed */
DCOPYVAL(RetVal, ARG(1)); DCOPYVAL(RetVal, ARG(1));
if (! StrCmpi(s, "int")) r = DoCoerce(INT_TYPE, &RetVal); if (! strcasecmp(s, "int")) r = DoCoerce(INT_TYPE, &RetVal);
else if (! StrCmpi(s, "date")) r = DoCoerce(DATE_TYPE, &RetVal); else if (! strcasecmp(s, "date")) r = DoCoerce(DATE_TYPE, &RetVal);
else if (! StrCmpi(s, "time")) r = DoCoerce(TIME_TYPE, &RetVal); else if (! strcasecmp(s, "time")) r = DoCoerce(TIME_TYPE, &RetVal);
else if (! StrCmpi(s, "string")) r = DoCoerce(STR_TYPE, &RetVal); else if (! strcasecmp(s, "string")) r = DoCoerce(STR_TYPE, &RetVal);
else if (! StrCmpi(s, "datetime")) r = DoCoerce(DATETIME_TYPE, &RetVal); else if (! strcasecmp(s, "datetime")) r = DoCoerce(DATETIME_TYPE, &RetVal);
else { else {
Eprint("coerce(): Invalid type `%s'", s); Eprint("coerce(): Invalid type `%s'", s);
return E_CANT_COERCE; return E_CANT_COERCE;
@@ -3537,7 +3537,7 @@ static int UTCToLocalHelper(int datetime, int *ret)
old_tz = getenv("TZ"); old_tz = getenv("TZ");
if (old_tz) { if (old_tz) {
old_tz = StrDup(old_tz); old_tz = strdup(old_tz);
if (!old_tz) return E_NO_MEM; if (!old_tz) return E_NO_MEM;
} }
@@ -4281,7 +4281,7 @@ int tz_convert(int year, int month, int day,
/* backup old TZ env var */ /* backup old TZ env var */
old_tz = getenv("TZ"); old_tz = getenv("TZ");
if (old_tz) { if (old_tz) {
old_tz = StrDup(old_tz); old_tz = strdup(old_tz);
if (!old_tz) return E_NO_MEM; if (!old_tz) return E_NO_MEM;
} }
if (tgt_tz == NULL || !*tgt_tz) { if (tgt_tz == NULL || !*tgt_tz) {

4
src/hbcal.c
View File

@@ -262,14 +262,14 @@ int HebNameToNum(char const *mname)
int m=-1; int m=-1;
for (i=0; i<14; i++) { for (i=0; i<14; i++) {
if (!StrCmpi(mname, HebMonthNames[i])) { if (!strcasecmp(mname, HebMonthNames[i])) {
m = i; m = i;
break; break;
} }
} }
if (m == -1) { if (m == -1) {
for (i=0; i<14; i++) { for (i=0; i<14; i++) {
if (!StrCmpi(mname, IvritMonthNames[i])) { if (!strcasecmp(mname, IvritMonthNames[i])) {
m = i; m = i;
break; break;
} }

2
src/init.c
View File

@@ -196,7 +196,7 @@ void InitRemind(int argc, char const *argv[])
/* Initialize local time zone */ /* Initialize local time zone */
LocalTimeZone = getenv("TZ"); LocalTimeZone = getenv("TZ");
if (LocalTimeZone) { if (LocalTimeZone) {
LocalTimeZone = StrDup(LocalTimeZone); LocalTimeZone = strdup(LocalTimeZone);
if (!LocalTimeZone) { if (!LocalTimeZone) {
fprintf(stderr, "Out of memory!\n"); fprintf(stderr, "Out of memory!\n");
exit(1); exit(1);

10
src/main.c
View File

@@ -1516,11 +1516,11 @@ int DoRun(ParsePtr p)
if ( (r=ParseToken(p, &buf)) ) return r; if ( (r=ParseToken(p, &buf)) ) return r;
/* Only allow RUN ON in top-level script */ /* Only allow RUN ON in top-level script */
if (! StrCmpi(DBufValue(&buf), "ON")) { if (! strcasecmp(DBufValue(&buf), "ON")) {
if (TopLevel()) RunDisabled &= ~RUN_SCRIPT; if (TopLevel()) RunDisabled &= ~RUN_SCRIPT;
} }
/* But allow RUN OFF anywhere */ /* But allow RUN OFF anywhere */
else if (! StrCmpi(DBufValue(&buf), "OFF")) else if (! strcasecmp(DBufValue(&buf), "OFF"))
RunDisabled |= RUN_SCRIPT; RunDisabled |= RUN_SCRIPT;
else { else {
DBufFree(&buf); DBufFree(&buf);
@@ -1548,11 +1548,11 @@ int DoExpr(ParsePtr p)
if ( (r=ParseToken(p, &buf)) ) return r; if ( (r=ParseToken(p, &buf)) ) return r;
/* Only allow EXPR ON in top-level script */ /* Only allow EXPR ON in top-level script */
if (! StrCmpi(DBufValue(&buf), "ON")) { if (! strcasecmp(DBufValue(&buf), "ON")) {
if (TopLevel()) ExpressionEvaluationDisabled = 0; if (TopLevel()) ExpressionEvaluationDisabled = 0;
} }
/* But allow EXPR OFF anywhere */ /* But allow EXPR OFF anywhere */
else if (! StrCmpi(DBufValue(&buf), "OFF")) else if (! strcasecmp(DBufValue(&buf), "OFF"))
ExpressionEvaluationDisabled = 1; ExpressionEvaluationDisabled = 1;
else { else {
DBufFree(&buf); DBufFree(&buf);
@@ -2117,7 +2117,7 @@ SaveLastTrigger(Trigger const *t)
DBufInit(&(LastTrigger.tags)); DBufInit(&(LastTrigger.tags));
if (LastTrigger.tz) { if (LastTrigger.tz) {
LastTrigger.tz = StrDup(LastTrigger.tz); LastTrigger.tz = strdup(LastTrigger.tz);
} }
DBufPuts(&(LastTrigger.tags), DBufValue(&(t->tags))); DBufPuts(&(LastTrigger.tags), DBufValue(&(t->tags)));
TrigInfo *cur = t->infos; TrigInfo *cur = t->infos;

26
src/protos.h
View File

@@ -13,20 +13,8 @@
/* Suppress unused variable warnings */ /* Suppress unused variable warnings */
#define UNUSED(x) (void) x #define UNUSED(x) (void) x
#ifdef HAVE_STRDUP
#define StrDup strdup
#endif
#ifdef HAVE_STRNCASECMP
#define StrinCmp strncasecmp
#endif
#ifdef HAVE_STRCASECMP
#define StrCmpi strcasecmp
#endif
/* Define a string assignment macro - be careful!!! */ /* Define a string assignment macro - be careful!!! */
#define STRSET(x, str) { if (x) free(x); (x) = StrDup(str); } #define STRSET(x, str) { if (x) free(x); (x) = strdup(str); }
/* Define a general malloc routine for creating pointers to objects */ /* Define a general malloc routine for creating pointers to objects */
#define NEW(type) (malloc(sizeof(type))) #define NEW(type) (malloc(sizeof(type)))
@@ -131,18 +119,6 @@ int ComputeTriggerNoAdjustDuration (int today, Trigger *trig, TimeTrig const *ti
int AdjustTriggerForDuration(int today, int r, Trigger *trig, TimeTrig *tim, int save_in_globals); int AdjustTriggerForDuration(int today, int r, Trigger *trig, TimeTrig *tim, int save_in_globals);
char *StrnCpy (char *dest, char const *source, int n); char *StrnCpy (char *dest, char const *source, int n);
#ifndef HAVE_STRNCASECMP
int StrinCmp (char const *s1, char const *s2, int n);
#endif
#ifndef HAVE_STRDUP
char *StrDup (char const *s);
#endif
#ifndef HAVE_STRCASECMP
int StrCmpi (char const *s1, char const *s2);
#endif
void strtolower(char *s); void strtolower(char *s);
Var *FindVar (char const *str, int create); Var *FindVar (char const *str, int create);

2
src/queue.c
View File

@@ -155,7 +155,7 @@ int QueueReminder(ParsePtr p, Trigger *trig,
qelem->red = DefaultColorR; qelem->red = DefaultColorR;
qelem->green = DefaultColorG; qelem->green = DefaultColorG;
qelem->blue = DefaultColorB; qelem->blue = DefaultColorB;
qelem->text = StrDup(p->pos); /* Guaranteed that parser is not nested. */ qelem->text = strdup(p->pos); /* Guaranteed that parser is not nested. */
if (!qelem->text) { if (!qelem->text) {
free(qelem); free(qelem);
return E_NO_MEM; return E_NO_MEM;

48
src/rem2ps.c
View File

@@ -154,24 +154,6 @@ put_escaped_string(char const *s)
} }
} }
/***************************************************************/
/* */
/* StrCmpi */
/* */
/* Compare strings, case insensitive. */
/* */
/***************************************************************/
static int StrCmpi(char const *s1, char const *s2)
{
int r;
while (*s1 && *s2) {
r = toupper(*s1) - toupper(*s2);
if (r) return r;
s1++;
s2++;
}
return toupper(*s1) - toupper(*s2);
}
/***************************************************************/ /***************************************************************/
/* */ /* */
/* Parse the new-style JSON intermediate format */ /* Parse the new-style JSON intermediate format */
@@ -229,18 +211,18 @@ JSONToCalEntry(DynamicBuffer const *buf)
} else if (!strcmp(nm, "passthru")) { } else if (!strcmp(nm, "passthru")) {
if (v->type == json_string) { if (v->type == json_string) {
s = v->u.string.ptr; s = v->u.string.ptr;
if (!StrCmpi(s, "PostScript")) { if (!strcasecmp(s, "PostScript")) {
c->special = SPECIAL_POSTSCRIPT; c->special = SPECIAL_POSTSCRIPT;
} else if (!StrCmpi(s, "SHADE")) { } else if (!strcasecmp(s, "SHADE")) {
c->special = SPECIAL_SHADE; c->special = SPECIAL_SHADE;
} else if (!StrCmpi(s, "MOON")) { } else if (!strcasecmp(s, "MOON")) {
c->special = SPECIAL_MOON; c->special = SPECIAL_MOON;
} else if (!StrCmpi(s, "WEEK")) { } else if (!strcasecmp(s, "WEEK")) {
c->special = SPECIAL_WEEK; c->special = SPECIAL_WEEK;
} else if (!StrCmpi(s, "PSFile")) { } else if (!strcasecmp(s, "PSFile")) {
c->special = SPECIAL_PSFILE; c->special = SPECIAL_PSFILE;
} else if (!StrCmpi(s, "COLOUR") || } else if (!strcasecmp(s, "COLOUR") ||
!StrCmpi(s, "COLOR")) { !strcasecmp(s, "COLOR")) {
c->special = SPECIAL_COLOR; c->special = SPECIAL_COLOR;
} else { } else {
c->special = SPECIAL_UNKNOWN; c->special = SPECIAL_UNKNOWN;
@@ -301,20 +283,20 @@ TextToCalEntry(DynamicBuffer *buf)
strcpy(c->entry, startOfBody); strcpy(c->entry, startOfBody);
/* Save the type of SPECIAL */ /* Save the type of SPECIAL */
if (!StrCmpi(passthru, "PostScript")) { if (!strcasecmp(passthru, "PostScript")) {
c->special = SPECIAL_POSTSCRIPT; c->special = SPECIAL_POSTSCRIPT;
} else if (!StrCmpi(passthru, "SHADE")) { } else if (!strcasecmp(passthru, "SHADE")) {
c->special = SPECIAL_SHADE; c->special = SPECIAL_SHADE;
} else if (!StrCmpi(passthru, "MOON")) { } else if (!strcasecmp(passthru, "MOON")) {
c->special = SPECIAL_MOON; c->special = SPECIAL_MOON;
} else if (!StrCmpi(passthru, "WEEK")) { } else if (!strcasecmp(passthru, "WEEK")) {
c->special = SPECIAL_WEEK; c->special = SPECIAL_WEEK;
} else if (!StrCmpi(passthru, "PSFile")) { } else if (!strcasecmp(passthru, "PSFile")) {
c->special = SPECIAL_PSFILE; c->special = SPECIAL_PSFILE;
} else if (!StrCmpi(passthru, "COLOUR") || } else if (!strcasecmp(passthru, "COLOUR") ||
!StrCmpi(passthru, "COLOR")) { !strcasecmp(passthru, "COLOR")) {
c->special = SPECIAL_COLOR; c->special = SPECIAL_COLOR;
} else if (StrCmpi(passthru, "*")) { } else if (strcasecmp(passthru, "*")) {
c->special = SPECIAL_UNKNOWN; c->special = SPECIAL_UNKNOWN;
} }
return c; return c;

2
src/sort.c
View File

@@ -49,7 +49,7 @@ static Sortrem *MakeSortRem(int dse, int tim, char const *body, int typ, int pri
Sortrem *new = NEW(Sortrem); Sortrem *new = NEW(Sortrem);
if (!new) return NULL; if (!new) return NULL;
new->text = StrDup(body); new->text = strdup(body);
if (!new->text) { if (!new->text) {
free(new); free(new);
return NULL; return NULL;

6
src/trans.c
View File

@@ -443,19 +443,19 @@ DoTranslate(ParsePtr p)
r = ParseToken(p, &orig); r = ParseToken(p, &orig);
if (r) return r; if (r) return r;
r = VerifyEoln(p); r = VerifyEoln(p);
if (!StrCmpi(DBufValue(&orig), "dump")) { if (!strcasecmp(DBufValue(&orig), "dump")) {
DBufFree(&orig); DBufFree(&orig);
if (r) return r; if (r) return r;
DumpTranslationTable(stdout, 0); DumpTranslationTable(stdout, 0);
return OK; return OK;
} }
if (!StrCmpi(DBufValue(&orig), "clear")) { if (!strcasecmp(DBufValue(&orig), "clear")) {
DBufFree(&orig); DBufFree(&orig);
if (r) return r; if (r) return r;
ClearTranslationTable(); ClearTranslationTable();
return OK; return OK;
} }
if (!StrCmpi(DBufValue(&orig), "generate")) { if (!strcasecmp(DBufValue(&orig), "generate")) {
DBufFree(&orig); DBufFree(&orig);
if (r) return r; if (r) return r;
GenerateTranslationTemplate(); GenerateTranslationTemplate();

2
src/trigger.c
View File

@@ -738,7 +738,7 @@ NewTrigInfo(char const *i)
return NULL; return NULL;
} }
ti->next = NULL; ti->next = NULL;
ti->info = StrDup(i); ti->info = strdup(i);
if (!ti->info) { if (!ti->info) {
free(ti); free(ti);
return NULL; return NULL;

6
src/userfns.c
View File

@@ -318,7 +318,7 @@ int DoFset(ParsePtr p)
} }
/* If we've already seen this local variable, error */ /* If we've already seen this local variable, error */
for (i=0; i<func->nargs; i++) { for (i=0; i<func->nargs; i++) {
if (!StrinCmp(DBufValue(&buf), local_array[i].name, VAR_NAME_LEN)) { if (!strncasecmp(DBufValue(&buf), local_array[i].name, VAR_NAME_LEN)) {
DBufFree(&buf); DBufFree(&buf);
DestroyUserFunc(func); DestroyUserFunc(func);
return E_REPEATED_ARG; return E_REPEATED_ARG;
@@ -393,7 +393,7 @@ int DoFset(ParsePtr p)
return E_NO_MEM; return E_NO_MEM;
} }
for (i=0; i<func->nargs; i++) { for (i=0; i<func->nargs; i++) {
func->args[i] = StrDup(local_array[i].name); func->args[i] = strdup(local_array[i].name);
if (!func->args[i]) { if (!func->args[i]) {
DestroyUserFunc(func); DestroyUserFunc(func);
return E_NO_MEM; return E_NO_MEM;
@@ -619,7 +619,7 @@ static UserFunc *clone_userfunc(char const *name, int *r)
return NULL; return NULL;
} }
for (i=0; i<dest->nargs; i++) { for (i=0; i<dest->nargs; i++) {
dest->args[i] = StrDup(src->args[i]); dest->args[i] = strdup(src->args[i]);
if (!dest->args[i]) { if (!dest->args[i]) {
DestroyUserFunc(dest); DestroyUserFunc(dest);
return NULL; return NULL;

61
src/utils.c
View File

@@ -140,67 +140,6 @@ char *StrnCpy(char *dest, char const *source, int n)
return odest; return odest;
} }
#ifndef HAVE_STRNCASECMP
/***************************************************************/
/* */
/* StrinCmp - compare strings, case-insensitive */
/* */
/***************************************************************/
int StrinCmp(char const *s1, char const *s2, int n)
{
register int r;
while (n && *s1 && *s2) {
n--;
r = toupper(*s1) - toupper(*s2);
if (r) return r;
s1++;
s2++;
}
if (n) return (toupper(*s1) - toupper(*s2)); else return 0;
}
#endif
#ifndef HAVE_STRDUP
/***************************************************************/
/* */
/* StrDup */
/* */
/* Like ANSI strdup */
/* */
/***************************************************************/
char *StrDup(char const *s)
{
char *ret = malloc(strlen(s)+1);
if (!ret) return NULL;
strcpy(ret, s);
return ret;
}
#endif
#ifndef HAVE_STRCASECMP
/***************************************************************/
/* */
/* StrCmpi */
/* */
/* Compare strings, case insensitive. */
/* */
/***************************************************************/
int StrCmpi(char const *s1, char const *s2)
{
int r;
while (*s1 && *s2) {
r = toupper(*s1) - toupper(*s2);
if (r) return r;
s1++;
s2++;
}
return toupper(*s1) - toupper(*s2);
}
#endif
/***************************************************************/ /***************************************************************/
/* */ /* */
/* DateOK */ /* DateOK */

24
src/var.c
View File

@@ -52,7 +52,7 @@ static int VarCompareFunc(void const *a, void const *b)
{ {
Var *x = (Var *) a; Var *x = (Var *) a;
Var *y = (Var *) b; Var *y = (Var *) b;
return StrCmpi(x->name, y->name); return strcasecmp(x->name, y->name);
} }
void void
@@ -220,15 +220,15 @@ static int warning_level_func(int do_set, Value *val)
if (!strcmp(val->v.str, VERSION)) { if (!strcmp(val->v.str, VERSION)) {
WarningLevel = NULL; WarningLevel = NULL;
} else { } else {
WarningLevel = StrDup(val->v.str); WarningLevel = strdup(val->v.str);
if (!WarningLevel) return E_NO_MEM; if (!WarningLevel) return E_NO_MEM;
} }
return OK; return OK;
} }
if (!WarningLevel) { if (!WarningLevel) {
val->v.str = StrDup(VERSION); val->v.str = strdup(VERSION);
} else { } else {
val->v.str = StrDup(WarningLevel); val->v.str = strdup(WarningLevel);
} }
if (!val->v.str) { if (!val->v.str) {
return E_NO_MEM; return E_NO_MEM;
@@ -257,14 +257,14 @@ static int oncefile_func(int do_set, Value *val)
if (OnceFile) { if (OnceFile) {
free( (void *) OnceFile); free( (void *) OnceFile);
} }
OnceFile = StrDup(val->v.str); OnceFile = strdup(val->v.str);
if (!OnceFile) return E_NO_MEM; if (!OnceFile) return E_NO_MEM;
return OK; return OK;
} }
if (!OnceFile) { if (!OnceFile) {
val->v.str = StrDup(""); val->v.str = strdup("");
} else { } else {
val->v.str = StrDup(OnceFile); val->v.str = strdup(OnceFile);
} }
if (!val->v.str) return E_NO_MEM; if (!val->v.str) return E_NO_MEM;
val->type = STR_TYPE; val->type = STR_TYPE;
@@ -1397,9 +1397,9 @@ static int GetTranslatableVariable(SysVar const *v, Value *value)
{ {
char const *translated = tr((char const *) v->value); char const *translated = tr((char const *) v->value);
if (translated) { if (translated) {
value->v.str = StrDup(translated); value->v.str = strdup(translated);
} else { } else {
value->v.str = StrDup(""); value->v.str = strdup("");
} }
if (!value->v.str) return E_NO_MEM; if (!value->v.str) return E_NO_MEM;
value->type = STR_TYPE; value->type = STR_TYPE;
@@ -1491,9 +1491,9 @@ int GetSysVar(char const *name, Value *val)
return f(0, val); return f(0, val);
} else if (v->type == STR_TYPE) { } else if (v->type == STR_TYPE) {
if (! * (char **) v->value) { if (! * (char **) v->value) {
val->v.str = StrDup(""); val->v.str = strdup("");
} else { } else {
val->v.str = StrDup(*((char **) v->value)); val->v.str = strdup(*((char **) v->value));
} }
if (!val->v.str) return E_NO_MEM; if (!val->v.str) return E_NO_MEM;
} else { } else {
@@ -1524,7 +1524,7 @@ SysVar *FindSysVar(char const *name)
int r; int r;
while (top >= bottom) { while (top >= bottom) {
r = StrCmpi(name, SysVarArr[mid].name); r = strcasecmp(name, SysVarArr[mid].name);
if (!r) return &SysVarArr[mid]; if (!r) return &SysVarArr[mid];
else if (r>0) bottom = mid+1; else if (r>0) bottom = mid+1;
else top = mid-1; else top = mid-1;