Removed the space between function names and the opening parenthesis.
authormarkus schnalke <meillo@marmaro.de>
Tue, 1 Nov 2011 08:05:30 +0000 (09:05 +0100)
committermarkus schnalke <meillo@marmaro.de>
Tue, 1 Nov 2011 08:05:30 +0000 (09:05 +0100)
165 files changed:
h/aliasbr.h
h/crawl_folders.h
h/dropsbr.h
h/fmt_scan.h
h/mf.h
h/mh.h
h/mhparse.h
h/mts.h
h/nmh.h
h/picksbr.h
h/prototypes.h
h/scansbr.h
h/signals.h
h/tws.h
sbr/addrsbr.c
sbr/ambigsw.c
sbr/brkstring.c
sbr/check_charset.c
sbr/closefds.c
sbr/concat.c
sbr/context_del.c
sbr/context_find.c
sbr/context_foil.c
sbr/context_read.c
sbr/context_replace.c
sbr/context_save.c
sbr/copyip.c
sbr/cpydata.c
sbr/cpydgst.c
sbr/crawl_folders.c
sbr/discard.c
sbr/dtime.c
sbr/error.c
sbr/fdcompare.c
sbr/fmt_addr.c
sbr/fmt_compile.c
sbr/fmt_new.c
sbr/fmt_rfc2047.c
sbr/fmt_scan.c
sbr/folder_addmsg.c
sbr/folder_delmsgs.c
sbr/folder_free.c
sbr/folder_pack.c
sbr/folder_read.c
sbr/folder_realloc.c
sbr/gans.c
sbr/getans.c
sbr/getanswer.c
sbr/getarguments.c
sbr/getcpy.c
sbr/getfolder.c
sbr/lock_file.c
sbr/m_atoi.c
sbr/m_backup.c
sbr/m_convert.c
sbr/m_draft.c
sbr/m_getfld.c
sbr/m_gmprot.c
sbr/m_maildir.c
sbr/m_mktemp.c
sbr/m_name.c
sbr/makedir.c
sbr/mf.c
sbr/mts.c
sbr/path.c
sbr/pidstatus.c
sbr/pidwait.c
sbr/print_help.c
sbr/print_sw.c
sbr/print_version.c
sbr/push.c
sbr/putenv.c
sbr/readconfig.c
sbr/refile.c
sbr/ruserpass.c
sbr/seq_add.c
sbr/seq_bits.c
sbr/seq_del.c
sbr/seq_getnum.c
sbr/seq_list.c
sbr/seq_nameok.c
sbr/seq_print.c
sbr/seq_read.c
sbr/seq_save.c
sbr/seq_setcur.c
sbr/seq_setprev.c
sbr/seq_setunseen.c
sbr/showfile.c
sbr/signals.c
sbr/snprintb.c
sbr/ssequal.c
sbr/strcasecmp.c
sbr/strdup.c
sbr/strindex.c
sbr/trimcpy.c
sbr/uprf.c
sbr/utils.c
sbr/vfgets.c
uip/ali.c
uip/aliasbr.c
uip/anno.c
uip/annosbr.c
uip/ap.c
uip/burst.c
uip/comp.c
uip/conflict.c
uip/dist.c
uip/distsbr.c
uip/dp.c
uip/dropsbr.c
uip/flist.c
uip/fmtdump.c
uip/folder.c
uip/forw.c
uip/ftpsbr.c
uip/inc.c
uip/install-mh.c
uip/mark.c
uip/mhbuild.c
uip/mhbuildsbr.c
uip/mhcachesbr.c
uip/mhfree.c
uip/mhl.c
uip/mhlist.c
uip/mhlistsbr.c
uip/mhlsbr.c
uip/mhmail.c
uip/mhmisc.c
uip/mhoutsbr.c
uip/mhparam.c
uip/mhparse.c
uip/mhpath.c
uip/mhshow.c
uip/mhshowsbr.c
uip/mhstore.c
uip/mhstoresbr.c
uip/mhtest.c
uip/msgchk.c
uip/new.c
uip/packf.c
uip/pick.c
uip/picksbr.c
uip/prompter.c
uip/rcvdist.c
uip/rcvpack.c
uip/rcvstore.c
uip/rcvtty.c
uip/refile.c
uip/repl.c
uip/replsbr.c
uip/rmf.c
uip/rmm.c
uip/scan.c
uip/scansbr.c
uip/send.c
uip/sendsbr.c
uip/show.c
uip/slocal.c
uip/sortm.c
uip/spost.c
uip/termsbr.c
uip/viamail.c
uip/whatnow.c
uip/whatnowproc.c
uip/whatnowsbr.c

index 5405531..c38223a 100644 (file)
@@ -33,17 +33,17 @@ struct home {
        struct home *h_next;    /* next home in list                     */
 };
 
-struct home *seek_home (char *);
+struct home *seek_home(char *);
 
 /*
 ** prototypes
 */
-int alias (char *);
-int akvisible (void);
-void init_pw (void);
-char *akresult (struct aka *);
-char *akvalue (char *);
-char *akerror (int);
+int alias(char *);
+int akvisible(void);
+void init_pw(void);
+char *akresult(struct aka *);
+char *akvalue(char *);
+char *akerror(int);
 
 /* codes returned by alias() */
 
index e81acb1..afc249c 100644 (file)
@@ -16,4 +16,4 @@ typedef boolean (crawl_callback_t)(char *folder, void *baton);
 ** directory) and `baton'; the callback may direct crawl_folders not to crawl
 ** its children; see above.
 */
-void crawl_folders (char *dir, crawl_callback_t *callback, void *baton);
+void crawl_folders(char *dir, crawl_callback_t *callback, void *baton);
index 2742ae6..b32d316 100644 (file)
@@ -43,13 +43,13 @@ struct drop {
 /*
 ** prototypes
 */
-int mbx_open (char *, int, uid_t, gid_t, mode_t);
-int mbx_read (FILE *, long, struct drop **, int);
+int mbx_open(char *, int, uid_t, gid_t, mode_t);
+int mbx_read(FILE *, long, struct drop **, int);
 int mbx_write(char *, int, FILE *, int, long, long, off_t, int, int);
-int mbx_copy (char *, int, int, int, int, char *, int);
-int mbx_size (int, off_t, off_t);
-int mbx_close (char *, int);
-char *map_name (char *);
-int map_read (char *, long, struct drop **, int);
-int map_write (char *, int, int, long, off_t, off_t, long, int, int);
-int map_chk (char *, int, struct drop *, long, int);
+int mbx_copy(char *, int, int, int, int, char *, int);
+int mbx_size(int, off_t, off_t);
+int mbx_close(char *, int);
+char *map_name(char *);
+int map_read(char *, long, struct drop **, int);
+int map_write(char *, int, int, long, off_t, off_t, long, int, int);
+int map_chk(char *, int, struct drop *, long, int);
index f65dab1..96acd56 100644 (file)
@@ -87,6 +87,6 @@ struct format {
 /*
 ** prototypes
 */
-struct format *fmt_scan (struct format *, char *, int, int *);
-char *new_fs (char *, char *, char *);
-int fmt_compile (char *, struct format **);
+struct format *fmt_scan(struct format *, char *, int, int *);
+char *new_fs(char *, char *, char *);
+int fmt_compile(char *, struct format **);
diff --git a/h/mf.h b/h/mf.h
index b5a7892..373a692 100644 (file)
--- a/h/mf.h
+++ b/h/mf.h
@@ -68,5 +68,5 @@ struct adrx {
 /*
 ** prototypes
 */
-char *legal_person (char *);
-struct adrx *getadrx (char *);
+char *legal_person(char *);
+struct adrx *getadrx(char *);
diff --git a/h/mh.h b/h/mh.h
index 70bfee7..2e3be95 100644 (file)
--- a/h/mh.h
+++ b/h/mh.h
@@ -263,7 +263,7 @@ extern char *msg_delim;      /*  .. */
 ** miscellaneous macros
 */
 
-#define pidXwait(pid,cp) pidstatus (pidwait (pid, NOTOK), stdout, cp)
+#define pidXwait(pid,cp) pidstatus(pidwait(pid, NOTOK), stdout, cp)
 
 #ifndef max
 # define max(a,b) ((a) > (b) ? (a) : (b))
index bef3f4f..9d31c4a 100644 (file)
@@ -271,12 +271,12 @@ extern struct str2init str2methods[];
 /*
 ** prototypes
 */
-int pidcheck (int);
-CT parse_mime (char *);
-int add_header (CT, char *, char *);
-int get_ctinfo (unsigned char *, CT, int);
-int params_external (CT, int);
-int open7Bit (CT, char **);
-void close_encoding (CT);
+int pidcheck(int);
+CT parse_mime(char *);
+int add_header(CT, char *, char *);
+int get_ctinfo(unsigned char *, CT, int);
+int params_external(CT, int);
+int open7Bit(CT, char **);
+void close_encoding(CT);
 
 extern int checksw;    /* Add Content-MD5 field */
diff --git a/h/mts.h b/h/mts.h
index df1d9b5..5ddd837 100644 (file)
--- a/h/mts.h
+++ b/h/mts.h
@@ -16,10 +16,10 @@ extern char *mmdflfil;
 extern char *uucpldir;
 extern char *uucplfil;
 
-#define MAILDIR (mmdfldir && *mmdfldir ? mmdfldir : getenv ("HOME"))
-#define MAILFIL (mmdflfil && *mmdflfil ? mmdflfil : getusername ())
-#define UUCPDIR (uucpldir && *uucpldir ? uucpldir : getenv ("HOME"))
-#define UUCPFIL (uucplfil && *uucplfil ? uucplfil : getusername ())
+#define MAILDIR (mmdfldir && *mmdfldir ? mmdfldir : getenv("HOME"))
+#define MAILFIL (mmdflfil && *mmdflfil ? mmdflfil : getusername())
+#define UUCPDIR (uucpldir && *uucpldir ? uucpldir : getenv("HOME"))
+#define UUCPFIL (uucplfil && *uucplfil ? uucplfil : getusername())
 
 char *getusername(void);
 char *getfullname(void);
@@ -30,13 +30,13 @@ char *getfullname(void);
 extern char *mmdlm1;
 extern char *mmdlm2;
 
-#define isdlm1(s) (strcmp (s, mmdlm1) == 0)
-#define isdlm2(s) (strcmp (s, mmdlm2) == 0)
+#define isdlm1(s) (strcmp(s, mmdlm1) == 0)
+#define isdlm2(s) (strcmp(s, mmdlm2) == 0)
 
 /*
 ** Read mts.conf file
 */
-void mts_init (char *);
+void mts_init(char *);
 
 /*
 ** Global MailDelivery File
diff --git a/h/nmh.h b/h/nmh.h
index 4ae127d..75d4d2a 100644 (file)
--- a/h/nmh.h
+++ b/h/nmh.h
 #include <signal.h>
 
 #define bcmp(b1,b2,length)      memcmp(b1, b2, length)
-#define bcopy(b1,b2,length)     memcpy (b2, b1, length)
-#define bcpy(b1,b2,length)      memcmp (b1, b2, length)
-#define bzero(b,length)         memset (b, 0, length)
+#define bcopy(b1,b2,length)     memcpy(b2, b1, length)
+#define bcpy(b1,b2,length)      memcmp(b1, b2, length)
+#define bzero(b,length)         memset(b, 0, length)
 
 #ifdef HAVE_KILLPG
 # define KILLPG(pgrp,sig) killpg(pgrp,sig);
index d69825a..31b904e 100644 (file)
@@ -5,5 +5,5 @@
 /*
 ** prototypes
 */
-int pcompile (char **, char *);
-int pmatches (FILE *, int, long, long);
+int pcompile(char **, char *);
+int pmatches(FILE *, int, long, long);
index baf40d9..81c4801 100644 (file)
@@ -6,12 +6,12 @@
 ** missing system prototypes
 */
 #ifndef HAVE_TERMCAP_H
-extern int tgetent (char *bp, char *name);
-extern int tgetnum (char *id);
-extern int tgetflag (char *id);
-extern char *tgetstr (char *id, char **area);
-extern char *tgoto (char *cm, int destcol, int destline);
-extern int tputs (char *cp, int affcnt, int (*outc) (int));
+extern int tgetent(char *bp, char *name);
+extern int tgetnum(char *id);
+extern int tgetflag(char *id);
+extern char *tgetstr(char *id, char **area);
+extern char *tgoto(char *cm, int destcol, int destline);
+extern int tputs(char *cp, int affcnt, int (*outc) (int));
 #endif
 
 /*
@@ -22,119 +22,119 @@ char *etcpath(char *);
 /*
 ** prototypes from the nmh subroutine library
 */
-void adios (char *, char *, ...) NORETURN;
-void admonish (char *, char *, ...);
-void advertise (char *, char *, char *, va_list);
-void advise (char *, char *, ...);
-void ambigsw (char *, struct swit *);
+void adios(char *, char *, ...) NORETURN;
+void admonish(char *, char *, ...);
+void advertise(char *, char *, char *, va_list);
+void advise(char *, char *, ...);
+void ambigsw(char *, struct swit *);
 int atooi(char *);
-char **brkstring (char *, char *, char *);
-int check_charset (char *, int);
+char **brkstring(char *, char *, char *);
+int check_charset(char *, int);
 void closefds(int);
-char *concat (char *, ...);
-int context_del (char *);
-char *context_find (char *);
-int context_foil (char *);
-void context_read (void);
-void context_replace (char *, char *);
-void context_save (void);
-char *copy (char *, char *);
-char **copyip (char **, char **, int);
-void cpydata (int, int, char *, char *);
-void cpydgst (int, int, char *, char *);
-int decode_rfc2047 (char *, char *, size_t);
-void discard (FILE *);
-int default_done (int);
+char *concat(char *, ...);
+int context_del(char *);
+char *context_find(char *);
+int context_foil(char *);
+void context_read(void);
+void context_replace(char *, char *);
+void context_save(void);
+char *copy(char *, char *);
+char **copyip(char **, char **, int);
+void cpydata(int, int, char *, char *);
+void cpydgst(int, int, char *, char *);
+int decode_rfc2047(char *, char *, size_t);
+void discard(FILE *);
+int default_done(int);
 int ext_hook(char *, char *, char *);
-int fdcompare (int, int);
-int folder_addmsg (struct msgs **, char *, int, int, int, int, char *);
-int folder_delmsgs (struct msgs *, int, int);
-void folder_free (struct msgs *);
-int folder_pack (struct msgs **, int);
-struct msgs *folder_read (char *);
-struct msgs *folder_realloc (struct msgs *, int, int);
-int gans (char *, struct swit *);
-char **getans (char *, struct swit *);
-int getanswer (char *);
-char **getarguments (char *, int, char **, int);
+int fdcompare(int, int);
+int folder_addmsg(struct msgs **, char *, int, int, int, int, char *);
+int folder_delmsgs(struct msgs *, int, int);
+void folder_free(struct msgs *);
+int folder_pack(struct msgs **, int);
+struct msgs *folder_read(char *);
+struct msgs *folder_realloc(struct msgs *, int, int);
+int gans(char *, struct swit *);
+char **getans(char *, struct swit *);
+int getanswer(char *);
+char **getarguments(char *, int, char **, int);
 char *get_charset();
-char *getcpy (char *);
+char *getcpy(char *);
 char *getfolder(int);
 int lkclose(int, char*);
 int lkfclose(FILE *, char *);
 FILE *lkfopen(char *, char *);
 int lkopen(char *, int, mode_t);
-int m_atoi (char *);
-char *m_backup (char *);
-int m_convert (struct msgs *, char *);
-char *m_draft (char *);
-int m_getfld (int, unsigned char *, unsigned char *, int, FILE *);
-int m_gmprot (void);
-char *m_maildir (char *);
-char *m_mailpath (char *);
-char *m_name (int);
-int m_putenv (char *, char *);
+int m_atoi(char *);
+char *m_backup(char *);
+int m_convert(struct msgs *, char *);
+char *m_draft(char *);
+int m_getfld(int, unsigned char *, unsigned char *, int, FILE *);
+int m_gmprot(void);
+char *m_maildir(char *);
+char *m_mailpath(char *);
+char *m_name(int);
+int m_putenv(char *, char *);
 char *m_mktemp(const char *, int *, FILE **);
 char *m_mktemp2(const char *, const char *, int *, FILE **);
 void m_unknown(FILE *);
-int makedir (char *);
+int makedir(char *);
 char *nmh_getpass(const char *);
 char *norm_charmap(char *);
-char *new_fs (char *, char *, char *);
+char *new_fs(char *, char *, char *);
 char *path(char *, int);
 int peekc(FILE *ib);
-int pidwait (pid_t, int);
-int pidstatus (int, FILE *, char *);
+int pidwait(pid_t, int);
+int pidstatus(int, FILE *, char *);
 char *pluspath(char *);
-void print_help (char *, struct swit *, int);
-void print_sw (char *, struct swit *, char *, FILE *);
-void print_version (char *);
-void push (void);
-char *pwd (void);
+void print_help(char *, struct swit *, int);
+void print_sw(char *, struct swit *, char *, FILE *);
+void print_version(char *);
+void push(void);
+char *pwd(void);
 char *r1bindex(char *, int);
-void readconfig (struct node **, FILE *, char *, int);
-int refile (char **, char *);
+void readconfig(struct node **, FILE *, char *, int);
+int refile(char **, char *);
 void ruserpass(char *, char **, char **);
-int seq_addmsg (struct msgs *, char *, int, int, int);
-int seq_addsel (struct msgs *, char *, int, int);
-char *seq_bits (struct msgs *);
-int seq_delmsg (struct msgs *, char *, int);
-int seq_delsel (struct msgs *, char *, int, int);
-int seq_getnum (struct msgs *, char *);
-char *seq_list (struct msgs *, char *);
-int seq_nameok (unsigned char *);
-void seq_print (struct msgs *, char *);
-void seq_printall (struct msgs *);
-void seq_read (struct msgs *);
-void seq_save (struct msgs *);
-void seq_setcur (struct msgs *, int);
-void seq_setprev (struct msgs *);
-void seq_setunseen (struct msgs *, int);
-int showfile (char **, char *);
+int seq_addmsg(struct msgs *, char *, int, int, int);
+int seq_addsel(struct msgs *, char *, int, int);
+char *seq_bits(struct msgs *);
+int seq_delmsg(struct msgs *, char *, int);
+int seq_delsel(struct msgs *, char *, int, int);
+int seq_getnum(struct msgs *, char *);
+char *seq_list(struct msgs *, char *);
+int seq_nameok(unsigned char *);
+void seq_print(struct msgs *, char *);
+void seq_printall(struct msgs *);
+void seq_read(struct msgs *);
+void seq_save(struct msgs *);
+void seq_setcur(struct msgs *, int);
+void seq_setprev(struct msgs *);
+void seq_setunseen(struct msgs *, int);
+int showfile(char **, char *);
 int smatch(char *, struct swit *);
-char *snprintb (char *, size_t, unsigned, char *);
-int ssequal (char *, char *);
-int stringdex (char *, char *);
-char *trimcpy (unsigned char *);
-int unputenv (char *);
-int uprf (char *, char *);
-int vfgets (FILE *, char **);
-char *write_charset_8bit (void);
+char *snprintb(char *, size_t, unsigned, char *);
+int ssequal(char *, char *);
+int stringdex(char *, char *);
+char *trimcpy(unsigned char *);
+int unputenv(char *);
+int uprf(char *, char *);
+int vfgets(FILE *, char **);
+char *write_charset_8bit(void);
 
 #ifdef RPATHS
-int get_returnpath (char *, int, char *, int);
+int get_returnpath(char *, int, char *, int);
 #endif
 
 /*
 ** prototypes for compatibility functions in library
 */
 #ifndef HAVE_SNPRINTF_PROTOTYPE
-int snprintf (char *, size_t, const char *, ...);
-int vsnprintf (char *, size_t, const char *, va_list);
+int snprintf(char *, size_t, const char *, ...);
+int vsnprintf(char *, size_t, const char *, va_list);
 #endif
 
-int mh_strcasecmp (const char *s1, const char *s2);
-int strncasecmp (const char *s1, const char *s2, size_t n);
+int mh_strcasecmp(const char *s1, const char *s2);
+int strncasecmp(const char *s1, const char *s2, size_t n);
 
 
 /*
@@ -148,12 +148,12 @@ char *OfficialName(char *);
 /*
 ** prototypes for some routines in uip
 */
-int annotate (char *, char *, char *, int, int, int, int);
+int annotate(char *, char *, char *, int, int, int, int);
 void annolist(char *, char *, char *, int);
 void annopreserve(int);
-int distout (char *, char *, char *);
-void replout (FILE *, char *, char *, struct msgs *, int,
-               int, char *, char *, char *);
-int sendsbr (char **, int, char *, struct stat *, int, char *, int);
-int what_now (char *, int, int, char *, char *,
-               int, struct msgs *, char *, int, char *);
+int distout(char *, char *, char *);
+void replout(FILE *, char *, char *, struct msgs *, int, int,
+               char *, char *, char *);
+int sendsbr(char **, int, char *, struct stat *, int, char *, int);
+int what_now(char *, int, int, char *, char *, int, struct msgs *,
+               char *, int, char *);
index bba2b44..45dd1fe 100644 (file)
@@ -35,4 +35,4 @@ extern char *scanl;
 /*
 ** prototypes
 */
-int scan (FILE *, int, int, char *, int, int, int, char *, long, int);
+int scan(FILE *, int, int, char *, int, int, int, char *, long, int);
index 645c340..d805d19 100644 (file)
@@ -26,6 +26,6 @@ typedef RETSIGTYPE (*SIGNAL_HANDLER)(int);
 /*
 ** prototypes
 */
-int SIGPROCMASK (int, const sigset_t *, sigset_t *);
-SIGNAL_HANDLER SIGNAL (int, SIGNAL_HANDLER);
-SIGNAL_HANDLER SIGNAL2 (int, SIGNAL_HANDLER);
+int SIGPROCMASK(int, const sigset_t *, sigset_t *);
+SIGNAL_HANDLER SIGNAL(int, SIGNAL_HANDLER);
+SIGNAL_HANDLER SIGNAL2(int, SIGNAL_HANDLER);
diff --git a/h/tws.h b/h/tws.h
index 77ccaa6..289a673 100644 (file)
--- a/h/tws.h
+++ b/h/tws.h
@@ -44,7 +44,7 @@ struct tws {
 #define TW_YES   0x0040  /*   yes, found                   */
 #define TW_NO    0x0000  /*   no, not found                */
 
-#define dtwszone(tw) dtimezone (tw->tw_zone, tw->tw_flags)
+#define dtwszone(tw) dtimezone(tw->tw_zone, tw->tw_flags)
 
 extern char *tw_dotw[];
 extern char *tw_ldotw[];
@@ -53,17 +53,17 @@ extern char *tw_moty[];
 /*
 ** prototypes
 */
-char *dtime (time_t *, int);
-char *dtimenow (int);
-char *dctime (struct tws *);
-struct tws *dlocaltimenow (void);
-struct tws *dlocaltime (time_t *);
-struct tws *dgmtime (time_t *);
-char *dasctime (struct tws *, int);
-char *dtimezone (int, int);
-void twscopy (struct tws *, struct tws *);
-int twsort (struct tws *, struct tws *);
-time_t dmktime (struct tws *);
-void set_dotw (struct tws *);
+char *dtime(time_t *, int);
+char *dtimenow(int);
+char *dctime(struct tws *);
+struct tws *dlocaltimenow(void);
+struct tws *dlocaltime(time_t *);
+struct tws *dgmtime(time_t *);
+char *dasctime(struct tws *, int);
+char *dtimezone(int, int);
+void twscopy(struct tws *, struct tws *);
+int twsort(struct tws *, struct tws *);
+time_t dmktime(struct tws *);
+void set_dotw(struct tws *);
 
-struct tws *dparsetime (char *);
+struct tws *dparsetime(char *);
index c8eb0c8..df81839 100644 (file)
@@ -79,21 +79,21 @@ extern boolean  username_extension_masquerading;  /* defined in mts.c */
 /*
 ** external prototypes
 */
-char *getusername (void);
+char *getusername(void);
 
 
 char *
-getname (char *addrs)
+getname(char *addrs)
 {
        struct adrx *ap;
 
        pers = mbox = host = route = grp = note = NULL;
        err[0] = '\0';
 
-       if ((ap = getadrx (addrs ? addrs : "")) == NULL)
+       if ((ap = getadrx(addrs ? addrs : "")) == NULL)
                return NULL;
 
-       strncpy (adr, ap->text, sizeof(adr));
+       strncpy(adr, ap->text, sizeof(adr));
        pers = ap->pers;
        mbox = ap->mbox;
        host = ap->host;
@@ -102,14 +102,14 @@ getname (char *addrs)
        ingrp = ap->ingrp;
        note = ap->note;
        if (ap->err && *ap->err)
-               strncpy (err, ap->err, sizeof(err));
+               strncpy(err, ap->err, sizeof(err));
 
        return adr;
 }
 
 
 struct mailname *
-getm (char *str, char *dfhost, int dftype, int wanthost, char *eresult)
+getm(char *str, char *dfhost, int dftype, int wanthost, char *eresult)
 {
        char *pp;
        struct mailname *mp;
@@ -119,70 +119,70 @@ getm (char *str, char *dfhost, int dftype, int wanthost, char *eresult)
 
        if (err[0]) {
                if (eresult)
-                       strcpy (eresult, err);
+                       strcpy(eresult, err);
                else
                        if (wanthost == AD_HOST)
-                               admonish (NULL, "bad address '%s' - %s", str, err);
+                               admonish(NULL, "bad address '%s' - %s", str, err);
                return NULL;
        }
        if (pers == NULL && mbox == NULL && host == NULL && route == NULL
                && grp == NULL) {
                if (eresult)
-                       strcpy (eresult, "null address");
+                       strcpy(eresult, "null address");
                else
                        if (wanthost == AD_HOST)
-                               admonish (NULL, "null address '%s'", str);
+                               admonish(NULL, "null address '%s'", str);
                return NULL;
        }
        if (mbox == NULL && grp == NULL) {
                if (eresult)
-                       strcpy (eresult, "no mailbox in address");
+                       strcpy(eresult, "no mailbox in address");
                else if (wanthost == AD_HOST)
-                       admonish (NULL, "no mailbox in address '%s'", str);
+                       admonish(NULL, "no mailbox in address '%s'", str);
                return NULL;
        }
 
        if (dfhost == NULL) {
-               dfhost = LocalName ();
+               dfhost = LocalName();
                dftype = LOCALHOST;
        }
 
-       mp = (struct mailname *) calloc ((size_t) 1, sizeof(*mp));
+       mp = (struct mailname *) calloc((size_t) 1, sizeof(*mp));
        if (mp == NULL) {
                if (eresult)
-                       strcpy (eresult, "insufficient memory to represent address");
+                       strcpy(eresult, "insufficient memory to represent address");
                else if (wanthost == AD_HOST)
-                       adios (NULL, "insufficient memory to represent address");
+                       adios(NULL, "insufficient memory to represent address");
                return NULL;
        }
 
        mp->m_next = NULL;
-       mp->m_text = getcpy (str);
+       mp->m_text = getcpy(str);
        if (pers)
-               mp->m_pers = getcpy (pers);
+               mp->m_pers = getcpy(pers);
 
        if (mbox == NULL) {
                mp->m_type = BADHOST;
                mp->m_nohost = 1;
                mp->m_ingrp = ingrp;
-               mp->m_gname = getcpy (grp);
+               mp->m_gname = getcpy(grp);
                if (note)
-                       mp->m_note = getcpy (note);
+                       mp->m_note = getcpy(note);
                return mp;
        }
 
        if (host) {
-               mp->m_mbox = getcpy (mbox);
-               mp->m_host = getcpy (host);
+               mp->m_mbox = getcpy(mbox);
+               mp->m_host = getcpy(host);
        } else {
                if ((pp = strchr(mbox, '!'))) {
                        *pp++ = '\0';
-                       mp->m_mbox = getcpy (pp);
-                       mp->m_host = getcpy (mbox);
+                       mp->m_mbox = getcpy(pp);
+                       mp->m_host = getcpy(mbox);
                        mp->m_type = UUCPHOST;
                } else {
                        mp->m_nohost = 1;
-                       mp->m_mbox = getcpy (mbox);
+                       mp->m_mbox = getcpy(mbox);
 #ifdef DUMB
                        if (route == NULL && dftype == LOCALHOST) {
                                mp->m_host = NULL;
@@ -190,7 +190,7 @@ getm (char *str, char *dfhost, int dftype, int wanthost, char *eresult)
                        } else
 #endif /* DUMB */
                        {
-                               mp->m_host = route ? NULL : getcpy (dfhost);
+                               mp->m_host = route ? NULL : getcpy(dfhost);
                                mp->m_type = route ? NETHOST : dftype;
                        }
                }
@@ -198,22 +198,22 @@ getm (char *str, char *dfhost, int dftype, int wanthost, char *eresult)
        }
 
        if (wanthost == AD_NHST)
-               mp->m_type = !mh_strcasecmp (LocalName (), mp->m_host)
+               mp->m_type = !mh_strcasecmp(LocalName(), mp->m_host)
                        ? LOCALHOST : NETHOST;
 #ifdef DUMB
        else
-               mp->m_type = mh_strcasecmp (LocalName(), mp->m_host) ?  NETHOST : LOCALHOST;
+               mp->m_type = mh_strcasecmp(LocalName(), mp->m_host) ?  NETHOST : LOCALHOST;
 #else /* not DUMB */
        else
-               if (pp = OfficialName (mp->m_host)) {
+               if (pp = OfficialName(mp->m_host)) {
        got_real_host: ;
                        free (mp->m_host);
-                       mp->m_host = getcpy (pp);
-                       mp->m_type = mh_strcasecmp (LocalName(), mp->m_host) ? NETHOST : LOCALHOST;
+                       mp->m_host = getcpy(pp);
+                       mp->m_type = mh_strcasecmp(LocalName(), mp->m_host) ? NETHOST : LOCALHOST;
                } else {
                        if (dp = strchr(mp->m_host, '.')) {
                                *dp = NULL;
-                               if (pp = OfficialName (mp->m_host))
+                               if (pp = OfficialName(mp->m_host))
                                        goto got_real_host;
                                *dp = '.';
                        }
@@ -223,77 +223,77 @@ getm (char *str, char *dfhost, int dftype, int wanthost, char *eresult)
 
 got_host: ;
        if (route)
-               mp->m_path = getcpy (route);
+               mp->m_path = getcpy(route);
        mp->m_ingrp = ingrp;
        if (grp)
-               mp->m_gname = getcpy (grp);
+               mp->m_gname = getcpy(grp);
        if (note)
-               mp->m_note = getcpy (note);
+               mp->m_note = getcpy(note);
 
        return mp;
 }
 
 
 void
-mnfree (struct mailname *mp)
+mnfree(struct mailname *mp)
 {
        if (!mp)
                return;
 
        if (mp->m_text)
-               free (mp->m_text);
+               free(mp->m_text);
        if (mp->m_pers)
-               free (mp->m_pers);
+               free(mp->m_pers);
        if (mp->m_mbox)
-               free (mp->m_mbox);
+               free(mp->m_mbox);
        if (mp->m_host)
-               free (mp->m_host);
+               free(mp->m_host);
        if (mp->m_path)
-               free (mp->m_path);
+               free(mp->m_path);
        if (mp->m_gname)
-               free (mp->m_gname);
+               free(mp->m_gname);
        if (mp->m_note)
-               free (mp->m_note);
+               free(mp->m_note);
 
-       free ((char *) mp);
+       free((char *) mp);
 }
 
 
 #define empty(s) ((s) ? (s) : "")
 
 char *
-adrformat (struct mailname *mp)
+adrformat(struct mailname *mp)
 {
        static char addr[BUFSIZ];
        static char buffer[BUFSIZ];
 
 #ifdef DUMB
        if (mp->m_nohost)
-               strncpy (addr, mp->m_mbox ? mp->m_mbox : "", sizeof(addr));
+               strncpy(addr, mp->m_mbox ? mp->m_mbox : "", sizeof(addr));
        else
 #endif /* DUMB */
 
 #ifndef BANG
        if (mp->m_type != UUCPHOST)
-               snprintf (addr, sizeof(addr), mp->m_host ? "%s%s@%s" : "%s%s",
+               snprintf(addr, sizeof(addr), mp->m_host ? "%s%s@%s" : "%s%s",
                        empty(mp->m_path), empty(mp->m_mbox), mp->m_host);
        else
 #endif /* not BANG */
-               snprintf (addr, sizeof(addr), "%s!%s", mp->m_host, mp->m_mbox);
+               snprintf(addr, sizeof(addr), "%s!%s", mp->m_host, mp->m_mbox);
 
        if (mp->m_pers || mp->m_path) {
                if (mp->m_note)
-                       snprintf (buffer, sizeof(buffer), "%s %s <%s>",
-                               legal_person (mp->m_pers ? mp->m_pers : mp->m_mbox),
+                       snprintf(buffer, sizeof(buffer), "%s %s <%s>",
+                               legal_person(mp->m_pers ? mp->m_pers : mp->m_mbox),
                                mp->m_note, addr);
                else
-                       snprintf (buffer, sizeof(buffer), "%s <%s>",
-                               legal_person (mp->m_pers ? mp->m_pers : mp->m_mbox),
+                       snprintf(buffer, sizeof(buffer), "%s <%s>",
+                               legal_person(mp->m_pers ? mp->m_pers : mp->m_mbox),
                                addr);
        } else if (mp->m_note)
-               snprintf (buffer, sizeof(buffer), "%s %s", addr, mp->m_note);
+               snprintf(buffer, sizeof(buffer), "%s %s", addr, mp->m_note);
        else
-               strncpy (buffer, addr, sizeof(buffer));
+               strncpy(buffer, addr, sizeof(buffer));
 
        return buffer;
 }
@@ -313,7 +313,7 @@ adrformat (struct mailname *mp)
 */
 
 int
-ismymbox (struct mailname *np)
+ismymbox(struct mailname *np)
 {
        int oops;
        register int len, i;
@@ -330,15 +330,15 @@ ismymbox (struct mailname *np)
        */
        if (am == NULL) {
                mq.m_next = NULL;
-               mq.m_mbox = getusername ();
-               if ((am = context_find ("alternate-mailboxes")) == NULL)
+               mq.m_mbox = getusername();
+               if ((am = context_find("alternate-mailboxes")) == NULL)
                        am = getusername();
                else {
                        mp = &mq;
                        oops = 0;
-                       while ((cp = getname (am))) {
-                               if ((mp->m_next = getm (cp, NULL, 0, AD_NAME, NULL)) == NULL) {
-                                       admonish (NULL, "illegal address: %s", cp);
+                       while ((cp = getname(am))) {
+                               if ((mp->m_next = getm(cp, NULL, 0, AD_NAME, NULL)) == NULL) {
+                                       admonish(NULL, "illegal address: %s", cp);
                                        oops++;
                                } else {
                                        mp = mp->m_next;
@@ -347,7 +347,7 @@ ismymbox (struct mailname *np)
                                                mp->m_type |= W_MBEG;
                                                mp->m_mbox++;
                                        }
-                                       if (*(cp = mp->m_mbox + strlen (mp->m_mbox) - 1) == '*') {
+                                       if (*(cp = mp->m_mbox + strlen(mp->m_mbox) - 1) == '*') {
                                                mp->m_type |= W_MEND;
                                                *cp = '\0';
                                        }
@@ -356,19 +356,19 @@ ismymbox (struct mailname *np)
                                                        mp->m_type |= W_HBEG;
                                                        mp->m_host++;
                                                }
-                                               if (*(cp = mp->m_host + strlen (mp->m_host) - 1) == '*') {
+                                               if (*(cp = mp->m_host + strlen(mp->m_host) - 1) == '*') {
                                                        mp->m_type |= W_HEND;
                                                        *cp = '\0';
                                                }
                                        }
-                                       if ((cp = getenv ("MHWDEBUG")) && *cp)
-                                               fprintf (stderr, "mbox=\"%s\" host=\"%s\" %s\n",
+                                       if ((cp = getenv("MHWDEBUG")) && *cp)
+                                               fprintf(stderr, "mbox=\"%s\" host=\"%s\" %s\n",
                                                        mp->m_mbox, mp->m_host,
-                                                       snprintb (buffer, sizeof(buffer), (unsigned) mp->m_type, WBITS));
+                                                       snprintb(buffer, sizeof(buffer), (unsigned) mp->m_type, WBITS));
                                }
                        }
                        if (oops)
-                               advise (NULL, "please fix the %s: entry in your %s file",
+                               advise(NULL, "please fix the %s: entry in your %s file",
                                        "alternate-mailboxes", mh_profile);
                }
        }
@@ -378,17 +378,17 @@ ismymbox (struct mailname *np)
 
        switch (np->m_type) {
                case NETHOST:
-                       len = strlen (cp = LocalName ());
-                       if (!uprf (np->m_host, cp) || np->m_host[len] != '.')
+                       len = strlen(cp = LocalName());
+                       if (!uprf(np->m_host, cp) || np->m_host[len] != '.')
                                break;
                        goto local_test;
 
                case UUCPHOST:
-                       if (mh_strcasecmp (np->m_host, SystemName()))
+                       if (mh_strcasecmp(np->m_host, SystemName()))
                                break;  /* fall */
                case LOCALHOST:
 local_test: ;
-                       if (!mh_strcasecmp (np->m_mbox, mq.m_mbox))
+                       if (!mh_strcasecmp(np->m_mbox, mq.m_mbox))
                                return 1;
                        break;
 
@@ -404,24 +404,24 @@ local_test: ;
                mp = mp->m_next;
                if (!np->m_mbox)
                        continue;
-               if ((len = strlen (cp = np->m_mbox))
-                       < (i = strlen (pp = mp->m_mbox)))
+               if ((len = strlen(cp = np->m_mbox))
+                       < (i = strlen(pp = mp->m_mbox)))
                        continue;
                switch (mp->m_type & W_MBOX) {
                        case W_NIL:
-                               if (mh_strcasecmp (cp, pp))
+                               if (mh_strcasecmp(cp, pp))
                                        continue;
                                break;
                        case W_MBEG:
-                               if (mh_strcasecmp (cp + len - i, pp))
+                               if (mh_strcasecmp(cp + len - i, pp))
                                        continue;
                                break;
                        case W_MEND:
-                               if (!uprf (cp, pp))
+                               if (!uprf(cp, pp))
                                        continue;
                                break;
                        case W_MBEG | W_MEND:
-                               if (stringdex (pp, cp) < 0)
+                               if (stringdex(pp, cp) < 0)
                                        continue;
                                break;
                }
@@ -430,12 +430,12 @@ local_test: ;
                        return 1;
                if (np->m_host == NULL)
                        continue;
-               if ((len = strlen (cp = np->m_host))
-                       < (i = strlen (pp = mp->m_host)))
+               if ((len = strlen(cp = np->m_host))
+                       < (i = strlen(pp = mp->m_host)))
                        continue;
                switch (mp->m_type & W_HOST) {
                        case W_NIL:
-                               if (mh_strcasecmp (cp, pp))
+                               if (mh_strcasecmp(cp, pp))
                                        continue;
                                break;
                        case W_HBEG:
@@ -443,11 +443,11 @@ local_test: ;
                                        continue;
                                break;
                        case W_HEND:
-                               if (!uprf (cp, pp))
+                               if (!uprf(cp, pp))
                                        continue;
                                break;
                        case W_HBEG | W_HEND:
-                               if (stringdex (pp, cp) < 0)
+                               if (stringdex(pp, cp) < 0)
                                        continue;
                                break;
                }
@@ -474,7 +474,7 @@ local_test: ;
 
 
 char *
-OfficialName (char *name)
+OfficialName(char *name)
 {
        unsigned char *p;
        char *q, site[BUFSIZ];
@@ -483,11 +483,11 @@ OfficialName (char *name)
        static char buffer[BUFSIZ];
 
        for (p = name, q = site; *p && (q - site < sizeof(site) - 1); p++, q++)
-               *q = isupper (*p) ? tolower (*p) : *p;
+               *q = isupper(*p) ? tolower(*p) : *p;
        *q = '\0';
        q = site;
 
-       if (!mh_strcasecmp (LocalName(), site))
+       if (!mh_strcasecmp(LocalName(), site))
                return LocalName();
 
        memset(&hints, 0, sizeof(hints));
@@ -495,12 +495,12 @@ OfficialName (char *name)
        hints.ai_family = PF_UNSPEC;
 
        if (getaddrinfo(q, NULL, &hints, &res) == 0) {
-               strncpy (buffer, res->ai_canonname, sizeof(buffer));
+               strncpy(buffer, res->ai_canonname, sizeof(buffer));
                buffer[sizeof(buffer) - 1] = '\0';
                freeaddrinfo(res);
                return buffer;
        }
 
-       strncpy (buffer, site, sizeof(buffer));
+       strncpy(buffer, site, sizeof(buffer));
        return buffer;
 }
index 6105a50..f2126b7 100644 (file)
@@ -10,8 +10,8 @@
 
 
 void
-ambigsw (char *arg, struct swit *swp)
+ambigsw(char *arg, struct swit *swp)
 {
-       advise (NULL, "-%s ambiguous.  It matches", arg);
-       print_sw (arg, swp, "-", stderr);
+       advise(NULL, "-%s ambiguous.  It matches", arg);
+       print_sw(arg, swp, "-", stderr);
 }
index 4496ae6..4e71ab5 100644 (file)
@@ -19,11 +19,11 @@ static int len = 0;             /* current size of "broken"           */
 /*
 ** static prototypes
 */
-static int brkany (char, char *);
+static int brkany(char, char *);
 
 
 char **
-brkstring (char *str, char *brksep, char *brkterm)
+brkstring(char *str, char *brksep, char *brkterm)
 {
        int i;
        char c, *s;
@@ -31,7 +31,7 @@ brkstring (char *str, char *brksep, char *brkterm)
        /* allocate initial space for pointers on first call */
        if (!broken) {
                len = NUMBROKEN;
-               broken = (char **) mh_xmalloc ((size_t) (len * sizeof(*broken)));
+               broken = (char **) mh_xmalloc((size_t) (len * sizeof(*broken)));
        }
 
        /*
@@ -45,17 +45,17 @@ brkstring (char *str, char *brksep, char *brkterm)
        /* enlarge pointer array, if necessary */
        if (i >= len) {
                len += NUMBROKEN;
-               broken = mh_xrealloc (broken, (size_t) (len * sizeof(*broken)));
+               broken = mh_xrealloc(broken, (size_t) (len * sizeof(*broken)));
        }
 
-       while (brkany (c = *s, brksep))
+       while (brkany(c = *s, brksep))
                *s++ = '\0';
 
        /*
        ** we are either at the end of the string, or the
        ** terminator found has been found, so finish up.
        */
-       if (!c || brkany (c, brkterm)) {
+       if (!c || brkany(c, brkterm)) {
                *s = '\0';
                broken[i] = NULL;
                return broken;
@@ -64,7 +64,7 @@ brkstring (char *str, char *brksep, char *brkterm)
        /* set next start addr */
        broken[i] = s;
 
-       while ((c = *++s) && !brkany (c, brksep) && !brkany (c, brkterm))
+       while ((c = *++s) && !brkany(c, brksep) && !brkany(c, brkterm))
                ;    /* empty body */
        }
 
@@ -78,7 +78,7 @@ brkstring (char *str, char *brksep, char *brkterm)
 */
 
 static int
-brkany (char c, char *str)
+brkany(char c, char *str)
 {
        char *s;
 
index cba270d..d11d772 100644 (file)
 ** Get the current character set
 */
 char *
-get_charset ()
+get_charset()
 {
-       char *charset = getenv ("MM_CHARSET");
+       char *charset = getenv("MM_CHARSET");
 #if defined(HAVE_NL_LANGINFO) && defined(CODESET)
        if (!charset)
-               charset = norm_charmap(nl_langinfo (CODESET));
+               charset = norm_charmap(nl_langinfo(CODESET));
 #endif
        return charset;
 }
@@ -35,7 +35,7 @@ get_charset ()
 */
 
 int
-check_charset (char *str, int len)
+check_charset(char *str, int len)
 {
        static char *mm_charset = NULL;
        static char *alt_charset = NULL;
@@ -44,15 +44,15 @@ check_charset (char *str, int len)
 
        /* Cache the name of our default character set */
        if (!mm_charset) {
-               if (!(mm_charset = get_charset ()))
+               if (!(mm_charset = get_charset()))
                        mm_charset = "US-ASCII";
-               mm_len = strlen (mm_charset);
+               mm_len = strlen(mm_charset);
 
                /* US-ASCII is a subset of the ISO-8859-X and UTF-8 character sets */
                if (!strncasecmp("ISO-8859-", mm_charset, 9) ||
                        !mh_strcasecmp("UTF-8", mm_charset)) {
                        alt_charset = "US-ASCII";
-                       alt_len = strlen (alt_charset);
+                       alt_len = strlen(alt_charset);
                }
        }
 
@@ -71,7 +71,7 @@ check_charset (char *str, int len)
 ** using for 8bit text.
 */
 char *
-write_charset_8bit (void)
+write_charset_8bit(void)
 {
        static char *mm_charset = NULL;
 
@@ -79,7 +79,7 @@ write_charset_8bit (void)
        ** Cache the name of the character set to
        ** use for 8bit text.
        */
-       if (!mm_charset && !(mm_charset = get_charset ()))
+       if (!mm_charset && !(mm_charset = get_charset()))
                mm_charset = "x-unknown";
 
        return mm_charset;
index 0f87bde..8a4da49 100644 (file)
@@ -15,5 +15,5 @@ closefds(int i)
        int nbits = OPEN_MAX;
 
        for (; i < nbits; i++)
-               close (i);
+               close(i);
 }
index 65ded77..4c3fcff 100644 (file)
 
 
 char *
-concat (char *s1, ...)
+concat(char *s1, ...)
 {
        char *cp, *dp, *sp;
        size_t len;
        va_list list;
 
-       len = strlen (s1) + 1;
+       len = strlen(s1) + 1;
        va_start(list, s1);
        while ((cp = va_arg(list, char *)))
-               len += strlen (cp);
+               len += strlen(cp);
        va_end(list);
 
        dp = sp = mh_xmalloc(len);
@@ -29,7 +29,7 @@ concat (char *s1, ...)
        sp = copy(s1, sp);
 
        va_start(list, s1);
-       while ((cp = va_arg (list, char *)))
+       while ((cp = va_arg(list, char *)))
                sp = copy(cp, sp);
        va_end(list);
 
index 1341424..6eebd7e 100644 (file)
 */
 
 int
-context_del (char *key)
+context_del(char *key)
 {
        register struct node *np, *pp;
 
        for (np = m_defs, pp = NULL; np; pp = np, np = np->n_next) {
-               if (!mh_strcasecmp (np->n_name, key)) {
+               if (!mh_strcasecmp(np->n_name, key)) {
                        if (!np->n_context)
-                               admonish (NULL, "bug: context_del(key=\"%s\")", np->n_name);
+                               admonish(NULL, "bug: context_del(key=\"%s\")", np->n_name);
                        if (pp)
                                pp->n_next = np->n_next;
                        else
                                m_defs = np->n_next;
-                       free (np->n_name);
+                       free(np->n_name);
                        if (np->n_field)
-                               free (np->n_field);
-                       free ((char *) np);
+                               free(np->n_field);
+                       free((char *) np);
                        ctxflags |= CTXMOD;
                        return 0;
                }
index e5ba5ff..64ed8e0 100644 (file)
 
 
 char *
-context_find (char *str)
+context_find(char *str)
 {
        struct node *np;
 
        for (np = m_defs; np; np = np->n_next)
-               if (!mh_strcasecmp (np->n_name, str))
+               if (!mh_strcasecmp(np->n_name, str))
                        return (np->n_field);
 
        return NULL;
index 93b198d..e7d7da8 100644 (file)
@@ -15,7 +15,7 @@
 */
 
 int
-context_foil (char *path)
+context_foil(char *path)
 {
        register struct node *np;
 
@@ -43,23 +43,23 @@ context_foil (char *path)
        ** If path is given, create a minimal profile/context list
        */
        if (path) {
-               m_defs = (struct node *) mh_xmalloc (sizeof(*np));
+               m_defs = (struct node *) mh_xmalloc(sizeof(*np));
 
                np = m_defs;
-               if (!(np->n_name = strdup ("Path"))) {
-                       advise (NULL, "strdup failed");
+               if (!(np->n_name = strdup("Path"))) {
+                       advise(NULL, "strdup failed");
                        return -1;
                }
-               if (!(np->n_field = strdup (path))) {
-                       advise (NULL, "strdup failed");
+               if (!(np->n_field = strdup(path))) {
+                       advise(NULL, "strdup failed");
                        return -1;
                }
                np->n_context = 0;
                np->n_next = NULL;
 
-               if (mypath == NULL && (mypath = getenv ("HOME")) != NULL)
-                       if (!(mypath = strdup (mypath))) {
-                               advise (NULL, "strdup failed");
+               if (mypath == NULL && (mypath = getenv("HOME")) != NULL)
+                       if (!(mypath = strdup(mypath))) {
+                               advise(NULL, "strdup failed");
                                return -1;
                        }
        }
index 1e1a84e..ea7d5da 100644 (file)
@@ -27,7 +27,7 @@
 #include <pwd.h>     /* structure for getpwuid() results */
 
 void
-context_read (void)
+context_read(void)
 {
        char buf[BUFSIZ];            /* path name buffer                 */
        char *cp;                    /* miscellaneous pointer            */
@@ -79,8 +79,8 @@ context_read (void)
                cp = mh_profile;
        }
 
-       readconfig (&m_defs, ib, cp, 0);
-       fclose (ib);
+       readconfig(&m_defs, ib, cp, 0);
+       fclose(ib);
 
        /*
        ** Find the user's nmh directory, which is specified by the "path"
@@ -88,28 +88,28 @@ context_read (void)
        ** one rooted in the home directory.
        */
 
-       if ((cp = context_find ("path")) == (char *)0)
+       if ((cp = context_find("path")) == (char *)0)
                adios(NULL, "Your %s file does not contain a path entry.", defpath);
 
        if (*cp == '\0')
                adios(NULL, "Your `%s' profile file does not contain a valid path entry.", defpath);
 
        if (*cp != '/')
-               (void)snprintf (nd = buf, sizeof(buf), "%s/%s", mypath, cp);
+               (void)snprintf(nd = buf, sizeof(buf), "%s/%s", mypath, cp);
        else
                nd = cp;
 
        if (stat(nd, &st) == -1) {
                if (errno != ENOENT)
-                       adios (nd, "error opening");
-               cp = concat ("Your MH-directory \"", nd, "\" doesn't exist; Create it? ", NULL);
+                       adios(nd, "error opening");
+               cp = concat("Your MH-directory \"", nd, "\" doesn't exist; Create it? ", NULL);
                if (!getanswer(cp))
-                       adios (NULL, "unable to access MH-directory \"%s\"", nd);
-               free (cp);
-               if (!makedir (nd))
-                       adios (NULL, "unable to create %s", nd);
+                       adios(NULL, "unable to access MH-directory \"%s\"", nd);
+               free(cp);
+               if (!makedir(nd))
+                       adios(NULL, "unable to create %s", nd);
        } else if ((st.st_mode & S_IFDIR) == 0)
-               adios ((char *)0, "`%s' is not a directory", nd);
+               adios((char *)0, "`%s' is not a directory", nd);
 
        /*
        ** Open and read user's context file.  The name of the context
@@ -117,7 +117,7 @@ context_read (void)
        ** environment variable.
        */
 
-       if ((cp = getenv ("MHCONTEXT")) == (char *)0 || *cp == '\0')
+       if ((cp = getenv("MHCONTEXT")) == (char *)0 || *cp == '\0')
                cp = context;
 
        /*
@@ -131,11 +131,11 @@ context_read (void)
                return;
        }
 
-       ctxpath = getcpy (m_maildir (cp));
+       ctxpath = getcpy(m_maildir(cp));
 
-       if ((ib = lkfopen (ctxpath, "r"))) {
-               readconfig ((struct node **) 0, ib, cp, 1);
-               lkfclose (ib, ctxpath);
+       if ((ib = lkfopen(ctxpath, "r"))) {
+               readconfig((struct node **) 0, ib, cp, 1);
+               lkfclose(ib, ctxpath);
        }
 
        return;
index bb49a90..6b3aa2f 100644 (file)
@@ -11,7 +11,7 @@
 
 
 void
-context_replace (char *key, char *value)
+context_replace(char *key, char *value)
 {
        register struct node *np;
 
@@ -19,11 +19,11 @@ context_replace (char *key, char *value)
        ** If list is emtpy, allocate head of profile/context list.
        */
        if (!m_defs) {
-               m_defs = (struct node *) mh_xmalloc (sizeof(*np));
+               m_defs = (struct node *) mh_xmalloc(sizeof(*np));
 
                np = m_defs;
-               np->n_name = getcpy (key);
-               np->n_field = getcpy (value);
+               np->n_name = getcpy(key);
+               np->n_field = getcpy(value);
                np->n_context = 1;
                np->n_next = NULL;
                ctxflags |= CTXMOD;
@@ -35,13 +35,13 @@ context_replace (char *key, char *value)
        ** this key, and replace its value if found.
        */
        for (np = m_defs;; np = np->n_next) {
-               if (!mh_strcasecmp (np->n_name, key)) {
-                       if (strcmp (value, np->n_field)) {
+               if (!mh_strcasecmp(np->n_name, key)) {
+                       if (strcmp(value, np->n_field)) {
                                if (!np->n_context)
-                                       admonish (NULL, "bug: context_replace(key=\"%s\",value=\"%s\")", key, value);
+                                       admonish(NULL, "bug: context_replace(key=\"%s\",value=\"%s\")", key, value);
                                if (np->n_field)
-                                       free (np->n_field);
-                               np->n_field = getcpy (value);
+                                       free(np->n_field);
+                               np->n_field = getcpy(value);
                                ctxflags |= CTXMOD;
                        }
                        return;
@@ -53,11 +53,11 @@ context_replace (char *key, char *value)
        /*
        ** Else add this new entry at the end
        */
-       np->n_next = (struct node *) mh_xmalloc (sizeof(*np));
+       np->n_next = (struct node *) mh_xmalloc(sizeof(*np));
 
        np = np->n_next;
-       np->n_name = getcpy (key);
-       np->n_field = getcpy (value);
+       np->n_name = getcpy(key);
+       np->n_field = getcpy(value);
        np->n_context = 1;
        np->n_next = NULL;
        ctxflags |= CTXMOD;
index 7d99cc3..e62aca8 100644 (file)
@@ -16,7 +16,7 @@ static int m_chkids(void);
 
 
 void
-context_save (void)
+context_save(void)
 {
        int action;
        register struct node *np;
@@ -31,28 +31,28 @@ context_save (void)
                return;
        ctxflags &= ~CTXMOD;
 
-       if ((action = m_chkids ()) > 0)
+       if ((action = m_chkids()) > 0)
                return;  /* child did it for us */
 
        /* block a few signals */
-       sigemptyset (&set);
-       sigaddset (&set, SIGHUP);
-       sigaddset (&set, SIGINT);
-       sigaddset (&set, SIGQUIT);
-       sigaddset (&set, SIGTERM);
-       SIGPROCMASK (SIG_BLOCK, &set, &oset);
-
-       if (!(out = lkfopen (ctxpath, "w")))
-               adios (ctxpath, "unable to write");
+       sigemptyset(&set);
+       sigaddset(&set, SIGHUP);
+       sigaddset(&set, SIGINT);
+       sigaddset(&set, SIGQUIT);
+       sigaddset(&set, SIGTERM);
+       SIGPROCMASK(SIG_BLOCK, &set, &oset);
+
+       if (!(out = lkfopen(ctxpath, "w")))
+               adios(ctxpath, "unable to write");
        for (np = m_defs; np; np = np->n_next)
                if (np->n_context)
-                       fprintf (out, "%s: %s\n", np->n_name, np->n_field);
-       lkfclose (out, ctxpath);
+                       fprintf(out, "%s: %s\n", np->n_name, np->n_field);
+       lkfclose(out, ctxpath);
 
-       SIGPROCMASK (SIG_SETMASK, &oset, &set); /* reset the signal mask */
+       SIGPROCMASK(SIG_SETMASK, &oset, &set); /* reset the signal mask */
 
        if (action == 0)
-               _exit (0);    /* we are child, time to die */
+               _exit(0);    /* we are child, time to die */
 }
 
 /*
@@ -66,28 +66,28 @@ context_save (void)
 */
 
 static int
-m_chkids (void)
+m_chkids(void)
 {
        int i;
        pid_t pid;
 
-       if (getuid () == geteuid ())
+       if (getuid() == geteuid())
                return (-1);
 
-       for (i = 0; (pid = fork ()) == -1 && i < 5; i++)
-               sleep (5);
+       for (i = 0; (pid = fork()) == -1 && i < 5; i++)
+               sleep(5);
 
        switch (pid) {
                case -1:
                        break;
 
                case 0:
-                       setgid (getgid ());
-                       setuid (getuid ());
+                       setgid(getgid());
+                       setuid(getuid());
                        break;
 
                default:
-                       pidwait (pid, -1);
+                       pidwait(pid, -1);
                        break;
        }
 
index e4253da..e5ded82 100644 (file)
@@ -10,7 +10,7 @@
 
 
 char **
-copyip (char **p, char **q, int len_q)
+copyip(char **p, char **q, int len_q)
 {
        while (*p && --len_q > 0)
                *q++ = *p++;
index 207bc03..048579e 100644 (file)
@@ -9,7 +9,7 @@
 #include <h/mh.h>
 
 void
-cpydata (int in, int out, char *ifile, char *ofile)
+cpydata(int in, int out, char *ifile, char *ofile)
 {
        int i;
        char buffer[BUFSIZ];
index 04ca76e..86211cf 100644 (file)
 #define S2 1
 
 #define output(c)  if (bp >= dp) {flush(); *bp++ = c;} else *bp++ = c
-#define flush()  if ((j = bp - outbuf) && write (out, outbuf, j) != j) \
-               adios (ofile, "error writing"); \
+#define flush()  if ((j = bp - outbuf) && write(out, outbuf, j) != j) \
+               adios(ofile, "error writing"); \
        else \
                bp = outbuf
 
 
 void
-cpydgst (int in, int out, char *ifile, char *ofile)
+cpydgst(int in, int out, char *ifile, char *ofile)
 {
        register int i, j, state;
        register char *cp, *ep;
@@ -40,20 +40,20 @@ cpydgst (int in, int out, char *ifile, char *ofile)
        char buffer[BUFSIZ], outbuf[BUFSIZ];
 
        dp = (bp = outbuf) + sizeof outbuf;
-       for (state = S1; (i = read (in, buffer, sizeof buffer)) > 0;)
+       for (state = S1; (i = read(in, buffer, sizeof buffer)) > 0;)
                for (ep = (cp = buffer) + i; cp < ep; cp++) {
                        if (*cp == '\0')
                                continue;
                        switch (state) {
                                case S1:
                                        if (*cp == '-') {
-                                               output ('-');
-                                               output (' ');
+                                               output('-');
+                                               output(' ');
                                        }
                                        state = S2;  /* fall */
 
                                case S2:
-                                       output (*cp);
+                                       output(*cp);
                                        if (*cp == '\n')
                                                state = S1;
                                        break;
@@ -61,6 +61,6 @@ cpydgst (int in, int out, char *ifile, char *ofile)
                }
 
        if (i == -1)
-               adios (ifile, "error reading");
+               adios(ifile, "error reading");
        flush();
 }
index 2691a78..0693a21 100644 (file)
@@ -27,19 +27,19 @@ struct crawl_context {
 */
 
 static void
-add_folder (char *fold, struct crawl_context *crawl)
+add_folder(char *fold, struct crawl_context *crawl)
 {
        register int i, j;
 
        /* if necessary, reallocate the space for folder names */
        if (crawl->foldp >= crawl->max) {
                crawl->max += CRAWL_NUMFOLDERS;
-               crawl->folders = mh_xrealloc (crawl->folders,
+               crawl->folders = mh_xrealloc(crawl->folders,
                        crawl->max * sizeof(char *));
        }
 
        for (i = crawl->start; i < crawl->foldp; i++)
-               if (strcmp (fold, crawl->folders[i]) < 0) {
+               if (strcmp(fold, crawl->folders[i]) < 0) {
                        for (j = crawl->foldp - 1; j >= i; j--)
                                crawl->folders[j + 1] = crawl->folders[j];
                        crawl->foldp++;
@@ -52,7 +52,7 @@ add_folder (char *fold, struct crawl_context *crawl)
 }
 
 static void
-add_children (char *name, struct crawl_context *crawl)
+add_children(char *name, struct crawl_context *crawl)
 {
        char *prefix, *child;
        struct stat st;
@@ -60,18 +60,18 @@ add_children (char *name, struct crawl_context *crawl)
        DIR * dd;
        int child_is_folder;
 
-       if (!(dd = opendir (name))) {
-               admonish (name, "unable to read directory ");
+       if (!(dd = opendir(name))) {
+               admonish(name, "unable to read directory ");
                return;
        }
 
-       if (strcmp (name, ".") == 0) {
-               prefix = getcpy ("");
+       if (strcmp(name, ".") == 0) {
+               prefix = getcpy("");
        } else {
-               prefix = concat (name, "/", (void *)NULL);
+               prefix = concat(name, "/", (void *)NULL);
        }
 
-       while ((dp = readdir (dd))) {
+       while ((dp = readdir(dd))) {
                /*
                ** If the system supports it, try to skip processing of
                ** children we know are not directories or symlinks.
@@ -84,31 +84,31 @@ add_children (char *name, struct crawl_context *crawl)
                        continue;
                }
 #endif
-               if (!strcmp (dp->d_name, ".") || !strcmp (dp->d_name, "..")) {
+               if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) {
                        continue;
                }
-               child = concat (prefix, dp->d_name, (void *)NULL);
+               child = concat(prefix, dp->d_name, (void *)NULL);
                /*
                ** If we have no d_type or d_type is DT_LNK or DT_UNKNOWN,
                ** stat the child to see what it is.
                */
                if (child_is_folder == -1) {
-                       child_is_folder = (stat (child, &st) != -1 && S_ISDIR(st.st_mode));
+                       child_is_folder = (stat(child, &st) != -1 && S_ISDIR(st.st_mode));
                }
                if (child_is_folder) {
                        /* add_folder saves child in the list, don't free it */
-                       add_folder (child, crawl);
+                       add_folder(child, crawl);
                } else {
-                       free (child);
+                       free(child);
                }
        }
 
-       closedir (dd);
+       closedir(dd);
        free(prefix);
 }
 
 static void
-crawl_folders_body (struct crawl_context *crawl, char *dir,
+crawl_folders_body(struct crawl_context *crawl, char *dir,
        crawl_callback_t *callback, void *baton)
 {
        int i;
@@ -117,18 +117,18 @@ crawl_folders_body (struct crawl_context *crawl, char *dir,
 
        crawl->start = crawl->foldp;
 
-       add_children (dir, crawl);
+       add_children(dir, crawl);
 
        for (i = crawl->start; i < crawl->foldp; i++) {
                char *fold = crawl->folders[i];
                int crawl_children = 1;
 
                if (callback != NULL) {
-                       crawl_children = callback (fold, baton);
+                       crawl_children = callback(fold, baton);
                }
 
                if (crawl_children) {
-                       crawl_folders_body (crawl, fold, callback, baton);
+                       crawl_folders_body(crawl, fold, callback, baton);
                }
        }
 
@@ -137,19 +137,19 @@ crawl_folders_body (struct crawl_context *crawl, char *dir,
 }
 
 void
-crawl_folders (char *dir, crawl_callback_t *callback, void *baton)
+crawl_folders(char *dir, crawl_callback_t *callback, void *baton)
 {
-       struct crawl_context *crawl = mh_xmalloc (sizeof(*crawl));
+       struct crawl_context *crawl = mh_xmalloc(sizeof(*crawl));
        crawl->max = CRAWL_NUMFOLDERS;
        crawl->total = crawl->start = crawl->foldp = 0;
-       crawl->folders = mh_xmalloc (crawl->max * sizeof(*crawl->folders));
+       crawl->folders = mh_xmalloc(crawl->max * sizeof(*crawl->folders));
 
-       crawl_folders_body (crawl, dir, callback, baton);
+       crawl_folders_body(crawl, dir, callback, baton);
 
        /*
        ** Note that we "leak" the folder names, on the assumption that the
        ** caller is using them.
        */
-       free (crawl->folders);
-       free (crawl);
+       free(crawl->folders);
+       free(crawl);
 }
index eb7e7c8..03eaa10 100644 (file)
@@ -27,7 +27,7 @@
 
 
 void
-discard (FILE *io)
+discard(FILE *io)
 {
 #ifndef HAVE_TERMIOS_H
 # ifdef HAVE_TERMIO_H
@@ -41,19 +41,19 @@ discard (FILE *io)
                return;
 
 #ifdef HAVE_TERMIOS_H
-       tcflush (fileno(io), TCOFLUSH);
+       tcflush(fileno(io), TCOFLUSH);
 #else
 # ifdef HAVE_TERMIO_H
-       if (ioctl (fileno(io), TCGETA, &tio) != -1)
-               ioctl (fileno(io), TCSETA, &tio);
+       if (ioctl(fileno(io), TCGETA, &tio) != -1)
+               ioctl(fileno(io), TCSETA, &tio);
 # else
-       if (ioctl (fileno(io), TIOCGETP, (char *) &tio) != -1)
-               ioctl (fileno(io), TIOCSETP, (char *) &tio);
+       if (ioctl(fileno(io), TIOCGETP, (char *) &tio) != -1)
+               ioctl(fileno(io), TIOCSETP, (char *) &tio);
 # endif
 #endif
 
 #if defined(_FSTDIO) || defined(__DragonFly__)
-       fpurge (io);
+       fpurge(io);
 #else
 # ifdef LINUX_STDIO
        io->_IO_write_ptr = io->_IO_write_base;
index 60ab9d7..737f998 100644 (file)
@@ -118,12 +118,12 @@ static int dmsize[] = {
 */
 
 struct tws *
-dlocaltimenow (void)
+dlocaltimenow(void)
 {
        time_t clock;
 
-       time (&clock);
-       return dlocaltime (&clock);
+       time(&clock);
+       return dlocaltime(&clock);
 }
 
 
@@ -134,7 +134,7 @@ dlocaltimenow (void)
 */
 
 struct tws *
-dlocaltime (time_t *clock)
+dlocaltime(time_t *clock)
 {
        static struct tws tw;
        struct tm *tm;
@@ -146,7 +146,7 @@ dlocaltime (time_t *clock)
        if (!clock)
                return NULL;
 
-       tm = localtime (clock);
+       tm = localtime(clock);
 
        tw.tw_sec  = tm->tm_sec;
        tw.tw_min  = tm->tm_min;
@@ -175,7 +175,7 @@ dlocaltime (time_t *clock)
        tzset();
        tw.tw_zone = -(timezone / 60);
 # else
-       ftime (&tb);
+       ftime(&tb);
        tw.tw_zone = -tb.timezone;
 # endif
 #endif
@@ -198,7 +198,7 @@ dlocaltime (time_t *clock)
 */
 
 struct tws *
-dgmtime (time_t *clock)
+dgmtime(time_t *clock)
 {
        static struct tws tw;
        struct tm *tm;
@@ -206,7 +206,7 @@ dgmtime (time_t *clock)
        if (!clock)
                return NULL;
 
-       tm = gmtime (clock);
+       tm = gmtime(clock);
 
        tw.tw_sec  = tm->tm_sec;
        tw.tw_min  = tm->tm_min;
@@ -247,14 +247,14 @@ dgmtime (time_t *clock)
 */
 
 char *
-dctime (struct tws *tw)
+dctime(struct tws *tw)
 {
        static char buffer[26];
 
        if (!tw)
                return NULL;
 
-       snprintf (buffer, sizeof(buffer), "%.3s %.3s %02d %02d:%02d:%02d %.4d\n",
+       snprintf(buffer, sizeof(buffer), "%.3s %.3s %02d %02d:%02d:%02d %.4d\n",
                tw_dotw[tw->tw_wday], tw_moty[tw->tw_mon], tw->tw_mday,
                tw->tw_hour, tw->tw_min, tw->tw_sec,
                tw->tw_year < 100 ? tw->tw_year + 1900 : tw->tw_year);
@@ -274,12 +274,12 @@ dctime (struct tws *tw)
 */
 
 char *
-dtimenow (int alpha_timezone)
+dtimenow(int alpha_timezone)
 {
        time_t clock;
 
-       time (&clock);
-       return dtime (&clock, alpha_timezone);
+       time(&clock);
+       return dtime(&clock, alpha_timezone);
 }
 
 
@@ -295,14 +295,14 @@ dtimenow (int alpha_timezone)
 */
 
 char *
-dtime (time_t *clock, int alpha_timezone)
+dtime(time_t *clock, int alpha_timezone)
 {
        if (alpha_timezone)
                /* use alpha-numeric timezones */
-               return dasctime (dlocaltime (clock), TW_NULL);
+               return dasctime(dlocaltime(clock), TW_NULL);
        else
                /* use numeric timezones */
-               return dasctime (dlocaltime (clock), TW_ZONE);
+               return dasctime(dlocaltime(clock), TW_ZONE);
 }
 
 
@@ -316,7 +316,7 @@ dtime (time_t *clock, int alpha_timezone)
 */
 
 char *
-dasctime (struct tws *tw, int flags)
+dasctime(struct tws *tw, int flags)
 {
        char buffer[80];
        static char result[80];
@@ -336,12 +336,12 @@ dasctime (struct tws *tw, int flags)
                tw->tw_hour, tw->tw_min, tw->tw_sec, result);
 
        if ((tw->tw_flags & TW_SDAY) == TW_SEXP)
-               snprintf (result, sizeof(result), "%s, %s", tw_dotw[tw->tw_wday], buffer);
+               snprintf(result, sizeof(result), "%s, %s", tw_dotw[tw->tw_wday], buffer);
        else
                if ((tw->tw_flags & TW_SDAY) == TW_SNIL)
-                       strncpy (result, buffer, sizeof(result));
+                       strncpy(result, buffer, sizeof(result));
                else
-                       snprintf (result, sizeof(result), "%s (%s)", buffer, tw_dotw[tw->tw_wday]);
+                       snprintf(result, sizeof(result), "%s (%s)", buffer, tw_dotw[tw->tw_wday]);
 
        return result;
 }
@@ -352,7 +352,7 @@ dasctime (struct tws *tw, int flags)
 */
 
 char *
-dtimezone (int offset, int flags)
+dtimezone(int offset, int flags)
 {
        int hours, mins;
        struct zone *z;
@@ -381,8 +381,8 @@ dtimezone (int offset, int flags)
        if (flags & TW_DST)
                hours += 1;
 #endif /* ADJUST_NUMERIC_ONLY_TZ_OFFSETS_WRT_DST */
-       snprintf (buffer, sizeof(buffer), "%s%02d%02d",
-               offset < 0 ? "-" : "+", abs (hours), abs (mins));
+       snprintf(buffer, sizeof(buffer), "%s%02d%02d",
+               offset < 0 ? "-" : "+", abs(hours), abs(mins));
        return buffer;
 }
 
@@ -395,7 +395,7 @@ dtimezone (int offset, int flags)
 */
 
 time_t
-dmktime (struct tws *tw)
+dmktime(struct tws *tw)
 {
        int i, sec, min, hour, mday, mon, year;
        time_t result;
@@ -420,8 +420,8 @@ dmktime (struct tws *tw)
                year += 100;
 
        for (i = 1970; i < year; i++)
-               result += dysize (i);
-       if (dysize (year) == 366 && mon >= 3)
+               result += dysize(i);
+       if (dysize(year) == 366 && mon >= 3)
                result++;
        while (--mon)
                result += dmsize[mon - 1];
@@ -444,7 +444,7 @@ dmktime (struct tws *tw)
 */
 
 void
-set_dotw (struct tws *tw)
+set_dotw(struct tws *tw)
 {
        int month, day, year, century;
 
@@ -475,7 +475,7 @@ set_dotw (struct tws *tw)
 */
 
 void
-twscopy (struct tws *tb, struct tws *tw)
+twscopy(struct tws *tb, struct tws *tw)
 {
        *tb = *tw;  /* struct copy */
 
@@ -500,14 +500,14 @@ twscopy (struct tws *tb, struct tws *tw)
 */
 
 int
-twsort (struct tws *tw1, struct tws *tw2)
+twsort(struct tws *tw1, struct tws *tw2)
 {
        time_t c1, c2;
 
        if (tw1->tw_clock == 0)
-               dmktime (tw1);
+               dmktime(tw1);
        if (tw2->tw_clock == 0)
-               dmktime (tw2);
+               dmktime(tw2);
 
        return ((c1 = tw1->tw_clock) > (c2 = tw2->tw_clock) ? 1
                : c1 == c2 ? 0 : -1);
index 42511c9..7db8d18 100644 (file)
 ** print out error message
 */
 void
-advise (char *what, char *fmt, ...)
+advise(char *what, char *fmt, ...)
 {
        va_list ap;
 
        va_start(ap, fmt);
-       advertise (what, NULL, fmt, ap);
+       advertise(what, NULL, fmt, ap);
        va_end(ap);
 }
 
@@ -34,14 +34,14 @@ advise (char *what, char *fmt, ...)
 ** print out error message and exit
 */
 void
-adios (char *what, char *fmt, ...)
+adios(char *what, char *fmt, ...)
 {
        va_list ap;
 
        va_start(ap, fmt);
-       advertise (what, NULL, fmt, ap);
+       advertise(what, NULL, fmt, ap);
        va_end(ap);
-       done (1);
+       done(1);
 }
 
 
@@ -49,12 +49,12 @@ adios (char *what, char *fmt, ...)
 ** admonish the user
 */
 void
-admonish (char *what, char *fmt, ...)
+admonish(char *what, char *fmt, ...)
 {
        va_list ap;
 
        va_start(ap, fmt);
-       advertise (what, "continuing...", fmt, ap);
+       advertise(what, "continuing...", fmt, ap);
        va_end(ap);
 }
 
@@ -68,7 +68,7 @@ admonish (char *what, char *fmt, ...)
 ** sexy syscall()...
 */
 void
-advertise (char *what, char *tail, char *fmt, va_list ap)
+advertise(char *what, char *tail, char *fmt, va_list ap)
 {
        int  eindex = errno;
 
@@ -77,65 +77,65 @@ advertise (char *what, char *tail, char *fmt, va_list ap)
        struct iovec iob[20], *iov;
 #endif
 
-       fflush (stdout);
+       fflush(stdout);
 
 #ifdef HAVE_WRITEV
-       fflush (stderr);
+       fflush(stderr);
        iov = iob;
 
        if (invo_name && *invo_name) {
-               iov->iov_len = strlen (iov->iov_base = invo_name);
+               iov->iov_len = strlen(iov->iov_base = invo_name);
                iov++;
-               iov->iov_len = strlen (iov->iov_base = ": ");
+               iov->iov_len = strlen(iov->iov_base = ": ");
                iov++;
        }
 
-       vsnprintf (buffer, sizeof(buffer), fmt, ap);
-       iov->iov_len = strlen (iov->iov_base = buffer);
+       vsnprintf(buffer, sizeof(buffer), fmt, ap);
+       iov->iov_len = strlen(iov->iov_base = buffer);
        iov++;
        if (what) {
                if (*what) {
-                       iov->iov_len = strlen (iov->iov_base = " ");
+                       iov->iov_len = strlen(iov->iov_base = " ");
                        iov++;
-                       iov->iov_len = strlen (iov->iov_base = what);
+                       iov->iov_len = strlen(iov->iov_base = what);
                        iov++;
-                       iov->iov_len = strlen (iov->iov_base = ": ");
+                       iov->iov_len = strlen(iov->iov_base = ": ");
                        iov++;
                }
-               if (!(iov->iov_base = strerror (eindex))) {
+               if (!(iov->iov_base = strerror(eindex))) {
                        /* this shouldn't happen, but we'll test for it just in case */
-                       snprintf (err, sizeof(err), "Error %d", eindex);
+                       snprintf(err, sizeof(err), "Error %d", eindex);
                        iov->iov_base = err;
                }
-               iov->iov_len = strlen (iov->iov_base);
+               iov->iov_len = strlen(iov->iov_base);
                iov++;
        }
        if (tail && *tail) {
-               iov->iov_len = strlen (iov->iov_base = ", ");
+               iov->iov_len = strlen(iov->iov_base = ", ");
                iov++;
-               iov->iov_len = strlen (iov->iov_base = tail);
+               iov->iov_len = strlen(iov->iov_base = tail);
                iov++;
        }
-       iov->iov_len = strlen (iov->iov_base = "\n");
+       iov->iov_len = strlen(iov->iov_base = "\n");
        iov++;
-       writev (fileno (stderr), iob, iov - iob);
+       writev(fileno(stderr), iob, iov - iob);
 #else
        if (invo_name && *invo_name)
-               fprintf (stderr, "%s: ", invo_name);
-       vfprintf (stderr, fmt, ap);
+               fprintf(stderr, "%s: ", invo_name);
+       vfprintf(stderr, fmt, ap);
 
        if (what) {
                char *s;
 
                if (*what)
-                       fprintf (stderr, " %s: ", what);
+                       fprintf(stderr, " %s: ", what);
                if ((s = strerror(eindex)))
-                       fprintf (stderr, "%s", s);
+                       fprintf(stderr, "%s", s);
                else
-                       fprintf (stderr, "Error %d", eindex);
+                       fprintf(stderr, "Error %d", eindex);
        }
        if (tail)
-               fprintf (stderr, ", %s", tail);
-       fputc ('\n', stderr);
+               fprintf(stderr, ", %s", tail);
+       fputc('\n', stderr);
 #endif
 }
index 769c525..937d196 100644 (file)
 
 
 int
-fdcompare (int fd1, int fd2)
+fdcompare(int fd1, int fd2)
 {
        register int i, n1, n2, resp;
        register char *c1, *c2;
        char b1[BUFSIZ], b2[BUFSIZ];
 
        resp = 1;
-       while ((n1 = read (fd1, b1, sizeof(b1))) >= 0
-               && (n2 = read (fd2, b2, sizeof(b2))) >= 0
+       while ((n1 = read(fd1, b1, sizeof(b1))) >= 0
+               && (n2 = read(fd2, b2, sizeof(b2))) >= 0
                && n1 == n2) {
                c1 = b1;
                c2 = b2;
@@ -33,7 +33,7 @@ fdcompare (int fd1, int fd2)
        resp = 0;
 
 leave: ;
-       lseek (fd1, (off_t) 0, SEEK_SET);
-       lseek (fd2, (off_t) 0, SEEK_SET);
+       lseek(fd1, (off_t) 0, SEEK_SET);
+       lseek(fd2, (off_t) 0, SEEK_SET);
        return resp;
 }
index a2338e3..d6218b5 100644 (file)
@@ -22,11 +22,11 @@ static unsigned int bufsiz;  /* current size of buf         */
 
 /* check if there's enough room in buf for str.  add more mem if needed */
 #define CHECKMEM(str) \
-       if ((len = strlen (str)) >= bufend - dst) {\
+       if ((len = strlen(str)) >= bufend - dst) {\
                int i = dst - buf;\
                int n = last_dst - buf;\
                bufsiz += ((dst + len - bufend) / BUFINCR + 1) * BUFINCR;\
-               buf = mh_xrealloc (buf, bufsiz);\
+               buf = mh_xrealloc(buf, bufsiz);\
                dst = buf + i;\
                last_dst = buf + n;\
                bufend = buf + bufsiz;\
@@ -49,7 +49,7 @@ static unsigned int bufsiz;  /* current size of buf         */
 */
 
 char *
-formataddr (char *orig, char *str)
+formataddr(char *orig, char *str)
 {
        register int len;
        register int isgroup;
@@ -60,7 +60,7 @@ formataddr (char *orig, char *str)
 
        /* if we don't have a buffer yet, get one */
        if (bufsiz == 0) {
-               buf = mh_xmalloc (BUFINCR);
+               buf = mh_xmalloc(BUFINCR);
                last_dst = buf;  /* XXX */
                bufsiz = BUFINCR - 6;  /* leave some slop */
                bufend = buf + bufsiz;
@@ -76,13 +76,13 @@ formataddr (char *orig, char *str)
                *dst = '\0';
        } else {
                dst = last_dst;  /* XXX */
-               CHECKMEM (orig);
-               CPY (orig);
+               CHECKMEM(orig);
+               CPY(orig);
        }
 
        /* concatenate all the new addresses onto 'buf' */
-       for (isgroup = 0; (cp = getname (str)); ) {
-               if ((mp = getm (cp, NULL, 0, fmt_norm, NULL)) == NULL)
+       for (isgroup = 0; (cp = getname(str)); ) {
+               if ((mp = getm(cp, NULL, 0, fmt_norm, NULL)) == NULL)
                        continue;
 
                if (isgroup && (mp->m_gname || !mp->m_ingrp)) {
@@ -95,14 +95,14 @@ formataddr (char *orig, char *str)
                        *dst++ = ' ';
                }
                if (mp->m_gname) {
-                       CHECKMEM (mp->m_gname);
-                       CPY (mp->m_gname);
+                       CHECKMEM(mp->m_gname);
+                       CPY(mp->m_gname);
                        isgroup++;
                }
-               sp = adrformat (mp);
-               CHECKMEM (sp);
-               CPY (sp);
-               mnfree (mp);
+               sp = adrformat(mp);
+               CHECKMEM(sp);
+               CPY(sp);
+               mnfree(mp);
        }
 
        if (isgroup)
index 9d8f41d..bcd7b3d 100644 (file)
@@ -189,7 +189,7 @@ static struct ftable functable[] = {
 static char *format_string;
 static unsigned char *usr_fstring;  /* for CERROR */
 
-#define CERROR(str) compile_error (str, cp)
+#define CERROR(str) compile_error(str, cp)
 
 /*
 ** external prototypes
@@ -201,11 +201,11 @@ extern char *getusername(void);
 */
 static struct ftable *lookup(char *);
 static void compile_error(char *, char *);
-static char *compile (char *);
+static char *compile(char *);
 static char *do_spec(char *);
 static char *do_name(char *, int);
 static char *do_func(char *);
-static char *do_expr (char *, int);
+static char *do_expr(char *, int);
 static char *do_loop(char *);
 static char *do_if(char *);
 
@@ -218,7 +218,7 @@ lookup(char *name)
        register char c = *name;
 
        while ((nm = t->name)) {
-               if (*nm == c && strcmp (nm, name) == 0)
+               if (*nm == c && strcmp(nm, name) == 0)
                        return (ftbl = t);
 
                t++;
@@ -247,7 +247,7 @@ compile_error(char *str, char *cp)
 
        advise(NULL, "\"%s\": format compile error - %s",
                   &usr_fstring[errpos-errctx], str);
-       adios (NULL, "%*s", errctx+1, "^");
+       adios(NULL, "%*s", errctx+1, "^");
 }
 
 /*
@@ -263,8 +263,8 @@ fmt_compile(char *fstring, struct format **fmt)
        int i;
 
        if (format_string)
-               free (format_string);
-       format_string = getcpy (fstring);
+               free(format_string);
+       format_string = getcpy(fstring);
        usr_fstring = fstring;
 
        /* init the component hash table. */
@@ -283,10 +283,10 @@ fmt_compile(char *fstring, struct format **fmt)
        i = strlen(fstring)/2 + 1;
        if (i == 1)
                i++;
-       next_fp = formatvec = (struct format *)calloc ((size_t) i,
+       next_fp = formatvec = (struct format *)calloc((size_t) i,
                sizeof(struct format));
        if (next_fp == NULL)
-               adios (NULL, "unable to allocate format storage");
+               adios(NULL, "unable to allocate format storage");
 
        ncomp = 0;
        infunction = 0;
@@ -302,7 +302,7 @@ fmt_compile(char *fstring, struct format **fmt)
 }
 
 static char *
-compile (char *sp)
+compile(char *sp)
 {
        register char *cp = sp;
        register int  c;
@@ -327,7 +327,7 @@ compile (char *sp)
 
                switch (c = *++cp) {
                case '%':
-                       PUTC (*cp);
+                       PUTC(*cp);
                        cp++;
                        break;
 
@@ -437,7 +437,7 @@ do_name(char *sp, int preprocess)
 
        case FT_MYMBOX:
                if (!primed) {
-                       ismymbox ((struct mailname *) 0);
+                       ismymbox((struct mailname *) 0);
                        primed++;
                }
                /* fall through */
@@ -478,7 +478,7 @@ do_func(char *sp)
                CERROR("'(', '{', ' ' or ')' expected");
        }
        cp[-1] = '\0';
-       if ((t = lookup (sp)) == 0) {
+       if ((t = lookup(sp)) == 0) {
                CERROR("unknown function");
        }
        if (isspace(c))
@@ -554,22 +554,22 @@ do_func(char *sp)
 }
 
 static char *
-do_expr (char *sp, int preprocess)
+do_expr(char *sp, int preprocess)
 {
        register char *cp = sp;
        register int  c;
 
        if ((c = *cp++) == '{') {
-               cp = do_name (cp, preprocess);
+               cp = do_name(cp, preprocess);
                fp->f_type = FT_LS_COMP;
        } else if (c == '(') {
-               cp = do_func (cp);
+               cp = do_func(cp);
        } else if (c == ')') {
                return (--cp);
        } else if (c == '%' && *cp == '<') {
-               cp = do_if (cp+1);
+               cp = do_if(cp+1);
        } else {
-               CERROR ("'(', '{', '%<' or ')' expected");
+               CERROR("'(', '{', '%<' or ')' expected");
        }
        return (cp);
 }
@@ -581,9 +581,9 @@ do_loop(char *sp)
        struct format *floop;
 
        floop = next_fp;
-       cp = compile (cp);
+       cp = compile(cp);
        if (*cp++ != ']')
-               CERROR ("']' expected");
+               CERROR("']' expected");
 
        LV(FT_DONE, 1);  /* not yet done */
        LV(FT_GOTO, 0);
@@ -604,7 +604,7 @@ do_if(char *sp)
                        if ((c = *cp++) == '{') /*}*/{
                                cp = do_name(cp, 0);
                                fp->f_type = FT_LS_COMP;
-                               LV (FT_IF_S, 0);
+                               LV(FT_IF_S, 0);
                        } else if (c == '(') {
                                cp = do_func(cp);
                                /* see if we can merge the load and the "if" */
@@ -617,9 +617,9 @@ do_if(char *sp)
                                        ** function 's return type is.
                                        */
                                        if (ftbl->flags & TFL_PUTS) {
-                                               LV (FT_IF_S, 0);
+                                               LV(FT_IF_S, 0);
                                        } else {
-                                               LV (FT_IF_V_NE, 0);
+                                               LV(FT_IF_V_NE, 0);
                                        }
                                }
                        } else {
@@ -628,7 +628,7 @@ do_if(char *sp)
                }
 
                fexpr = fp;  /* loc of [ELS]IF */
-               cp = compile (cp);  /* compile IF TRUE stmts */
+               cp = compile(cp);  /* compile IF TRUE stmts */
                if (fif)
                        fif->f_skip = next_fp - fif;
 
@@ -639,7 +639,7 @@ do_if(char *sp)
 
                        fexpr = (struct format *)NULL;/* no extra ENDIF */
 
-                       cp = compile (cp);  /* compile ELSE stmts */
+                       cp = compile(cp);  /* compile ELSE stmts */
                        fif->f_skip = next_fp - fif;
                        c = *cp++;
                } else if (c == '?') {  /* another ELSIF */
index 7576ae4..4e56378 100644 (file)
@@ -16,7 +16,7 @@ static char *formats = 0;
 /*
 ** static prototypes
 */
-static void normalize (char *);
+static void normalize(char *);
 
 
 /*
@@ -24,34 +24,34 @@ static void normalize (char *);
 */
 
 char *
-new_fs (char *form, char *format, char *default_fs)
+new_fs(char *form, char *format, char *default_fs)
 {
        struct stat st;
        register FILE *fp;
 
        if (formats)
-               free (formats);
+               free(formats);
 
        if (form) {
-               if ((fp = fopen (etcpath (form), "r")) == NULL)
-                       adios (form, "unable to open format file");
+               if ((fp = fopen(etcpath(form), "r")) == NULL)
+                       adios(form, "unable to open format file");
 
-               if (fstat (fileno (fp), &st) == -1)
-                       adios (form, "unable to stat format file");
+               if (fstat(fileno(fp), &st) == -1)
+                       adios(form, "unable to stat format file");
 
-               formats = mh_xmalloc ((size_t) st.st_size + 1);
+               formats = mh_xmalloc((size_t) st.st_size + 1);
 
-               if (read (fileno(fp), formats, (int) st.st_size) != st.st_size)
-                       adios (form, "error reading format file");
+               if (read(fileno(fp), formats, (int) st.st_size) != st.st_size)
+                       adios(form, "error reading format file");
 
                formats[st.st_size] = '\0';
 
-               fclose (fp);
+               fclose(fp);
        } else {
-               formats = getcpy (format ? format : default_fs);
+               formats = getcpy(format ? format : default_fs);
        }
 
-       normalize (formats);  /* expand escapes */
+       normalize(formats);  /* expand escapes */
 
        return formats;
 }
@@ -62,7 +62,7 @@ new_fs (char *form, char *format, char *default_fs)
 */
 
 static void
-normalize (char *cp)
+normalize(char *cp)
 {
        char *dp;
 
index 5bc7850..dc123e5 100644 (file)
@@ -38,7 +38,7 @@ static signed char index_64[128] = {
 #define char64(c) (((unsigned char) (c) > 127) ? -1 : index_64[(unsigned char) (c)])
 
 static int
-unqp (unsigned char byte1, unsigned char byte2)
+unqp(unsigned char byte1, unsigned char byte2)
 {
        if (hexindex[byte1] == -1 || hexindex[byte2] == -1)
                return -1;
@@ -57,7 +57,7 @@ unqp (unsigned char byte1, unsigned char byte2)
 #define ADDCHR(C) do { *q++ = (C); dstlen--; if (!dstlen) goto buffull; } while (0)
 
 int
-decode_rfc2047 (char *str, char *dst, size_t dstlen)
+decode_rfc2047(char *str, char *dst, size_t dstlen)
 {
        char *p, *q, *pp;
        char *startofmime, *endofmime;
@@ -81,7 +81,7 @@ decode_rfc2047 (char *str, char *dst, size_t dstlen)
        ** Do a quick and dirty check for the '=' character.
        ** This should quickly eliminate many cases.
        */
-       if (!strchr (str, '='))
+       if (!strchr(str, '='))
                return 0;
 
        for (p = str, q = dst; *p; p++) {
@@ -222,7 +222,7 @@ decode_rfc2047 (char *str, char *dst, size_t dstlen)
                        if (quoted_printable) {
                                for (pp = startofmime; pp < endofmime; pp++) {
                                        if (*pp == '=') {
-                                               c = unqp (pp[1], pp[2]);
+                                               c = unqp(pp[1], pp[2]);
                                                if (c == -1)
                                                        continue;
                                                if (c != 0)
@@ -302,7 +302,7 @@ decode_rfc2047 (char *str, char *dst, size_t dstlen)
                                                ** which won't work if either
                                                ** encoding was stateful
                                                */
-                                               iconv (cd, 0, 0, &saveq, &savedstlen);
+                                               iconv(cd, 0, 0, &saveq, &savedstlen);
                                                if (!savedstlen)
                                                        break;
                                                *saveq++ = '?';
index 8a8e4c1..ac98883 100644 (file)
@@ -29,7 +29,7 @@
 
 #define NFMTS MAXARGS
 
-extern char *formataddr ();  /* hook for custom address formatting */
+extern char *formataddr();  /* hook for custom address formatting */
 
 #ifdef LBL
 struct msgs *fmt_current_folder; /* current folder (set by main program) */
@@ -41,9 +41,9 @@ struct mailname fmt_mnull;
 /*
 ** static prototypes
 */
-static int match (char *, char *);
-static char *get_x400_friendly (char *, char *, int);
-static int get_x400_comp (char *, char *, char *, int);
+static int match(char *, char *);
+static char *get_x400_friendly(char *, char *, int);
+static int get_x400_comp(char *, char *, char *, int);
 
 
 /*
@@ -52,7 +52,7 @@ static int get_x400_comp (char *, char *, char *, int);
 */
 
 static int
-match (char *str, char *sub)
+match(char *str, char *sub)
 {
        int c1, c2;
        char *s1, *s2;
@@ -208,7 +208,7 @@ cptrimmed(char **dest, char *str, unsigned int wid, char fill, size_t n) {
 }
 
 static void
-cpstripped (char **start, char *end, char *str)
+cpstripped(char **start, char *end, char *str)
 {
        int c;
        char *s = str;
@@ -248,7 +248,7 @@ static char *lmonth[] = {
 };
 
 static char *
-get_x400_friendly (char *mbox, char *buffer, int buffer_len)
+get_x400_friendly(char *mbox, char *buffer, int buffer_len)
 {
        char given[BUFSIZ], surname[BUFSIZ];
 
@@ -259,40 +259,40 @@ get_x400_friendly (char *mbox, char *buffer, int buffer_len)
        if (*mbox != '/')
                return NULL;
 
-       if (get_x400_comp (mbox, "/PN=", buffer, buffer_len)) {
+       if (get_x400_comp(mbox, "/PN=", buffer, buffer_len)) {
                for (mbox = buffer; (mbox = strchr(mbox, '.')); )
                        *mbox++ = ' ';
 
                return buffer;
        }
 
-       if (!get_x400_comp (mbox, "/S=", surname, sizeof(surname)))
+       if (!get_x400_comp(mbox, "/S=", surname, sizeof(surname)))
                return NULL;
 
-       if (get_x400_comp (mbox, "/G=", given, sizeof(given)))
-               snprintf (buffer, buffer_len, "%s %s", given, surname);
+       if (get_x400_comp(mbox, "/G=", given, sizeof(given)))
+               snprintf(buffer, buffer_len, "%s %s", given, surname);
        else
-               snprintf (buffer, buffer_len, "%s", surname);
+               snprintf(buffer, buffer_len, "%s", surname);
 
        return buffer;
 }
 
 static int
-get_x400_comp (char *mbox, char *key, char *buffer, int buffer_len)
+get_x400_comp(char *mbox, char *key, char *buffer, int buffer_len)
 {
        int idx;
        char *cp;
 
-       if ((idx = stringdex (key, mbox)) < 0
-               || !(cp = strchr(mbox += idx + strlen (key), '/')))
+       if ((idx = stringdex(key, mbox)) < 0
+               || !(cp = strchr(mbox += idx + strlen(key), '/')))
                return 0;
 
-       snprintf (buffer, buffer_len, "%*.*s", (int)(cp - mbox), (int)(cp - mbox), mbox);
+       snprintf(buffer, buffer_len, "%*.*s", (int)(cp - mbox), (int)(cp - mbox), mbox);
        return 1;
 }
 
 struct format *
-fmt_scan (struct format *format, char *scanl, int width, int *dat)
+fmt_scan(struct format *format, char *scanl, int width, int *dat)
 {
        char *cp, *ep;
        unsigned char *sp;
@@ -324,10 +324,10 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                switch (fmt->f_type) {
 
                case FT_COMP:
-                       cpstripped (&cp, ep, fmt->f_comp->c_text);
+                       cpstripped(&cp, ep, fmt->f_comp->c_text);
                        break;
                case FT_COMPF:
-                       cptrimmed (&cp, fmt->f_comp->c_text, fmt->f_width, fmt->f_fill, ep - cp);
+                       cptrimmed(&cp, fmt->f_comp->c_text, fmt->f_width, fmt->f_fill, ep - cp);
                        break;
 
                case FT_LIT:
@@ -350,13 +350,13 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        break;
 
                case FT_STR:
-                       cpstripped (&cp, ep, str);
+                       cpstripped(&cp, ep, str);
                        break;
                case FT_STRF:
-                       cptrimmed (&cp, str, fmt->f_width, fmt->f_fill, ep - cp);
+                       cptrimmed(&cp, str, fmt->f_width, fmt->f_fill, ep - cp);
                        break;
                case FT_STRFW:
-                       adios (NULL, "internal error (FT_STRFW)");
+                       adios(NULL, "internal error (FT_STRFW)");
 
                case FT_NUM:
                        n = snprintf(cp, ep - cp + 1, "%d", value);
@@ -368,7 +368,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        }
                        break;
                case FT_NUMF:
-                       cpnumber (&cp, value, fmt->f_width, fmt->f_fill, ep - cp);
+                       cpnumber(&cp, value, fmt->f_width, fmt->f_fill, ep - cp);
                        break;
 
                case FT_CHAR:
@@ -414,7 +414,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        break;
 
                case FT_IF_MATCH:
-                       if (!(value = (str && match (str, fmt->f_text)))) {
+                       if (!(value = (str && match(str, fmt->f_text)))) {
                                fmt += fmt->f_skip;
                                continue;
                        }
@@ -422,20 +422,20 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
 
                case FT_V_MATCH:
                        if (str)
-                               value = match (str, fmt->f_text);
+                               value = match(str, fmt->f_text);
                        else
                                value = 0;
                        break;
 
                case FT_IF_AMATCH:
-                       if (!(value = (str && uprf (str, fmt->f_text)))) {
+                       if (!(value = (str && uprf(str, fmt->f_text)))) {
                                fmt += fmt->f_skip;
                                continue;
                        }
                        break;
 
                case FT_V_AMATCH:
-                       value = uprf (str, fmt->f_text);
+                       value = uprf(str, fmt->f_text);
                        break;
 
                case FT_S_NONNULL:
@@ -472,11 +472,11 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        str = fmt->f_text;
                        break;
                case FT_LS_GETENV:
-                       if (!(str = getenv (fmt->f_text)))
+                       if (!(str = getenv(fmt->f_text)))
                                str = "";
                        break;
                case FT_LS_CFIND:
-                       if (!(str = context_find (fmt->f_text)))
+                       if (!(str = context_find(fmt->f_text)))
                                str = "";
                        break;
 
@@ -583,24 +583,24 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        str = lmonth[fmt->f_comp->c_tws->tw_mon];
                        break;
                case FT_LS_ZONE:
-                       str = dtwszone (fmt->f_comp->c_tws);
+                       str = dtwszone(fmt->f_comp->c_tws);
                        break;
                case FT_LV_YEAR:
                        value = fmt->f_comp->c_tws->tw_year;
                        break;
                case FT_LV_WDAY:
                        if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
-                               set_dotw (tws);
+                               set_dotw(tws);
                        value = tws->tw_wday;
                        break;
                case FT_LS_DAY:
                        if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
-                               set_dotw (tws);
+                               set_dotw(tws);
                        str = tw_dotw[tws->tw_wday];
                        break;
                case FT_LS_WEEKDAY:
                        if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
-                               set_dotw (tws);
+                               set_dotw(tws);
                        str = tw_ldotw[tws->tw_wday];
                        break;
                case FT_LV_YDAY:
@@ -620,7 +620,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        break;
                case FT_LV_DAYF:
                        if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
-                               set_dotw (tws);
+                               set_dotw(tws);
                        switch (fmt->f_comp->c_tws->tw_flags & TW_SDAY) {
                                case TW_SEXP:
                                        value = 1; break;
@@ -639,10 +639,10 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        value = fmt->f_comp->c_tws->tw_flags & TW_DST;
                        break;
                case FT_LS_822DATE:
-                       str = dasctime (fmt->f_comp->c_tws , TW_ZONE);
+                       str = dasctime(fmt->f_comp->c_tws , TW_ZONE);
                        break;
                case FT_LS_PRETTY:
-                       str = dasctime (fmt->f_comp->c_tws, TW_NULL);
+                       str = dasctime(fmt->f_comp->c_tws, TW_NULL);
                        break;
 
                case FT_LS_PERS:
@@ -685,7 +685,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                                goto unfriendly;
                        if ((str = mn->m_pers) == NULL) {
                                if ((str = mn->m_note)) {
-                                       strncpy (buffer, str, sizeof(buffer));
+                                       strncpy(buffer, str, sizeof(buffer));
                                        buffer[sizeof(buffer)-1] = '\0';
                                        str = buffer;
                                        if (*str == '(')
@@ -699,7 +699,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                                                        else
                                                                break;
                                        }
-                               } else if (!(str = get_x400_friendly (mn->m_mbox,
+                               } else if (!(str = get_x400_friendly(mn->m_mbox,
                                        buffer, sizeof(buffer)))) {
                unfriendly: ;
                                        switch (mn->m_type) {
@@ -707,13 +707,13 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                                                str = mn->m_mbox;
                                                break;
                                        case UUCPHOST:
-                                               snprintf (buffer, sizeof(buffer), "%s!%s",
+                                               snprintf(buffer, sizeof(buffer), "%s!%s",
                                                        mn->m_host, mn->m_mbox);
                                                str = buffer;
                                                break;
                                        default:
                                                if (mn->m_mbox) {
-                                                       snprintf (buffer, sizeof(buffer), "%s@%s",
+                                                       snprintf(buffer, sizeof(buffer), "%s@%s",
                                                                mn->m_mbox, mn->m_host);
                                                        str= buffer;
                                                } else
@@ -782,7 +782,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                                *comp->c_tws = *tws;
                                comp->c_flags &= ~CF_TRUE;
                        } else if ((comp->c_flags & CF_DATEFAB) == 0) {
-                               memset ((char *) comp->c_tws, 0, sizeof *comp->c_tws);
+                               memset((char *) comp->c_tws, 0, sizeof *comp->c_tws);
                                comp->c_flags = CF_TRUE;
                        }
                        comp->c_flags |= CF_PARSED;
@@ -793,7 +793,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        ** hook for custom address list formatting
                        ** (see replsbr.c)
                        */
-                       str = formataddr (savestr, str);
+                       str = formataddr(savestr, str);
                        break;
 
                case FT_PUTADDR:
@@ -811,9 +811,9 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
 
                        lp = str;
                        wid = value;
-                       len = strlen (str);
+                       len = strlen(str);
                        sp = fmt->f_text;
-                       indent = strlen (sp);
+                       indent = strlen(sp);
                        wid -= indent;
                        while( (c = *sp++) && cp < ep)
                                *cp++ = c;
@@ -847,7 +847,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                                                *cp++ = ' ';
                                }
                        }
-                       cpstripped (&cp, ep, lp);
+                       cpstripped(&cp, ep, lp);
                        }
                        break;
 
@@ -856,9 +856,9 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        if (comp->c_flags & CF_PARSED)
                                break;
                        if (comp->c_mn != &fmt_mnull)
-                               mnfree (comp->c_mn);
+                               mnfree(comp->c_mn);
                        if ((sp = comp->c_text) && (sp = getname(sp)) &&
-                               (mn = getm (sp, NULL, 0, fmt_norm, NULL))) {
+                               (mn = getm(sp, NULL, 0, fmt_norm, NULL))) {
                                comp->c_mn = mn;
                                while (getname(""))
                                        ;
@@ -878,9 +878,9 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        */
                        comp = fmt->f_comp;
                        if (comp->c_mn != &fmt_mnull)
-                               mnfree (comp->c_mn);
+                               mnfree(comp->c_mn);
                        if ((sp = comp->c_text) && (sp = getname(sp)) &&
-                               (mn = getm (sp, NULL, 0, AD_NAME, NULL))) {
+                               (mn = getm(sp, NULL, 0, AD_NAME, NULL))) {
                                comp->c_mn = mn;
                                if (ismymbox(mn))
                                        comp->c_flags |= CF_TRUE;
@@ -888,7 +888,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                                        comp->c_flags &= ~CF_TRUE;
                                while ((sp = getname(sp)))
                                        if ((comp->c_flags & CF_TRUE) == 0 &&
-                                               (mn = getm (sp, NULL, 0, AD_NAME, NULL)))
+                                               (mn = getm(sp, NULL, 0, AD_NAME, NULL)))
                                                if (ismymbox(mn))
                                                        comp->c_flags |= CF_TRUE;
                        } else {
index 5d1690e..423384a 100644 (file)
@@ -16,7 +16,7 @@
 */
 
 int
-folder_addmsg (struct msgs **mpp, char *msgfile, int selected,
+folder_addmsg(struct msgs **mpp, char *msgfile, int selected,
        int unseen, int preserve, int deleting, char *from_dir)
 {
        int infd, outfd, linkerr, msgnum;
@@ -28,7 +28,7 @@ folder_addmsg (struct msgs **mpp, char *msgfile, int selected,
        mp = *mpp;
 
        /* should we preserve the numbering of the message? */
-       if (preserve && (msgnum = m_atoi (msgfile)) > 0) {
+       if (preserve && (msgnum = m_atoi(msgfile)) > 0) {
                ;
        } else if (mp->nummsg == 0) {
                /* check if we are adding to empty folder */
@@ -51,17 +51,17 @@ folder_addmsg (struct msgs **mpp, char *msgfile, int selected,
                ** extend message status range to cover this message number.
                */
                if (msgnum > mp->hghoff) {
-                       if ((mp = folder_realloc (mp, mp->lowoff, msgnum + 100)))
+                       if ((mp = folder_realloc(mp, mp->lowoff, msgnum + 100)))
                                *mpp = mp;
                        else {
-                               advise (NULL, "unable to allocate folder storage");
+                               advise(NULL, "unable to allocate folder storage");
                                return -1;
                        }
                } else if (msgnum < mp->lowoff) {
-                       if ((mp = folder_realloc (mp, msgnum, mp->hghoff)))
+                       if ((mp = folder_realloc(mp, msgnum, mp->hghoff)))
                                *mpp = mp;
                        else {
-                               advise (NULL, "unable to allocate folder storage");
+                               advise(NULL, "unable to allocate folder storage");
                                return -1;
                        }
                }
@@ -70,21 +70,21 @@ folder_addmsg (struct msgs **mpp, char *msgfile, int selected,
                ** If a message is already in that slot,
                ** then loop to next available slot.
                */
-               if (does_exist (mp, msgnum))
+               if (does_exist(mp, msgnum))
                        continue;
 
                /* setup the bit flags for this message */
-               clear_msg_flags (mp, msgnum);
-               set_exists (mp, msgnum);
+               clear_msg_flags(mp, msgnum);
+               set_exists(mp, msgnum);
 
                /* should we set the SELECT_UNSEEN bit? */
                if (unseen) {
-                       set_unseen (mp, msgnum);
+                       set_unseen(mp, msgnum);
                }
 
                /* should we set the SELECTED bit? */
                if (selected) {
-                       set_selected (mp, msgnum);
+                       set_selected(mp, msgnum);
 
                        /* check if highest or lowest selected */
                        if (mp->numsel == 0) {
@@ -117,8 +117,8 @@ folder_addmsg (struct msgs **mpp, char *msgfile, int selected,
                /* increment message count */
                mp->nummsg++;
 
-               nmsg = m_name (msgnum);
-               snprintf (newmsg, sizeof(newmsg), "%s/%s", mp->foldpath, nmsg);
+               nmsg = m_name(msgnum);
+               snprintf(newmsg, sizeof(newmsg), "%s/%s", mp->foldpath, nmsg);
 
                /*
                ** Now try to link message into folder.  Then run the
@@ -129,7 +129,7 @@ folder_addmsg (struct msgs **mpp, char *msgfile, int selected,
                ** Run the add hook if the message is getting copied or
                ** linked somewhere else.
                */
-               if (link (msgfile, newmsg) != -1) {
+               if (link(msgfile, newmsg) != -1) {
 
                        if (deleting) {
                                (void)snprintf(oldmsg, sizeof (oldmsg), "%s/%s", from_dir, msgfile);
@@ -154,7 +154,7 @@ folder_addmsg (struct msgs **mpp, char *msgfile, int selected,
                        ** slot (hghmsg+1).
                        */
                        if (linkerr == EEXIST) {
-                               if (stat (msgfile, &st2) == 0 && stat (newmsg, &st1) == 0
+                               if (stat(msgfile, &st2) == 0 && stat(newmsg, &st1) == 0
                                        && st2.st_ino == st1.st_ino) {
                                        return msgnum;
                                } else {
@@ -169,23 +169,23 @@ folder_addmsg (struct msgs **mpp, char *msgfile, int selected,
                        ** error, else just copy the message.
                        */
                        if (linkerr == EXDEV) {
-                               if (stat (newmsg, &st1) == 0) {
-                                       advise (NULL, "message %s:%s already exists", mp->foldpath, newmsg);
+                               if (stat(newmsg, &st1) == 0) {
+                                       advise(NULL, "message %s:%s already exists", mp->foldpath, newmsg);
                                        return -1;
                                } else {
-                                       if ((infd = open (msgfile, O_RDONLY)) == -1) {
-                                               advise (msgfile, "unable to open message %s", msgfile);
+                                       if ((infd = open(msgfile, O_RDONLY)) == -1) {
+                                               advise(msgfile, "unable to open message %s", msgfile);
                                                return -1;
                                        }
-                                       fstat (infd, &st1);
-                                       if ((outfd = creat (newmsg, (int) st1.st_mode & 0777)) == -1) {
-                                               advise (newmsg, "unable to create");
-                                               close (infd);
+                                       fstat(infd, &st1);
+                                       if ((outfd = creat(newmsg, (int) st1.st_mode & 0777)) == -1) {
+                                               advise(newmsg, "unable to create");
+                                               close(infd);
                                                return -1;
                                        }
-                                       cpydata (infd, outfd, msgfile, newmsg);
-                                       close (infd);
-                                       close (outfd);
+                                       cpydata(infd, outfd, msgfile, newmsg);
+                                       close(infd);
+                                       close(outfd);
 
                                        if (deleting) {
                                                (void)snprintf(oldmsg, sizeof (oldmsg), "%s/%s", from_dir, msgfile);
@@ -201,7 +201,7 @@ folder_addmsg (struct msgs **mpp, char *msgfile, int selected,
                        ** Else, some other type of link error,
                        ** so just return error.
                        */
-                       advise (newmsg, "error linking %s to", msgfile);
+                       advise(newmsg, "error linking %s to", msgfile);
                        return -1;
                }
        }
index 5df5b5f..77131b1 100644 (file)
@@ -19,7 +19,7 @@
 */
 
 int
-folder_delmsgs (struct msgs *mp, int unlink_msgs, int nohook)
+folder_delmsgs(struct msgs *mp, int unlink_msgs, int nohook)
 {
        pid_t pid;
        int msgnum, vecp, retval = 0;
@@ -32,43 +32,43 @@ folder_delmsgs (struct msgs *mp, int unlink_msgs, int nohook)
        if (rmmproc) {
                /* Unset the EXISTS flag for each message to be removed */
                for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
-                       if (is_selected (mp, msgnum))
-                       unset_exists (mp, msgnum);
+                       if (is_selected(mp, msgnum))
+                       unset_exists(mp, msgnum);
                }
 
                /* Mark that the sequence information has changed */
                mp->msgflags |= SEQMOD;
 
                if (mp->numsel > MAXARGS - 2)
-                       adios (NULL, "more than %d messages for %s exec", MAXARGS - 2,
+                       adios(NULL, "more than %d messages for %s exec", MAXARGS - 2,
                                rmmproc);
-               vec = (char **) calloc ((size_t) (mp->numsel + 2), sizeof(*vec));
+               vec = (char **) calloc((size_t) (mp->numsel + 2), sizeof(*vec));
                if (vec == NULL)
-                       adios (NULL, "unable to allocate exec vector");
+                       adios(NULL, "unable to allocate exec vector");
                vecp = 1;
                for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
-                       if (is_selected (mp, msgnum) &&
-                               !(vec[vecp++] = strdup (m_name (msgnum))))
-                       adios (NULL, "strdup failed");
+                       if (is_selected(mp, msgnum) &&
+                               !(vec[vecp++] = strdup(m_name(msgnum))))
+                       adios(NULL, "strdup failed");
                }
                vec[vecp] = NULL;
 
-               fflush (stdout);
-               vec[0] = r1bindex (rmmproc, '/');
+               fflush(stdout);
+               vec[0] = r1bindex(rmmproc, '/');
 
                switch (pid = vfork()) {
                case -1:
-                       advise ("fork", "unable to");
+                       advise("fork", "unable to");
                        return -1;
 
                case 0:
-                       execvp (rmmproc, vec);
-                       fprintf (stderr, "unable to exec ");
-                       perror (rmmproc);
-                       _exit (-1);
+                       execvp(rmmproc, vec);
+                       fprintf(stderr, "unable to exec ");
+                       perror(rmmproc);
+                       _exit(-1);
 
                default:
-                       return (pidwait (pid, -1));
+                       return (pidwait(pid, -1));
                }
        }
 
@@ -76,9 +76,9 @@ folder_delmsgs (struct msgs *mp, int unlink_msgs, int nohook)
        ** Either unlink or rename the SELECTED messages
        */
        for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
-               if (is_selected (mp, msgnum)) {
+               if (is_selected(mp, msgnum)) {
                        /* unselect message */
-                       unset_selected (mp, msgnum);
+                       unset_selected(mp, msgnum);
                        mp->numsel--;
 
                        /*
@@ -96,34 +96,34 @@ folder_delmsgs (struct msgs *mp, int unlink_msgs, int nohook)
                                (void)ext_hook("del-hook", msgpath, (char *)0);
                        }
 
-                       dp = m_name (msgnum);
+                       dp = m_name(msgnum);
 
                        if (unlink_msgs) {
                                /* just unlink the messages */
-                               if (unlink (dp) == -1) {
-                                       admonish (dp, "unable to unlink");
+                               if (unlink(dp) == -1) {
+                                       admonish(dp, "unable to unlink");
                                        retval = -1;
                                        continue;
                                }
                        } else {
                                /* or rename messages with standard prefix */
-                               strncpy (buf, m_backup (dp), sizeof(buf));
-                               if (rename (dp, buf) == -1) {
-                                       admonish (buf, "unable to rename %s to", dp);
+                               strncpy(buf, m_backup(dp), sizeof(buf));
+                               if (rename(dp, buf) == -1) {
+                                       admonish(buf, "unable to rename %s to", dp);
                                        retval = -1;
                                        continue;
                                }
                        }
 
                        /* If removal was successful, decrement message count */
-                       unset_exists (mp, msgnum);
+                       unset_exists(mp, msgnum);
                        mp->nummsg--;
                }
        }
 
        /* Sanity check */
        if (mp->numsel != 0)
-       adios (NULL, "oops, mp->numsel should be 0");
+       adios(NULL, "oops, mp->numsel should be 0");
 
        /* Mark that the sequence information has changed */
        mp->msgflags |= SEQMOD;
index d88febe..d383d78 100644 (file)
@@ -10,7 +10,7 @@
 
 
 void
-folder_free (struct msgs *mp)
+folder_free(struct msgs *mp)
 {
        int i;
 
@@ -18,12 +18,12 @@ folder_free (struct msgs *mp)
                return;
 
        if (mp->foldpath)
-               free (mp->foldpath);
+               free(mp->foldpath);
 
        /* free the sequence names */
        for (i = 0; mp->msgattrs[i]; i++)
-               free (mp->msgattrs[i]);
+               free(mp->msgattrs[i]);
 
-       free (mp->msgstats);  /* free message status area   */
-       free (mp);  /* free main folder structure */
+       free(mp->msgstats);  /* free message status area   */
+       free(mp);  /* free main folder structure */
 }
index 29ed687..5280e30 100644 (file)
@@ -15,7 +15,7 @@
 */
 
 int
-folder_pack (struct msgs **mpp, int verbose)
+folder_pack(struct msgs **mpp, int verbose)
 {
        int hole, msgnum, newcurrent = 0;
        char newmsg[BUFSIZ], oldmsg[BUFSIZ];
@@ -34,21 +34,21 @@ folder_pack (struct msgs **mpp, int verbose)
        ** for all numbers from 1 to current high message.
        */
        if (mp->lowoff > 1) {
-               if ((mp = folder_realloc (mp, 1, mp->hghmsg)))
+               if ((mp = folder_realloc(mp, 1, mp->hghmsg)))
                        *mpp = mp;
                else {
-                       advise (NULL, "unable to allocate folder storage");
+                       advise(NULL, "unable to allocate folder storage");
                        return -1;
                }
        }
 
        for (msgnum = mp->lowmsg, hole = 1; msgnum <= mp->hghmsg; msgnum++) {
-               if (does_exist (mp, msgnum)) {
+               if (does_exist(mp, msgnum)) {
                        if (msgnum != hole) {
-                               strncpy (newmsg, m_name (hole), sizeof(newmsg));
-                               strncpy (oldmsg, m_name (msgnum), sizeof(oldmsg));
+                               strncpy(newmsg, m_name(hole), sizeof(newmsg));
+                               strncpy(oldmsg, m_name(msgnum), sizeof(oldmsg));
                                if (verbose)
-                                       printf ("message %s becomes %s\n", oldmsg, newmsg);
+                                       printf("message %s becomes %s\n", oldmsg, newmsg);
 
                                /*
                                ** Invoke the external refile hook for each
@@ -62,8 +62,8 @@ folder_pack (struct msgs **mpp, int verbose)
                                ext_hook("ref-hook", oldmsg, newmsg);
 
                                /* move the message file */
-                               if (rename (oldmsg, newmsg) == -1) {
-                                       advise (newmsg, "unable to rename %s to", oldmsg);
+                               if (rename(oldmsg, newmsg) == -1) {
+                                       advise(newmsg, "unable to rename %s to", oldmsg);
                                        return -1;
                                }
 
@@ -72,7 +72,7 @@ folder_pack (struct msgs **mpp, int verbose)
                                        newcurrent = hole;
 
                                /* copy the attribute flags for this message */
-                               copy_msg_flags (mp, hole, msgnum);
+                               copy_msg_flags(mp, hole, msgnum);
 
                                if (msgnum == mp->lowsel)
                                        mp->lowsel = hole;
@@ -95,7 +95,7 @@ folder_pack (struct msgs **mpp, int verbose)
 
        /* update the "cur" sequence */
        if (newcurrent != 0)
-               seq_setcur (mp, newcurrent);
+               seq_setcur(mp, newcurrent);
 
        return 0;
 }
index 5743166..222b490 100644 (file)
@@ -22,7 +22,7 @@
 */
 
 struct msgs *
-folder_read (char *name)
+folder_read(char *name)
 {
        int msgnum, prefix_len, len, *mi;
        struct msgs *mp;
@@ -30,21 +30,21 @@ folder_read (char *name)
        struct dirent *dp;
        DIR *dd;
 
-       name = m_mailpath (name);
-       if (!(dd = opendir (name))) {
-               free (name);
+       name = m_mailpath(name);
+       if (!(dd = opendir(name))) {
+               free(name);
                return NULL;
        }
 
-       if (stat (name, &st) == -1) {
-               free (name);
+       if (stat(name, &st) == -1) {
+               free(name);
                return NULL;
        }
 
        /* Allocate the main structure for folder information */
-       mp = (struct msgs *) mh_xmalloc ((size_t) sizeof(*mp));
+       mp = (struct msgs *) mh_xmalloc((size_t) sizeof(*mp));
 
-       clear_folder_flags (mp);
+       clear_folder_flags(mp);
        mp->foldpath = name;
        mp->lowmsg = 0;
        mp->hghmsg = 0;
@@ -54,8 +54,8 @@ folder_read (char *name)
        mp->numsel = 0;
        mp->nummsg = 0;
 
-       if (access (name, W_OK) == -1)
-               set_readonly (mp);
+       if (access(name, W_OK) == -1)
+               set_readonly(mp);
        prefix_len = strlen(backup_prefix);
 
        /*
@@ -63,17 +63,17 @@ folder_read (char *name)
        ** name of the messages in this folder.
        */
        len = NUMMSGS;
-       mi = (int *) mh_xmalloc ((size_t) (len * sizeof(*mi)));
+       mi = (int *) mh_xmalloc((size_t) (len * sizeof(*mi)));
 
-       while ((dp = readdir (dd))) {
-               if ((msgnum = m_atoi (dp->d_name)) && msgnum > 0) {
+       while ((dp = readdir(dd))) {
+               if ((msgnum = m_atoi(dp->d_name)) && msgnum > 0) {
                        /*
                        ** Check if we need to allocate more
                        ** temporary elements for message names.
                        */
                        if (mp->nummsg >= len) {
                                len += NUMMSGS;
-                               mi = (int *) mh_xrealloc (mi, (size_t) (len * sizeof(*mi)));
+                               mi = (int *) mh_xrealloc(mi, (size_t) (len * sizeof(*mi)));
                        }
 
                        /* Check if this is the first message we've seen */
@@ -111,43 +111,43 @@ folder_read (char *name)
                                        ** skip any files beginning with
                                        ** backup prefix
                                        */
-                                       if (!strncmp (dp->d_name, backup_prefix, prefix_len))
+                                       if (!strncmp(dp->d_name, backup_prefix, prefix_len))
                                                continue;
 
                                        /* skip the altmsg link file */
-                                       if (!strcmp (dp->d_name, altmsglink))
+                                       if (!strcmp(dp->d_name, altmsglink))
                                                continue;
 
                                        /*
                                        ** indicate that there are other
                                        ** files in folder
                                        */
-                                       set_other_files (mp);
+                                       set_other_files(mp);
                                        continue;
                        }
                }
        }
 
-       closedir (dd);
-       mp->lowoff = max (mp->lowmsg, 1);
+       closedir(dd);
+       mp->lowoff = max(mp->lowmsg, 1);
 
        /* Go ahead and allocate space for 100 additional messages. */
        mp->hghoff = mp->hghmsg + 100;
 
        /* for testing, allocate minimal necessary space */
-       /* mp->hghoff = max (mp->hghmsg, 1); */
+       /* mp->hghoff = max(mp->hghmsg, 1); */
 
        /*
        ** Allocate space for status of each message.
        */
-       mp->msgstats = mh_xmalloc (MSGSTATSIZE(mp, mp->lowoff, mp->hghoff));
+       mp->msgstats = mh_xmalloc(MSGSTATSIZE(mp, mp->lowoff, mp->hghoff));
 
        /*
        ** Clear all the flag bits for all the message
        ** status entries we just allocated.
        */
        for (msgnum = mp->lowoff; msgnum <= mp->hghoff; msgnum++)
-               clear_msg_flags (mp, msgnum);
+               clear_msg_flags(mp, msgnum);
 
        /*
        ** Scan through the array of messages we've seen and
@@ -155,14 +155,14 @@ folder_read (char *name)
        ** newly allocated mp->msgstats area.
        */
        for (msgnum = 0; msgnum < mp->nummsg; msgnum++)
-               set_exists (mp, mi[msgnum]);
+               set_exists(mp, mi[msgnum]);
 
-       free (mi);  /* We don't need this anymore */
+       free(mi);  /* We don't need this anymore */
 
        /*
        ** Read and initialize the sequence information.
        */
-       seq_read (mp);
+       seq_read(mp);
 
        return mp;
 }
index 2418abd..f1b703f 100644 (file)
 */
 
 struct msgs *
-folder_realloc (struct msgs *mp, int lo, int hi)
+folder_realloc(struct msgs *mp, int lo, int hi)
 {
        int msgnum;
 
        /* sanity checks */
        if (lo < 1)
-               adios (NULL, "BUG: called folder_realloc with lo (%d) < 1", lo);
+               adios(NULL, "BUG: called folder_realloc with lo (%d) < 1", lo);
        if (hi < 1)
-               adios (NULL, "BUG: called folder_realloc with hi (%d) < 1", hi);
+               adios(NULL, "BUG: called folder_realloc with hi (%d) < 1", hi);
        if (mp->nummsg > 0 && lo > mp->lowmsg)
-               adios (NULL, "BUG: called folder_realloc with lo (%d) > mp->lowmsg (%d)",
+               adios(NULL, "BUG: called folder_realloc with lo (%d) > mp->lowmsg (%d)",
                           lo, mp->lowmsg);
        if (mp->nummsg > 0 && hi < mp->hghmsg)
-               adios (NULL, "BUG: called folder_realloc with hi (%d) < mp->hghmsg (%d)",
+               adios(NULL, "BUG: called folder_realloc with hi (%d) < mp->hghmsg (%d)",
                           hi, mp->hghmsg);
 
        /* Check if we really need to reallocate anything */
@@ -44,7 +44,7 @@ folder_realloc (struct msgs *mp, int lo, int hi)
                ** status array.  So we don't have to move anything and can
                ** just realloc the message status array.
                */
-               mp->msgstats = mh_xrealloc (mp->msgstats, MSGSTATSIZE(mp, lo, hi));
+               mp->msgstats = mh_xrealloc(mp->msgstats, MSGSTATSIZE(mp, lo, hi));
        } else {
                /*
                ** We are changing the offset of the message status
@@ -53,7 +53,7 @@ folder_realloc (struct msgs *mp, int lo, int hi)
                seqset_t *tmpstats;
 
                /* first allocate the new message status space */
-               tmpstats = mh_xmalloc (MSGSTATSIZE(mp, lo, hi));
+               tmpstats = mh_xmalloc(MSGSTATSIZE(mp, lo, hi));
 
                /* then copy messages status array with shift */
                if (mp->nummsg > 0) {
@@ -73,13 +73,13 @@ folder_realloc (struct msgs *mp, int lo, int hi)
        */
        if (mp->nummsg > 0) {
                for (msgnum = mp->lowoff; msgnum < mp->lowmsg; msgnum++)
-                       clear_msg_flags (mp, msgnum);
+                       clear_msg_flags(mp, msgnum);
                for (msgnum = mp->hghmsg + 1; msgnum <= mp->hghoff; msgnum++)
-                       clear_msg_flags (mp, msgnum);
+                       clear_msg_flags(mp, msgnum);
        } else {
                /* no messages, so clear entire range */
                for (msgnum = mp->lowoff; msgnum <= mp->hghoff; msgnum++)
-                       clear_msg_flags (mp, msgnum);
+                       clear_msg_flags(mp, msgnum);
        }
 
        return mp;
index 27d91cd..2b9a015 100644 (file)
@@ -10,7 +10,7 @@
 
 
 int
-gans (char *prompt, struct swit *ansp)
+gans(char *prompt, struct swit *ansp)
 {
        register int i;
        register char *cp;
@@ -18,10 +18,10 @@ gans (char *prompt, struct swit *ansp)
        char ansbuf[BUFSIZ];
 
        for (;;) {
-               printf ("%s", prompt);
-               fflush (stdout);
+               printf("%s", prompt);
+               fflush(stdout);
                cp = ansbuf;
-               while ((i = getchar ()) != '\n') {
+               while ((i = getchar()) != '\n') {
                        if (i == EOF)
                                return 0;
                        if (cp < &ansbuf[sizeof ansbuf - 1]) {
@@ -36,13 +36,13 @@ gans (char *prompt, struct swit *ansp)
                }
                *cp = '\0';
                if (ansbuf[0] == '?' || cp == ansbuf) {
-                       printf ("Options are:\n");
+                       printf("Options are:\n");
                        for (ap = ansp; ap->sw; ap++)
-                               printf ("  %s\n", ap->sw);
+                               printf("  %s\n", ap->sw);
                        continue;
                }
-               if ((i = smatch (ansbuf, ansp)) < 0) {
-                       printf ("%s: %s.\n", ansbuf, i == -1 ? "unknown" : "ambiguous");
+               if ((i = smatch(ansbuf, ansp)) < 0) {
+                       printf("%s: %s.\n", ansbuf, i == -1 ? "unknown" : "ambiguous");
                        continue;
                }
                return i;
index 3e38d87..919fd32 100644 (file)
@@ -17,49 +17,49 @@ static jmp_buf sigenv;
 /*
 ** static prototypes
 */
-static RETSIGTYPE intrser (int);
+static RETSIGTYPE intrser(int);
 
 
 char **
-getans (char *prompt, struct swit *ansp)
+getans(char *prompt, struct swit *ansp)
 {
        int i;
        SIGNAL_HANDLER istat = NULL;
        char *cp, **cpp;
 
-       if (!(setjmp (sigenv))) {
-               istat = SIGNAL (SIGINT, intrser);
+       if (!(setjmp(sigenv))) {
+               istat = SIGNAL(SIGINT, intrser);
        } else {
-               SIGNAL (SIGINT, istat);
+               SIGNAL(SIGINT, istat);
                return NULL;
        }
 
        for (;;) {
-               printf ("%s", prompt);
-               fflush (stdout);
+               printf("%s", prompt);
+               fflush(stdout);
                cp = ansbuf;
-               while ((i = getchar ()) != '\n') {
+               while ((i = getchar()) != '\n') {
                        if (i == EOF)
-                               longjmp (sigenv, 1);
+                               longjmp(sigenv, 1);
                        if (cp < &ansbuf[sizeof ansbuf - 1])
                                *cp++ = i;
                }
                *cp = '\0';
                if (ansbuf[0] == '?' || cp == ansbuf) {
-                       printf ("Options are:\n");
-                       print_sw (ALL, ansp, "", stdout);
+                       printf("Options are:\n");
+                       print_sw(ALL, ansp, "", stdout);
                        continue;
                }
-               cpp = brkstring (ansbuf, " ", NULL);
-               switch (smatch (*cpp, ansp)) {
+               cpp = brkstring(ansbuf, " ", NULL);
+               switch (smatch(*cpp, ansp)) {
                        case AMBIGSW:
-                               ambigsw (*cpp, ansp);
+                               ambigsw(*cpp, ansp);
                                continue;
                        case UNKWNSW:
-                               printf (" -%s unknown. Hit <CR> for help.\n", *cpp);
+                               printf(" -%s unknown. Hit <CR> for help.\n", *cpp);
                                continue;
                        default:
-                               SIGNAL (SIGINT, istat);
+                               SIGNAL(SIGINT, istat);
                                return cpp;
                }
        }
@@ -67,10 +67,10 @@ getans (char *prompt, struct swit *ansp)
 
 
 static RETSIGTYPE
-intrser (int i)
+intrser(int i)
 {
        /*
        ** should this be siglongjmp?
        */
-       longjmp (sigenv, 1);
+       longjmp(sigenv, 1);
 }
index 4707255..9bac0e5 100644 (file)
 
 
 int
-getanswer (char *prompt)
+getanswer(char *prompt)
 {
        static int interactive = -1;
 
        if (interactive < 0)
-               interactive = isatty (fileno (stdin)) ? 1 : 0;
+               interactive = isatty(fileno(stdin)) ? 1 : 0;
 
-       return (interactive ? gans (prompt, anoyes) : 1);
+       return (interactive ? gans(prompt, anoyes) : 1);
 }
index 5dbdf56..ce33c2e 100644 (file)
@@ -10,7 +10,7 @@
 #include <h/utils.h>
 
 char **
-getarguments (char *invo_name, int argc, char **argv, int check_context)
+getarguments(char *invo_name, int argc, char **argv, int check_context)
 {
        char *cp = NULL, **ap = NULL, **bp = NULL, **arguments = NULL;
        int n = 0;
@@ -18,9 +18,9 @@ getarguments (char *invo_name, int argc, char **argv, int check_context)
        /*
        ** Check if profile/context specifies any arguments
        */
-       if (check_context && (cp = context_find (invo_name))) {
-               cp = getcpy (cp);  /* make copy */
-               ap = brkstring (cp, " ", "\n");  /* split string */
+       if (check_context && (cp = context_find(invo_name))) {
+               cp = getcpy(cp);  /* make copy */
+               ap = brkstring(cp, " ", "\n");  /* split string */
 
                /* Count number of arguments split */
                bp = ap;
@@ -28,7 +28,7 @@ getarguments (char *invo_name, int argc, char **argv, int check_context)
                        n++;
        }
 
-       arguments = (char **) mh_xmalloc ((argc + n) * sizeof(*arguments));
+       arguments = (char **) mh_xmalloc((argc + n) * sizeof(*arguments));
        bp = arguments;
 
        /* Copy any arguments from profile/context */
index b2891b8..478986a 100644 (file)
 
 
 char *
-getcpy (char *str)
+getcpy(char *str)
 {
        char *cp;
        size_t len;
 
        if (str) {
                len = strlen(str) + 1;
-               cp = mh_xmalloc (len);
-               memcpy (cp, str, len);
+               cp = mh_xmalloc(len);
+               memcpy(cp, str, len);
        } else {
-               cp = mh_xmalloc ((size_t) 1);
+               cp = mh_xmalloc((size_t) 1);
                *cp = '\0';
        }
        return cp;
index 02910c3..9a6b18b 100644 (file)
@@ -17,13 +17,13 @@ getfolder(int wantcurrent)
        /*
        ** If wantcurrent == 1, then try the current folder first
        */
-       if (wantcurrent && (folder = context_find (pfolder)) && *folder != '\0')
+       if (wantcurrent && (folder = context_find(pfolder)) && *folder != '\0')
                return folder;
 
        /*
        ** Else try the Inbox profile entry
        */
-       if ((folder = context_find (inbox)) && *folder != '\0')
+       if ((folder = context_find(inbox)) && *folder != '\0')
                return folder;
 
        /*
index d3d447e..34d743e 100644 (file)
@@ -98,19 +98,19 @@ static struct lock *l_top = NULL;
 ** static prototypes
 */
 #ifdef KERNEL_LOCKING
-static int lkopen_kernel (char *, int, mode_t);
+static int lkopen_kernel(char *, int, mode_t);
 #endif
 
 #ifdef DOT_LOCKING
-static int lkopen_dot (char *, int, mode_t);
-static void lockname (char *, struct lockinfo *, int);
-static void timerON (char *, int);
-static void timerOFF (int);
-static RETSIGTYPE alrmser (int);
+static int lkopen_dot(char *, int, mode_t);
+static void lockname(char *, struct lockinfo *, int);
+static void timerON(char *, int);
+static void timerOFF(int);
+static RETSIGTYPE alrmser(int);
 #endif
 
 #if !defined(HAVE_LIBLOCKFILE)
-static int lockit (struct lockinfo *);
+static int lockit(struct lockinfo *);
 #endif
 
 /*
@@ -119,7 +119,7 @@ static int lockit (struct lockinfo *);
 */
 
 int
-lkopen (char *file, int access, mode_t mode)
+lkopen(char *file, int access, mode_t mode)
 {
 #ifdef KERNEL_LOCKING
        return lkopen_kernel(file, access, mode);
@@ -137,7 +137,7 @@ lkopen (char *file, int access, mode_t mode)
 */
 
 int
-lkclose (int fd, char *file)
+lkclose(int fd, char *file)
 {
 #ifdef FCNTL_LOCKING
        struct flock buf;
@@ -159,26 +159,26 @@ lkclose (int fd, char *file)
 #endif
 
 #ifdef FLOCK_LOCKING
-       flock (fd, LOCK_UN);
+       flock(fd, LOCK_UN);
 #endif
 
 #ifdef LOCKF_LOCKING
        /* make sure we unlock the whole thing */
-       lseek (fd, (off_t) 0, SEEK_SET);
-       lockf (fd, F_ULOCK, 0L);
+       lseek(fd, (off_t) 0, SEEK_SET);
+       lockf(fd, F_ULOCK, 0L);
 #endif
 
 #ifdef DOT_LOCKING
-       lockname (file, &lkinfo, 0);  /* get name of lock file */
+       lockname(file, &lkinfo, 0);  /* get name of lock file */
 #if !defined(HAVE_LIBLOCKFILE)
-       unlink (lkinfo.curlock);  /* remove lock file */
+       unlink(lkinfo.curlock);  /* remove lock file */
 #else
        lockfile_remove(lkinfo.curlock);
 #endif /* HAVE_LIBLOCKFILE */
-       timerOFF (fd);  /* turn off lock timer   */
+       timerOFF(fd);  /* turn off lock timer   */
 #endif /* DOT_LOCKING */
 
-       return (close (fd));
+       return (close(fd));
 }
 
 
@@ -188,33 +188,33 @@ lkclose (int fd, char *file)
 */
 
 FILE *
-lkfopen (char *file, char *mode)
+lkfopen(char *file, char *mode)
 {
        int fd, access;
        FILE *fp;
 
-       if (strcmp (mode, "r") == 0)
+       if (strcmp(mode, "r") == 0)
                access = O_RDONLY;
-       else if (strcmp (mode, "r+") == 0)
+       else if (strcmp(mode, "r+") == 0)
                access = O_RDWR;
-       else if (strcmp (mode, "w") == 0)
+       else if (strcmp(mode, "w") == 0)
                access = O_WRONLY | O_CREAT | O_TRUNC;
-       else if (strcmp (mode, "w+") == 0)
+       else if (strcmp(mode, "w+") == 0)
                access = O_RDWR | O_CREAT | O_TRUNC;
-       else if (strcmp (mode, "a") == 0)
+       else if (strcmp(mode, "a") == 0)
                access = O_WRONLY | O_CREAT | O_APPEND;
-       else if (strcmp (mode, "a+") == 0)
+       else if (strcmp(mode, "a+") == 0)
                access = O_RDWR | O_CREAT | O_APPEND;
        else {
                errno = EINVAL;
                return NULL;
        }
 
-       if ((fd = lkopen (file, access, 0666)) == -1)
+       if ((fd = lkopen(file, access, 0666)) == -1)
                return NULL;
 
-       if ((fp = fdopen (fd, mode)) == NULL) {
-               close (fd);
+       if ((fp = fdopen(fd, mode)) == NULL) {
+               close(fd);
                return NULL;
        }
 
@@ -228,7 +228,7 @@ lkfopen (char *file, char *mode)
 */
 
 int
-lkfclose (FILE *fp, char *file)
+lkfclose(FILE *fp, char *file)
 {
 #ifdef FCNTL_LOCKING
        struct flock buf;
@@ -250,26 +250,26 @@ lkfclose (FILE *fp, char *file)
 #endif
 
 #ifdef FLOCK_LOCKING
-       flock (fileno(fp), LOCK_UN);
+       flock(fileno(fp), LOCK_UN);
 #endif
 
 #ifdef LOCKF_LOCKING
        /* make sure we unlock the whole thing */
-       fseek (fp, 0L, SEEK_SET);
-       lockf (fileno(fp), F_ULOCK, 0L);
+       fseek(fp, 0L, SEEK_SET);
+       lockf(fileno(fp), F_ULOCK, 0L);
 #endif
 
 #ifdef DOT_LOCKING
-       lockname (file, &lkinfo, 0);  /* get name of lock file */
+       lockname(file, &lkinfo, 0);  /* get name of lock file */
 #if !defined(HAVE_LIBLOCKFILE)
-       unlink (lkinfo.curlock);  /* remove lock file */
+       unlink(lkinfo.curlock);  /* remove lock file */
 #else
        lockfile_remove(lkinfo.curlock);
 #endif /* HAVE_LIBLOCKFILE */
-       timerOFF (fileno(fp));  /* turn off lock timer   */
+       timerOFF(fileno(fp));  /* turn off lock timer   */
 #endif /* DOT_LOCKING */
 
-       return (fclose (fp));
+       return (fclose(fp));
 }
 
 
@@ -280,7 +280,7 @@ lkfclose (FILE *fp, char *file)
 */
 
 static int
-lkopen_kernel (char *file, int access, mode_t mode)
+lkopen_kernel(char *file, int access, mode_t mode)
 {
        int fd, i, j;
 
@@ -307,7 +307,7 @@ lkopen_kernel (char *file, int access, mode_t mode)
                }
 # endif /* LOCKF_LOCKING || FCNTL_LOCKING */
 
-               if ((fd = open (file, access | O_NDELAY, mode)) == -1)
+               if ((fd = open(file, access | O_NDELAY, mode)) == -1)
                        return -1;
 
 # ifdef FCNTL_LOCKING
@@ -315,31 +315,31 @@ lkopen_kernel (char *file, int access, mode_t mode)
                buf.l_whence = SEEK_SET;
                buf.l_start  = 0;
                buf.l_len = 0;
-               if (fcntl (fd, F_SETLK, &buf) != -1)
+               if (fcntl(fd, F_SETLK, &buf) != -1)
                        return fd;
 # endif
 
 # ifdef FLOCK_LOCKING
-               if (flock (fd, (((access & 03) == O_RDONLY) ? LOCK_SH :
+               if (flock(fd, (((access & 03) == O_RDONLY) ? LOCK_SH :
                        LOCK_EX) | LOCK_NB) != -1)
                        return fd;
 # endif
 
 # ifdef LOCKF_LOCKING
-               if (lockf (fd, F_TLOCK, 0L) != -1) {
+               if (lockf(fd, F_TLOCK, 0L) != -1) {
                        /* see if we should be at the end */
                        if (j & O_APPEND)
-                               lseek (fd, (off_t) 0, SEEK_END);
+                               lseek(fd, (off_t) 0, SEEK_END);
                        return fd;
                }
 # endif
 
                j = errno;
-               close (fd);
-               sleep (5);
+               close(fd);
+               sleep(5);
        }
 
-       close (fd);
+       close(fd);
        errno = j;
        return -1;
 }
@@ -354,29 +354,29 @@ lkopen_kernel (char *file, int access, mode_t mode)
 */
 
 static int
-lkopen_dot (char *file, int access, mode_t mode)
+lkopen_dot(char *file, int access, mode_t mode)
 {
        int fd;
        struct lockinfo lkinfo;
 
        /* open the file */
-       if ((fd = open (file, access, mode)) == -1)
+       if ((fd = open(file, access, mode)) == -1)
                return -1;
 
        /*
        ** Get the name of the eventual lock file, as well
        ** as a name for a temporary lock file.
        */
-       lockname (file, &lkinfo, 1);
+       lockname(file, &lkinfo, 1);
 
 #if !defined(HAVE_LIBLOCKFILE)
        {
                int i;
                for (i = 0;;) {
                        /* attempt to create lock file */
-                       if (lockit (&lkinfo) == 0) {
+                       if (lockit(&lkinfo) == 0) {
                                /* if successful, turn on timer and return */
-                               timerON (lkinfo.curlock, fd);
+                               timerON(lkinfo.curlock, fd);
                                return fd;
                        } else {
                                /*
@@ -385,25 +385,25 @@ lkopen_dot (char *file, int access, mode_t mode)
                                ** lock file.
                                */
                                struct stat st;
-                               if (stat (lkinfo.curlock, &st) == -1) {
+                               if (stat(lkinfo.curlock, &st) == -1) {
                                        if (i++ > 5)
                                                return -1;
-                                       sleep (5);
+                                       sleep(5);
                                } else {
                                        time_t curtime;
                                        i = 0;
-                                       time (&curtime);
+                                       time(&curtime);
 
                                        /*
                                        ** check for stale lockfile,
                                        ** else sleep
                                        */
                                        if (curtime > st.st_ctime + RSECS)
-                                               unlink (lkinfo.curlock);
+                                               unlink(lkinfo.curlock);
                                        else
-                                               sleep (5);
+                                               sleep(5);
                                }
-                               lockname (file, &lkinfo, 1);
+                               lockname(file, &lkinfo, 1);
                        }
                }
        }
@@ -425,7 +425,7 @@ lkopen_dot (char *file, int access, mode_t mode)
 */
 
 static int
-lockit (struct lockinfo *li)
+lockit(struct lockinfo *li)
 {
        int fd;
        char *curlock, *tmplock;
@@ -452,11 +452,11 @@ lockit (struct lockinfo *li)
 
 #if 0
        /* write our process id into lock file */
-       snprintf (buffer, sizeof(buffer), "nmh lock: pid %d\n", (int) getpid());
+       snprintf(buffer, sizeof(buffer), "nmh lock: pid %d\n", (int) getpid());
        write(fd, buffer, strlen(buffer) + 1);
 #endif
 
-       close (fd);
+       close(fd);
 
        /*
        ** Now try to create the real lock file
@@ -474,7 +474,7 @@ lockit (struct lockinfo *li)
 */
 
 static void
-lockname (char *file, struct lockinfo *li, int isnewlock)
+lockname(char *file, struct lockinfo *li, int isnewlock)
 {
        int bplen, tmplen;
        char *bp, *cp;
@@ -483,20 +483,20 @@ lockname (char *file, struct lockinfo *li, int isnewlock)
        struct stat st;
 #endif
 
-       if ((cp = strrchr (file, '/')) == NULL || *++cp == 0)
+       if ((cp = strrchr(file, '/')) == NULL || *++cp == 0)
                cp = file;
 
        bp = li->curlock;
        bplen = 0;
 #ifdef LOCKDIR
-       snprintf (bp, sizeof(li->curlock), "%s/", lockdir);
-       tmplen = strlen (bp);
+       snprintf(bp, sizeof(li->curlock), "%s/", lockdir);
+       tmplen = strlen(bp);
        bp += tmplen;
        bplen += tmplen;
 #else
        if (cp != file) {
-               snprintf (bp, sizeof(li->curlock), "%.*s", (int)(cp - file), file);
-               tmplen = strlen (bp);
+               snprintf(bp, sizeof(li->curlock), "%.*s", (int)(cp - file), file);
+               tmplen = strlen(bp);
                bp += tmplen;
                bplen += tmplen;
        }
@@ -508,14 +508,14 @@ lockname (char *file, struct lockinfo *li, int isnewlock)
        ** If we start supporting mmdf style dot locking,
        ** we will need to change the return value of lockname
        */
-       if (stat (file, &st) == -1)
+       if (stat(file, &st) == -1)
                return -1;
 
-       snprintf (bp, sizeof(li->curlock) - bplen, "LCK%05d.%05d",
+       snprintf(bp, sizeof(li->curlock) - bplen, "LCK%05d.%05d",
                st.st_dev, st.st_ino);
 #endif
 
-       snprintf (bp, sizeof(li->curlock) - bplen, "%s.lock", cp);
+       snprintf(bp, sizeof(li->curlock) - bplen, "%s.lock", cp);
 
 #if !defined(HAVE_LIBLOCKFILE)
        /*
@@ -523,11 +523,12 @@ lockname (char *file, struct lockinfo *li, int isnewlock)
        ** the temporary lock file for lockit()
        */
        if (isnewlock) {
-               if ((cp = strrchr (li->curlock, '/')) == NULL || *++cp == 0)
-                       strncpy (li->tmplock, ",LCK.XXXXXX", sizeof(li->tmplock));
+               if ((cp = strrchr(li->curlock, '/')) == NULL || *++cp == 0)
+                       strncpy(li->tmplock, ",LCK.XXXXXX", sizeof(li->tmplock));
                else
-                       snprintf (li->tmplock, sizeof(li->tmplock), "%.*s,LCK.XXXXXX",
-                                (int)(cp - li->curlock), li->curlock);
+                       snprintf(li->tmplock, sizeof(li->tmplock),
+                                       "%.*s,LCK.XXXXXX",
+                                       (int)(cp - li->curlock), li->curlock);
        }
 #endif
 }
@@ -539,23 +540,23 @@ lockname (char *file, struct lockinfo *li, int isnewlock)
 */
 
 static void
-timerON (char *curlock, int fd)
+timerON(char *curlock, int fd)
 {
        struct lock *lp;
        size_t len;
 
-       lp = (struct lock *) mh_xmalloc (sizeof(*lp));
+       lp = (struct lock *) mh_xmalloc(sizeof(*lp));
 
        len = strlen(curlock) + 1;
        lp->l_fd = fd;
-       lp->l_lock = mh_xmalloc (len);
-       memcpy (lp->l_lock, curlock, len);
+       lp->l_lock = mh_xmalloc(len);
+       memcpy(lp->l_lock, curlock, len);
        lp->l_next = l_top;
 
        if (!l_top) {
                /* perhaps SIGT{STP,TIN,TOU} ? */
-               SIGNAL (SIGALRM, alrmser);
-               alarm (NSECS);
+               SIGNAL(SIGALRM, alrmser);
+               alarm(NSECS);
        }
 
        l_top = lp;
@@ -568,7 +569,7 @@ timerON (char *curlock, int fd)
 */
 
 static void
-timerOFF (int fd)
+timerOFF(int fd)
 {
        struct lock *pp, *lp;
 
@@ -585,14 +586,14 @@ timerOFF (int fd)
                        else
                                pp->l_next = lp->l_next;
 
-                       free (lp->l_lock);
-                       free (lp);
+                       free(lp->l_lock);
+                       free(lp);
                }
        }
 
        /* if there are locks left, restart timer */
        if (l_top)
-               alarm (NSECS);
+               alarm(NSECS);
 }
 
 
@@ -602,13 +603,13 @@ timerOFF (int fd)
 */
 
 static RETSIGTYPE
-alrmser (int sig)
+alrmser(int sig)
 {
        char *lockfile;
        struct lock *lp;
 
 #ifndef RELIABLE_SIGNALS
-       SIGNAL (SIGALRM, alrmser);
+       SIGNAL(SIGALRM, alrmser);
 #endif
 
        /* update the ctime of all the lock files */
@@ -617,8 +618,8 @@ alrmser (int sig)
 #if !defined(HAVE_LIBLOCKFILE)
                {
                        int j;
-                       if (*lockfile && (j = creat (lockfile, 0600)) != -1)
-                               close (j);
+                       if (*lockfile && (j = creat(lockfile, 0600)) != -1)
+                               close(j);
                }
 #else
        lockfile_touch(lockfile);
@@ -626,7 +627,7 @@ alrmser (int sig)
        }
 
        /* restart the alarm */
-       alarm (NSECS);
+       alarm(NSECS);
 }
 
 #endif /* DOT_LOCKING */
index 0222533..03bf0d0 100644 (file)
@@ -12,7 +12,7 @@
 
 
 int
-m_atoi (char *str)
+m_atoi(char *str)
 {
        int i;
        unsigned char *cp;
index e8c5566..17f7ad5 100644 (file)
@@ -10,7 +10,7 @@
 
 
 char *
-m_backup (char *file)
+m_backup(char *file)
 {
        char *cp;
        static char buffer[BUFSIZ];
index cd18406..89da537 100644 (file)
@@ -29,19 +29,19 @@ static char *delimp;
 /*
 ** static prototypes
 */
-static int m_conv (struct msgs *, char *, int);
-static int attr (struct msgs *, char *);
+static int m_conv(struct msgs *, char *, int);
+static int attr(struct msgs *, char *);
 
 
 int
-m_convert (struct msgs *mp, char *name)
+m_convert(struct msgs *mp, char *name)
 {
        int first, last, found, range, err;
        unsigned char *bp;
        char *cp;
 
        /* check if user defined sequence */
-       err = attr (mp, cp = name);
+       err = attr(mp, cp = name);
 
        if (err == -1)
                return 0;
@@ -59,57 +59,57 @@ m_convert (struct msgs *mp, char *name)
        ** Check for special "new" sequence, which
        ** is valid only if ALLOW_NEW is set.
        */
-       if ((mp->msgflags & ALLOW_NEW) && !strcmp (cp, "new")) {
-               if ((err = first = getnew (mp)) <= 0)
+       if ((mp->msgflags & ALLOW_NEW) && !strcmp(cp, "new")) {
+               if ((err = first = getnew(mp)) <= 0)
                        goto badmsg;
                else
                        goto single;
        }
 
-       if (!strcmp (cp, "all"))
+       if (!strcmp(cp, "all"))
                cp = "first-last";
 
-       if ((err = first = m_conv (mp, cp, FIRST)) <= 0)
+       if ((err = first = m_conv(mp, cp, FIRST)) <= 0)
                goto badmsg;
 
        cp = delimp;
        if (*cp != '\0' && *cp != '-' && *cp != ':') {
 badelim:
-               advise (NULL, "illegal argument delimiter: `%c'(0%o)",
+               advise(NULL, "illegal argument delimiter: `%c'(0%o)",
                                *delimp, *delimp);
                return 0;
        }
 
        if (*cp == '-') {
                cp++;
-               if ((err = last = m_conv (mp, cp, LAST)) <= 0) {
+               if ((err = last = m_conv(mp, cp, LAST)) <= 0) {
 badmsg:
                        switch (err) {
                        case BADMSG:
-                               advise (NULL, "no %s message", cp);
+                               advise(NULL, "no %s message", cp);
                                break;
 
                        case BADNUM:
-                               advise (NULL, "message %s doesn't exist", cp);
+                               advise(NULL, "message %s doesn't exist", cp);
                                break;
 
                        case BADRNG:
-                               advise (NULL, "message %s out of range 1-%d",
+                               advise(NULL, "message %s out of range 1-%d",
                                                cp, mp->hghmsg);
                                break;
 
                        case BADLST:
 badlist:
-                               advise (NULL, "bad message list %s", name);
+                               advise(NULL, "bad message list %s", name);
                                break;
 
                        case BADNEW:
-                               advise (NULL, "folder full, no %s message",
+                               advise(NULL, "folder full, no %s message",
                                                name);
                                break;
 
                        default:
-                               advise (NULL, "no messages match specification");
+                               advise(NULL, "no messages match specification");
                        }
                        return 0;
                }
@@ -120,7 +120,7 @@ badlist:
                        goto badelim;
                if (first > mp->hghmsg || last < mp->lowmsg) {
 rangerr:
-                       advise (NULL, "no messages in range %s", name);
+                       advise(NULL, "no messages in range %s", name);
                        return 0;
                }
 
@@ -139,9 +139,9 @@ rangerr:
                        convdir = 1;
                        cp++;
                }
-               if ((range = atoi (bp = cp)) == 0)
+               if ((range = atoi(bp = cp)) == 0)
                        goto badlist;
-               while (isdigit (*bp))
+               while (isdigit(*bp))
                        bp++;
                if (*bp)
                        goto badelim;
@@ -157,7 +157,7 @@ rangerr:
 
                for (last = first; last >= mp->lowmsg && last <= mp->hghmsg;
                        last += convdir)
-                       if (does_exist (mp, last))
+                       if (does_exist(mp, last))
                                if (--range <= 0)
                                        break;
                if (last < mp->lowmsg)
@@ -180,15 +180,15 @@ single:
                ** check if message is in-range and exists.
                */
                if (mp->msgflags & ALLOW_NEW) {
-                       set_select_empty (mp, first);
+                       set_select_empty(mp, first);
                } else {
                        if (first > mp->hghmsg
                                || first < mp->lowmsg
-                               || !(does_exist (mp, first))) {
-                               if (!strcmp (name, "cur") || !strcmp (name, "."))
-                                       advise (NULL, "no %s message", name);
+                               || !(does_exist(mp, first))) {
+                               if (!strcmp(name, "cur") || !strcmp(name, "."))
+                                       advise(NULL, "no %s message", name);
                                else
-                                       advise (NULL, "message %d doesn't exist", first);
+                                       advise(NULL, "message %d doesn't exist", first);
                                return 0;
                        }
                }
@@ -201,10 +201,10 @@ single:
        ** if we are selecting an empty slot.
        */
        for (; first <= last; first++) {
-               if (does_exist (mp, first) ||
-                       ((mp->msgflags & ALLOW_NEW) && is_select_empty (mp, first))) {
-                       if (!is_selected (mp, first)) {
-                               set_selected (mp, first);
+               if (does_exist(mp, first) ||
+                       ((mp->msgflags & ALLOW_NEW) && is_select_empty(mp, first))) {
+                       if (!is_selected(mp, first)) {
+                               set_selected(mp, first);
                                mp->numsel++;
                                if (mp->lowsel == 0 || first < mp->lowsel)
                                        mp->lowsel = first;
@@ -235,7 +235,7 @@ single:
 */
 
 static int
-m_conv (struct msgs *mp, char *str, int call)
+m_conv(struct msgs *mp, char *str, int call)
 {
        register int i;
        register unsigned char *cp, *bp;
@@ -243,11 +243,11 @@ m_conv (struct msgs *mp, char *str, int call)
 
        convdir = 1;
        cp = bp = str;
-       if (isdigit (*cp)) {
-               while (isdigit (*bp))
+       if (isdigit(*cp)) {
+               while (isdigit(*bp))
                        bp++;
                delimp = bp;
-               i = atoi (cp);
+               i = atoi(cp);
 
                if (i <= mp->hghmsg)
                        return i;
@@ -273,32 +273,32 @@ m_conv (struct msgs *mp, char *str, int call)
        *bp++ = '\0';
        delimp = cp;
 
-       if (!strcmp (buf, "first"))
+       if (!strcmp(buf, "first"))
                return (mp->hghmsg || !(mp->msgflags & ALLOW_NEW)
                                ? mp->lowmsg : BADMSG);
 
-       if (!strcmp (buf, "last")) {
+       if (!strcmp(buf, "last")) {
                convdir = -1;
                return (mp->hghmsg || !(mp->msgflags & ALLOW_NEW) ? mp->hghmsg : BADMSG);
        }
 
-       if (!strcmp (buf, "cur") || !strcmp (buf, "."))
+       if (!strcmp(buf, "cur") || !strcmp(buf, "."))
                return (mp->curmsg > 0 ? mp->curmsg : BADMSG);
 
-       if (!strcmp (buf, "prev")) {
+       if (!strcmp(buf, "prev")) {
                convdir = -1;
                for (i = (mp->curmsg <= mp->hghmsg) ? mp->curmsg - 1 : mp->hghmsg;
                        i >= mp->lowmsg; i--) {
-                       if (does_exist (mp, i))
+                       if (does_exist(mp, i))
                                return i;
                }
                return BADMSG;
        }
 
-       if (!strcmp (buf, "next")) {
+       if (!strcmp(buf, "next")) {
                for (i = (mp->curmsg >= mp->lowmsg) ? mp->curmsg + 1 : mp->lowmsg;
                        i <= mp->hghmsg; i++) {
-                       if (does_exist (mp, i))
+                       if (does_exist(mp, i))
                                return i;
                }
                return BADMSG;
@@ -322,7 +322,7 @@ m_conv (struct msgs *mp, char *str, int call)
 */
 
 static int
-attr (struct msgs *mp, char *cp)
+attr(struct msgs *mp, char *cp)
 {
        register unsigned char *dp;
        char *bp = NULL;
@@ -333,15 +333,15 @@ attr (struct msgs *mp, char *cp)
        int first = 0;
 
        /* hack for "cur-name", "cur-n", etc. */
-       if (!strcmp (cp, "cur"))
+       if (!strcmp(cp, "cur"))
                return 0;
-       if (ssequal ("cur:", cp))  /* this code need to be rewritten... */
+       if (ssequal("cur:", cp))  /* this code need to be rewritten... */
                return 0;
 
        /* Check for sequence negation */
-       if ((dp = context_find (nsequence)) && *dp != '\0' && ssequal (dp, cp)) {
+       if ((dp = context_find(nsequence)) && *dp != '\0' && ssequal(dp, cp)) {
                inverted = 1;
-               cp += strlen (dp);
+               cp += strlen(dp);
        }
 
        convdir = 1;  /* convert direction */
@@ -359,18 +359,18 @@ attr (struct msgs *mp, char *cp)
                ** seq:first (or)
                ** seq:last
                */
-               if (isalpha (*dp)) {
-                       if (!strcmp (dp, "prev")) {
+               if (isalpha(*dp)) {
+                       if (!strcmp(dp, "prev")) {
                                convdir = -1;
                                first = (mp->curmsg > 0) && (mp->curmsg <= mp->hghmsg)
                                        ? mp->curmsg - 1 : mp->hghmsg;
-                       } else if (!strcmp (dp, "next")) {
+                       } else if (!strcmp(dp, "next")) {
                                convdir = 1;
                                first = (mp->curmsg >= mp->lowmsg)
                                        ? mp->curmsg + 1 : mp->lowmsg;
-                       } else if (!strcmp (dp, "first")) {
+                       } else if (!strcmp(dp, "first")) {
                                convdir = 1;
-                       } else if (!strcmp (dp, "last")) {
+                       } else if (!strcmp(dp, "last")) {
                                convdir = -1;
                        } else
                                return BADLST;
@@ -388,7 +388,7 @@ attr (struct msgs *mp, char *cp)
                        }
                        if ((range = atoi(dp)) == 0)
                                return BADLST;
-                       while (isdigit (*dp))
+                       while (isdigit(*dp))
                                dp++;
                        if (*dp)
                                return BADLST;
@@ -397,7 +397,7 @@ attr (struct msgs *mp, char *cp)
                *bp = '\0';  /* temporarily terminate sequence name */
        }
 
-       i = seq_getnum (mp, cp);  /* get index of sequence */
+       i = seq_getnum(mp, cp);  /* get index of sequence */
 
        if (bp)
                *bp = ':';  /* restore sequence name */
@@ -408,10 +408,10 @@ attr (struct msgs *mp, char *cp)
 
        for (j = first ? first : (convdir > 0) ? mp->lowmsg : mp->hghmsg;
                j >= mp->lowmsg && j <= mp->hghmsg; j += convdir) {
-               if (does_exist (mp, j)
-                       && inverted ? !in_sequence (mp, i, j) : in_sequence (mp, i, j)) {
-                       if (!is_selected (mp, j)) {
-                               set_selected (mp, j);
+               if (does_exist(mp, j)
+                       && inverted ? !in_sequence(mp, i, j) : in_sequence(mp, i, j)) {
+                       if (!is_selected(mp, j)) {
+                               set_selected(mp, j);
                                mp->numsel++;
                                if (mp->lowsel == 0 || j < mp->lowsel)
                                        mp->lowsel = j;
@@ -434,6 +434,6 @@ attr (struct msgs *mp, char *cp)
 
        if (first)
                return BADMSG;
-       advise (NULL, "sequence %s %s", cp, inverted ? "full" : "empty");
+       advise(NULL, "sequence %s %s", cp, inverted ? "full" : "empty");
        return -1;
 }
index 845fb96..3920315 100644 (file)
@@ -24,19 +24,19 @@ m_draft(char *which)
        char *folder;
 
        cp = draftfolder;
-       folder = path (*cp == '+' || *cp == '@' ? cp + 1 : cp,
+       folder = path(*cp == '+' || *cp == '@' ? cp + 1 : cp,
                        *cp != '@' ? TFOLDER : TSUBCWF);
 
-       chdir (m_maildir (""));
-       strncpy (buffer, m_maildir (folder), sizeof(buffer));
+       chdir(m_maildir(""));
+       strncpy(buffer, m_maildir(folder), sizeof(buffer));
 
-       create_folder (buffer, 0, done);
+       create_folder(buffer, 0, done);
 
-       if (chdir (buffer) == -1)
-               adios (buffer, "unable to change directory to");
+       if (chdir(buffer) == -1)
+               adios(buffer, "unable to change directory to");
 
-       if (!(mp = folder_read (folder)))
-               adios (NULL, "unable to read folder %s", folder);
+       if (!(mp = folder_read(folder)))
+               adios(NULL, "unable to read folder %s", folder);
 
        /*
        ** Make sure we have enough message status space for all
@@ -45,11 +45,11 @@ m_draft(char *which)
        ** end, go ahead and add 10 additional slots.
        */
        if (mp->hghmsg >= mp->hghoff) {
-               if (!(mp = folder_realloc (mp, 1, mp->hghmsg + 10)))
-                       adios (NULL, "unable to allocate folder storage");
+               if (!(mp = folder_realloc(mp, 1, mp->hghmsg + 10)))
+                       adios(NULL, "unable to allocate folder storage");
        } else if (mp->lowoff > 1) {
-               if (!(mp = folder_realloc (mp, 1, mp->hghoff)))
-                       adios (NULL, "unable to allocate folder storage");
+               if (!(mp = folder_realloc(mp, 1, mp->hghoff)))
+                       adios(NULL, "unable to allocate folder storage");
        }
 
        mp->msgflags |= ALLOW_NEW;  /* allow the "new" sequence */
@@ -59,15 +59,15 @@ m_draft(char *which)
        ** Usually it is "cur" (for the current draft) or "new"
        ** (to start a new draft).
        */
-       if (!m_convert (mp, which))
-               done (1);
-       seq_setprev (mp);
+       if (!m_convert(mp, which))
+               done(1);
+       seq_setprev(mp);
 
-       snprintf (buffer, sizeof(buffer), "%s/%s", mp->foldpath,
-                       m_name (mp->lowsel));
-       seq_setcur (mp, mp->lowsel);
-       seq_save (mp);
-       folder_free (mp);
+       snprintf(buffer, sizeof(buffer), "%s/%s", mp->foldpath,
+                       m_name(mp->lowsel));
+       seq_setcur(mp, mp->lowsel);
+       seq_save(mp);
+       folder_free(mp);
 
        return buffer;
 }
index 1ce52b6..26707a2 100644 (file)
@@ -42,7 +42,7 @@
 ** This worked fine, until one day: a message with no body portion arrived.
 ** Then the
 **
-**                 while (eom (c = Getc (iob), iob))
+**                 while (eom(c = Getc(iob), iob))
 **                      continue;
 **
 ** loop caused m_getfld() to return FMTERR.  So, that logic was changed to
 /*
 ** static prototypes
 */
-static int m_Eom (int, FILE *);
+static int m_Eom(int, FILE *);
 static unsigned char *matchc(int, char *, int, char *);
 static unsigned char *locc(int, unsigned char *, unsigned char);
 
@@ -207,7 +207,7 @@ extern int  _filbuf(FILE*);
 
 
 int
-m_getfld (int state, unsigned char *name, unsigned char *buf,
+m_getfld(int state, unsigned char *name, unsigned char *buf,
        int bufsz, FILE *iob)
 {
        register unsigned char  *bp, *cp, *ep, *sp;
@@ -218,10 +218,10 @@ m_getfld (int state, unsigned char *name, unsigned char *buf,
                *buf = 0;
                return FILEEOF;
        }
-       if (eom (c, iob)) {
+       if (eom(c, iob)) {
                if (! eom_action) {
                        /* flush null messages */
-                       while ((c = Getc(iob)) >= 0 && eom (c, iob))
+                       while ((c = Getc(iob)) >= 0 && eom(c, iob))
                                ;
                        if (c >= 0)
                                ungetc(c, iob);
@@ -240,10 +240,10 @@ m_getfld (int state, unsigned char *name, unsigned char *buf,
                                while (c != '\n' && (c = Getc(iob)) >= 0)
                                        ;
 
-                               if (c < 0 || (c = Getc(iob)) < 0 || eom (c, iob)) {
+                               if (c < 0 || (c = Getc(iob)) < 0 || eom(c, iob)) {
                                        if (! eom_action) {
                                                /* flush null messages */
-                                               while ((c = Getc(iob)) >= 0 && eom (c, iob))
+                                               while ((c = Getc(iob)) >= 0 && eom(c, iob))
                                                        ;
                                                if (c >= 0)
                                                        ungetc(c, iob);
@@ -288,7 +288,7 @@ m_getfld (int state, unsigned char *name, unsigned char *buf,
                                        if (_filbuf(iob) == EOF) {
 #endif
                                                *cp = *buf = 0;
-                                               advise (NULL, "eof encountered in field \"%s\"", name);
+                                               advise(NULL, "eof encountered in field \"%s\"", name);
                                                return FMTERR;
                                        }
 #ifdef LINUX_STDIO
@@ -339,11 +339,11 @@ m_getfld (int state, unsigned char *name, unsigned char *buf,
                                                ** guess we'll blow up.
                                                */
                                                *cp = *buf = 0;
-                                               advise (NULL, "eol encountered in field \"%s\"", name);
+                                               advise(NULL, "eol encountered in field \"%s\"", name);
                                                state = FMTERR;
                                                goto finish;
                                        }
-                                       memcpy (buf, name, j - 1);
+                                       memcpy(buf, name, j - 1);
                                        buf[j - 1] = '\n';
                                        buf[j] = '\0';
                                        /*
@@ -360,18 +360,18 @@ m_getfld (int state, unsigned char *name, unsigned char *buf,
                                        ** should be harmless enough, right?
                                        ** This is a corrupt message anyway.
                                        */
-                                       fseek (iob, ftell (iob) - 2, SEEK_SET);
+                                       fseek(iob, ftell(iob) - 2, SEEK_SET);
                                        return BODY;
                                }
                                if ((i -= j) <= 0) {
                                        *cp = *buf = 0;
-                                       advise (NULL, "field name \"%s\" exceeds %d bytes", name, NAMESZ - 2);
+                                       advise(NULL, "field name \"%s\" exceeds %d bytes", name, NAMESZ - 2);
                                        state = LENERR;
                                        goto finish;
                                }
                        }
 
-                       while (isspace (*--cp) && cp >= name)
+                       while (isspace(*--cp) && cp >= name)
                                ;
                        *++cp = 0;
                        /* fall through */
@@ -403,16 +403,16 @@ m_getfld (int state, unsigned char *name, unsigned char *buf,
                                        if ((j = *++ep) != ' ' && j != '\t') {
 #ifdef LINUX_STDIO
                                                j = ep - (unsigned char *) iob->_IO_read_ptr;
-                                               memcpy (cp, iob->_IO_read_ptr, j);
+                                               memcpy(cp, iob->_IO_read_ptr, j);
                                                iob->_IO_read_ptr = ep;
 #elif defined(__DragonFly__)
                                                j = ep - (unsigned char *) ((struct __FILE_public *)iob)->_p;
-                                               memcpy (cp, ((struct __FILE_public *)iob)->_p, j);
+                                               memcpy(cp, ((struct __FILE_public *)iob)->_p, j);
                                                ((struct __FILE_public *)iob)->_p = ep;
                                                ((struct __FILE_public *)iob)->_r -= j;
 #else
                                                j = ep - (unsigned char *) iob->_ptr;
-                                               memcpy (cp, iob->_ptr, j);
+                                               memcpy(cp, iob->_ptr, j);
                                                iob->_ptr = ep;
                                                iob->_cnt -= j;
 #endif
@@ -429,13 +429,13 @@ m_getfld (int state, unsigned char *name, unsigned char *buf,
                                */
 #ifdef LINUX_STDIO
                                c += bp - (unsigned char *) iob->_IO_read_ptr;
-                               memcpy( cp, iob->_IO_read_ptr, c);
+                               memcpy(cp, iob->_IO_read_ptr, c);
 #elif defined(__DragonFly__)
                                c += bp - (unsigned char *) ((struct __FILE_public *)iob)->_p;
-                               memcpy( cp, ((struct __FILE_public *)iob)->_p, c);
+                               memcpy(cp, ((struct __FILE_public *)iob)->_p, c);
 #else
                                c += bp - (unsigned char *) iob->_ptr;
-                               memcpy( cp, iob->_ptr, c);
+                               memcpy(cp, iob->_ptr, c);
 #endif
                                i -= c;
                                cp += c;
@@ -628,7 +628,7 @@ m_getfld (int state, unsigned char *name, unsigned char *buf,
                        break;
 
                default:
-                       adios (NULL, "m_getfld() called with bogus state of %d", state);
+                       adios(NULL, "m_getfld() called with bogus state of %d", state);
        }
 finish:
        *cp = 0;
@@ -665,29 +665,29 @@ m_unknown(FILE *iob)
 
        msg_style = MS_UNKNOWN;
 
-       pos = ftell (iob);
-       if (fread (text, sizeof(*text), 5, iob) == 5
-               && strncmp (text, "From ", 5) == 0) {
+       pos = ftell(iob);
+       if (fread(text, sizeof(*text), 5, iob) == 5
+               && strncmp(text, "From ", 5) == 0) {
                msg_style = MS_MBOX;
                delimstr = "\nFrom ";
 #ifndef RPATHS
-               while ((c = getc (iob)) != '\n' && c >= 0)
+               while ((c = getc(iob)) != '\n' && c >= 0)
                        ;
 #else /* RPATHS */
                cp = unixbuf;
-               while ((c = getc (iob)) != '\n' && cp - unixbuf < BUFSIZ - 1)
+               while ((c = getc(iob)) != '\n' && cp - unixbuf < BUFSIZ - 1)
                        *cp++ = c;
                *cp = 0;
 #endif /* RPATHS */
        } else {
                /* not a Unix style maildrop */
-               fseek (iob, pos, SEEK_SET);
+               fseek(iob, pos, SEEK_SET);
                if (mmdlm2 == NULL || *mmdlm2 == 0)
                        mmdlm2 = "\001\001\001\001\n";
                delimstr = mmdlm2;
                msg_style = MS_MMDF;
        }
-       c = strlen (delimstr);
+       c = strlen(delimstr);
        fdelim = (unsigned char *) mh_xmalloc((size_t) (c + 3));
        *fdelim++ = '\0';
        *fdelim = '\n';
@@ -695,24 +695,24 @@ m_unknown(FILE *iob)
        edelim = (unsigned char *)msg_delim+1;
        fdelimlen = c + 1;
        edelimlen = c - 1;
-       strcpy (msg_delim, delimstr);
+       strcpy(msg_delim, delimstr);
        delimend = (unsigned char *)msg_delim + edelimlen;
        if (edelimlen <= 1)
-               adios (NULL, "maildrop delimiter must be at least 2 bytes");
+               adios(NULL, "maildrop delimiter must be at least 2 bytes");
        /*
        ** build a Boyer-Moore end-position map for the matcher in m_getfld.
        ** N.B. - we don't match just the first char (since it's the newline
        ** separator) or the last char (since the matchc would have found it
        ** if it was a real delim).
        */
-       pat_map = (unsigned char **) calloc (256, sizeof(unsigned char *));
+       pat_map = (unsigned char **) calloc(256, sizeof(unsigned char *));
 
        for (cp = (char *) fdelim + 1; cp < (char *) delimend; cp++ )
                pat_map[(unsigned char)*cp] = (unsigned char *) cp;
 
        if (msg_style == MS_MMDF) {
                /* flush extra msg hdrs */
-               while ((c = Getc(iob)) >= 0 && eom (c, iob))
+               while ((c = Getc(iob)) >= 0 && eom(c, iob))
                        ;
                if (c >= 0)
                        ungetc(c, iob);
@@ -725,7 +725,7 @@ m_unknown(FILE *iob)
 */
 
 static int
-m_Eom (int c, FILE *iob)
+m_Eom(int c, FILE *iob)
 {
        register long pos = 0L;
        register int i;
@@ -734,9 +734,9 @@ m_Eom (int c, FILE *iob)
        register char *cp;
 #endif /* RPATHS */
 
-       pos = ftell (iob);
-       if ((i = fread (text, sizeof *text, edelimlen, iob)) != edelimlen
-               || strncmp (text, (char *)edelim, edelimlen)) {
+       pos = ftell(iob);
+       if ((i = fread(text, sizeof *text, edelimlen, iob)) != edelimlen
+               || strncmp(text, (char *)edelim, edelimlen)) {
                if (i == 0 && msg_style == MS_MBOX)
                        /*
                        ** the final newline in the (brain damaged) unix-format
@@ -745,22 +745,22 @@ m_Eom (int c, FILE *iob)
                        return 1;
 
 #if 0
-               fseek (iob, pos, SEEK_SET);
+               fseek(iob, pos, SEEK_SET);
 #endif
 
-               fseek (iob, (long)(pos-1), SEEK_SET);
-               getc (iob);  /* should be OK */
+               fseek(iob, (long)(pos-1), SEEK_SET);
+               getc(iob);  /* should be OK */
                return 0;
        }
 
        if (msg_style == MS_MBOX) {
 #ifndef RPATHS
-               while ((c = getc (iob)) != '\n')
+               while ((c = getc(iob)) != '\n')
                        if (c < 0)
                                break;
 #else /* RPATHS */
                cp = unixbuf;
-               while ((c = getc (iob)) != '\n' && c >= 0 && cp - unixbuf < BUFSIZ - 1)
+               while ((c = getc(iob)) != '\n' && c >= 0 && cp - unixbuf < BUFSIZ - 1)
                        *cp++ = c;
                *cp = 0;
 #endif /* RPATHS */
@@ -783,7 +783,7 @@ m_Eom (int c, FILE *iob)
 */
 
 int
-get_returnpath (char *rp, int rplen, char *dd, int ddlen)
+get_returnpath(char *rp, int rplen, char *dd, int ddlen)
 {
        char *ap, *bp, *cp, *dp;
 
@@ -796,8 +796,8 @@ get_returnpath (char *rp, int rplen, char *dd, int ddlen)
        ** if this message uses UUCP style addressing
        */
        while ((cp = strchr(++cp, 'r'))) {
-               if (strncmp (cp, "remote from", 11) == 0) {
-                       cp = strrchr (cp, ' ');
+               if (strncmp(cp, "remote from", 11) == 0) {
+                       cp = strrchr(cp, ' ');
                        break;
                }
        }
@@ -808,11 +808,11 @@ get_returnpath (char *rp, int rplen, char *dd, int ddlen)
        */
        if (cp) {
                /* return path for UUCP style addressing */
-               dp = strchr (++cp, '\n');
-               snprintf (rp, rplen, "%.*s!%.*s\n", (int)(dp - cp), cp, (int)(bp - ap), ap);
+               dp = strchr(++cp, '\n');
+               snprintf(rp, rplen, "%.*s!%.*s\n", (int)(dp - cp), cp, (int)(bp - ap), ap);
        } else {
                /* return path for standard domain addressing */
-               snprintf (rp, rplen, "%.*s\n", (int)(bp - ap), ap);
+               snprintf(rp, rplen, "%.*s\n", (int)(bp - ap), ap);
        }
 
        /*
@@ -823,7 +823,7 @@ get_returnpath (char *rp, int rplen, char *dd, int ddlen)
                bp++;
 
        /* Now get delivery date from envelope */
-       snprintf (dd, ddlen, "%.*s\n", 24, bp);
+       snprintf(dd, ddlen, "%.*s\n", 24, bp);
 
        unixbuf[0] = 0;
        return 1;
index 999e6f7..9c86e77 100644 (file)
@@ -10,9 +10,9 @@
 
 
 int
-m_gmprot (void)
+m_gmprot(void)
 {
        register char *cp;
 
-       return atooi ((cp = context_find ("msg-protect")) && *cp ? cp : msgprot);
+       return atooi ((cp = context_find("msg-protect")) && *cp ? cp : msgprot);
 }
index 1ba21c8..95f72af 100644 (file)
@@ -20,16 +20,16 @@ static char mailfold[BUFSIZ];
 /*
 ** static prototypes
 */
-static char *exmaildir (char *);
+static char *exmaildir(char *);
 
 
 char *
-m_maildir (char *folder)
+m_maildir(char *folder)
 {
        register char *cp, *ep;
 
-       if ((cp = exmaildir (folder))
-               && (ep = cp + strlen (cp) - 1) > cp
+       if ((cp = exmaildir(folder))
+               && (ep = cp + strlen(cp) - 1) > cp
                && *ep == '/')
                *ep = '\0';
 
@@ -38,21 +38,21 @@ m_maildir (char *folder)
 
 
 char *
-m_mailpath (char *folder)
+m_mailpath(char *folder)
 {
        register char *cp;
        char maildir[BUFSIZ];
 
        if (*folder != '/'
-               && strncmp (folder, CWD, NCWD)
-               && strcmp (folder, DOT)
-               && strcmp (folder, DOTDOT)
-               && strncmp (folder, PWD, NPWD)) {
-               strncpy (maildir, mailfold, sizeof(maildir));  /* preserve... */
-               cp = getcpy (m_maildir (folder));
-               strncpy (mailfold, maildir, sizeof(mailfold));
+               && strncmp(folder, CWD, NCWD)
+               && strcmp(folder, DOT)
+               && strcmp(folder, DOTDOT)
+               && strncmp(folder, PWD, NPWD)) {
+               strncpy(maildir, mailfold, sizeof(maildir));  /* preserve... */
+               cp = getcpy(m_maildir(folder));
+               strncpy(mailfold, maildir, sizeof(mailfold));
        } else {
-               cp = path (folder, TFOLDER);
+               cp = path(folder, TFOLDER);
        }
 
        return cp;
@@ -60,7 +60,7 @@ m_mailpath (char *folder)
 
 
 static char *
-exmaildir (char *folder)
+exmaildir(char *folder)
 {
        register char *cp, *pp;
 
@@ -68,28 +68,26 @@ exmaildir (char *folder)
        if (folder == NULL)
                folder = getfolder(1);
 
-       if (!(*folder != '/'
-               && strncmp (folder, CWD, NCWD)
-               && strcmp (folder, DOT)
-               && strcmp (folder, DOTDOT)
-               && strncmp (folder, PWD, NPWD))) {
-               strncpy (mailfold, folder, sizeof(mailfold));
+       if (!(*folder != '/' && strncmp(folder, CWD, NCWD)
+                       && strcmp(folder, DOT) && strcmp(folder, DOTDOT)
+                       && strncmp(folder, PWD, NPWD))) {
+               strncpy(mailfold, folder, sizeof(mailfold));
                return mailfold;
        }
 
        cp = mailfold;
-       if ((pp = context_find ("path")) && *pp) {
+       if ((pp = context_find("path")) && *pp) {
                if (*pp != '/') {
-                       sprintf (cp, "%s/", mypath);
-                       cp += strlen (cp);
+                       sprintf(cp, "%s/", mypath);
+                       cp += strlen(cp);
                }
-               cp = copy (pp, cp);
+               cp = copy(pp, cp);
        } else {
-               cp = copy (path ("./", TFOLDER), cp);
+               cp = copy(path("./", TFOLDER), cp);
        }
        if (cp[-1] != '/')
                *cp++ = '/';
-       strcpy (cp, folder);
+       strcpy(cp, folder);
 
        return mailfold;
 }
index 9b9652b..c0c1a9c 100644 (file)
@@ -41,7 +41,7 @@ static char *get_temp_dir();
 **    char *tmp_pathname = m_mktemp2(NULL, "mypre", ...);
 */
 char *
-m_mktemp (
+m_mktemp(
        const char *pfx_in,  /* Pathname prefix for temporary file. */
        int *fd_ret,         /* (return,opt.) File descriptor to temp file. */
        FILE **fp_ret        /* (return,opt.) FILE pointer to temp file. */
@@ -100,7 +100,7 @@ m_mktemp (
 ** above) is used to create the temp file.
 */
 char *
-m_mktemp2 (
+m_mktemp2(
        const char *dir_in,   /* Directory to place temp file. */
        const char *pfx_in,   /* Basename prefix for temp file. */
        int *fd_ret,          /* (return,opt.) File descriptor to temp file. */
@@ -119,7 +119,7 @@ m_mktemp2 (
                return m_mktemp(buffer, fd_ret, fp_ret);
        }
 
-       if ((cp = r1bindex ((char *)dir_in, '/')) == dir_in) {
+       if ((cp = r1bindex((char *)dir_in, '/')) == dir_in) {
                /* No directory component */
                return m_mktemp(pfx_in, fd_ret, fp_ret);
        }
index 20acffe..ef391e6 100644 (file)
@@ -12,11 +12,11 @@ static char name[BUFSIZ];
 
 
 char *
-m_name (int num)
+m_name(int num)
 {
        if (num <= 0)
                return "?";
 
-       snprintf (name, sizeof(name), "%d", num);
+       snprintf(name, sizeof(name), "%d", num);
        return name;
 }
index 89e9045..1c13bb6 100644 (file)
@@ -16,7 +16,7 @@
 #include <sys/file.h>
 
 int
-makedir (char *dir)
+makedir(char *dir)
 {
        char path[PATH_MAX];
        char* folder_perms_ASCII;
@@ -28,7 +28,7 @@ makedir (char *dir)
        context_save();  /* save the context file */
        fflush(stdout);
 
-       if (!(folder_perms_ASCII = context_find ("folder-protect")))
+       if (!(folder_perms_ASCII = context_find("folder-protect")))
                folder_perms_ASCII = foldprot;  /* defaults to "700" */
 
        /*
@@ -49,19 +49,19 @@ makedir (char *dir)
        */
        saved_umask = umask(0);
 
-       if (getuid () == geteuid ()) {
+       if (getuid() == geteuid()) {
                c = strncpy(path, dir, sizeof(path));
 
                while (!had_an_error && (c = strchr((c + 1), '/')) != NULL) {
                        *c = (char)0;
                        if (access(path, X_OK)) {
                                if (errno != ENOENT){
-                                       advise (dir, "unable to create directory");
+                                       advise(dir, "unable to create directory");
                                        had_an_error = 1;
                                }
                                /* Create an outer directory. */
                                if (mkdir(path, folder_perms)) {
-                                       advise (dir, "unable to create directory");
+                                       advise(dir, "unable to create directory");
                                        had_an_error = 1;
                                }
                        }
@@ -73,37 +73,40 @@ makedir (char *dir)
                        ** Create the innermost nested subdirectory of the
                        ** path we're being asked to create.
                        */
-                       if (mkdir (dir, folder_perms) == -1) {
-                               advise (dir, "unable to create directory");
+                       if (mkdir(dir, folder_perms) == -1) {
+                               advise(dir, "unable to create directory");
                                had_an_error = 1;
                        }
                }
        } else {
-               /* Ummm, why do we want to avoid creating directories with the effective
-                  user ID?  None of the nmh tools are installed such that the effective
-                  should be different from the real, and if some parent process made
-                  the two be different, I don't see why it should be our job to enforce
-                  the real UID.  Also, why the heck do we call the mkdir executable
-                  rather than the library function in this case??  If we do want to
-                  call the mkdir executable, we should at least be giving it -p (and
-                  change the single chmod() call below) so it can successfully create
-                  nested directories like the above code can.
-
-                  -- Dan Harkless <dan-nmh@dilvish.speed.net> */
+               /*
+               ** Ummm, why do we want to avoid creating directories
+               ** with the effective user ID?  None of the nmh tools are
+               ** installed such that the effective should be different
+               ** from the real, and if some parent process made the two
+               ** be different, I don't see why it should be our job to
+               ** enforce the real UID.  Also, why the heck do we call
+               ** the mkdir executable rather than the library function in
+               ** this case??  If we do want to call the mkdir executable,
+               ** we should at least be giving it -p (and change the single
+               ** chmod() call below) so it can successfully create nested
+               ** directories like the above code can.
+               ** -- Dan Harkless <dan-nmh@dilvish.speed.net>
+               */
                switch (pid = vfork()) {
                        case -1:
-                               advise ("fork", "unable to");
+                               advise("fork", "unable to");
                                return 0;
 
                        case 0:
-                               setgid (getgid ());
-                               setuid (getuid ());
+                               setgid(getgid());
+                               setuid(getuid());
 
-                               execl ("/bin/mkdir", "mkdir", dir, NULL);
-                               execl ("/usr/bin/mkdir", "mkdir", dir, NULL);
-                               fprintf (stderr, "unable to exec ");
-                               perror ("mkdir");
-                               _exit (-1);
+                               execl("/bin/mkdir", "mkdir", dir, NULL);
+                               execl("/usr/bin/mkdir", "mkdir", dir, NULL);
+                               fprintf(stderr, "unable to exec ");
+                               perror("mkdir");
+                               _exit(-1);
 
                        default:
                                if (pidXwait(pid, "mkdir"))
@@ -111,7 +114,7 @@ makedir (char *dir)
                                break;
                }
 
-               chmod (dir, folder_perms);
+               chmod(dir, folder_perms);
        }
 
        umask(saved_umask);  /* put the user's umask back */
index 8f7e357..d93ad26 100644 (file)
--- a/sbr/mf.c
+++ b/sbr/mf.c
 /*
 ** static prototypes
 */
-static char *getcpy (char *);
-static int isat (char *);
-static int parse_address (void);
-static int phrase (char *);
-static int route_addr (char *);
-static int local_part (char *);
-static int domain (char *);
-static int route (char *);
-static int my_lex (char *);
+static char *getcpy(char *);
+static int isat(char *);
+static int parse_address(void);
+static int phrase(char *);
+static int route_addr(char *);
+static int local_part(char *);
+static int domain(char *);
+static int route(char *);
+static int my_lex(char *);
 
 
 static char *
-getcpy (char *s)
+getcpy(char *s)
 {
        register char *p;
 
@@ -40,8 +40,8 @@ getcpy (char *s)
                for(;;)
                        pause();
        }
-       p = mh_xmalloc ((size_t) (strlen (s) + 2));
-       strcpy (p, s);
+       p = mh_xmalloc((size_t) (strlen(s) + 2));
+       strcpy(p, s);
        return p;
 }
 
@@ -52,12 +52,12 @@ getcpy (char *s)
 
 
 static int
-isat (char *p)
+isat(char *p)
 {
-       return (strncmp (p, " AT ", 4)
-               && strncmp (p, " At ", 4)
-               && strncmp (p, " aT ", 4)
-               && strncmp (p, " at ", 4) ? FALSE : TRUE);
+       return (strncmp(p, " AT ", 4)
+               && strncmp(p, " At ", 4)
+               && strncmp(p, " aT ", 4)
+               && strncmp(p, " at ", 4) ? FALSE : TRUE);
 }
 
 
@@ -176,38 +176,38 @@ static struct adrx  adrxs2;
 
 
 struct adrx *
-getadrx (char *addrs)
+getadrx(char *addrs)
 {
        register char *bp;
        register struct adrx *adrxp = &adrxs2;
 
        if (pers)
-               free (pers);
+               free(pers);
        if (mbox)
-               free (mbox);
+               free(mbox);
        if (host)
-               free (host);
+               free(host);
        if (path)
-               free (path);
+               free(path);
        if (grp)
-               free (grp);
+               free(grp);
        if (note)
-               free (note);
+               free(note);
        pers = mbox = host = path = grp = note = NULL;
        err[0] = 0;
 
        if (dp == NULL) {
-               dp = cp = getcpy (addrs ? addrs : "");
+               dp = cp = getcpy(addrs ? addrs : "");
                glevel = 0;
        } else if (cp == NULL) {
-               free (dp);
+               free(dp);
                dp = NULL;
                return NULL;
        }
 
-       switch (parse_address ()) {
+       switch (parse_address()) {
                case DONE:
-                       free (dp);
+                       free(dp);
                        dp = cp = NULL;
                        return NULL;
 
@@ -219,7 +219,7 @@ getadrx (char *addrs)
 
                                default:  /* catch trailing comments */
                                        bp = cp;
-                                       my_lex (adr);
+                                       my_lex(adr);
                                        cp = bp;
                                        break;
                        }
@@ -237,18 +237,18 @@ getadrx (char *addrs)
                                        break;
 
                                default:
-                                       my_lex (adr);
+                                       my_lex(adr);
                                        continue;
                        }
                        break;
                }
-       while (isspace (*ap))
+       while (isspace(*ap))
                ap++;
        if (cp)
-               sprintf (adr, "%.*s", (int)(cp - ap), ap);
+               sprintf(adr, "%.*s", (int)(cp - ap), ap);
        else
-               strcpy (adr, ap);
-       bp = adr + strlen (adr) - 1;
+               strcpy(adr, ap);
+       bp = adr + strlen(adr) - 1;
        if (*bp == ',' || *bp == ';' || *bp == '\n')
                *bp = 0;
 
@@ -267,26 +267,26 @@ getadrx (char *addrs)
 
 
 static int
-parse_address (void)
+parse_address(void)
 {
        char buffer[BUFSIZ];
 
 again: ;
        ap = cp;
-       switch (my_lex (buffer)) {
+       switch (my_lex(buffer)) {
                case LX_ATOM:
                case LX_QSTR:
-                       pers = getcpy (buffer);
+                       pers = getcpy(buffer);
                        break;
 
                case LX_SEMI:
                        if (glevel-- <= 0) {
-                               strcpy (err, "extraneous semi-colon");
+                               strcpy(err, "extraneous semi-colon");
                                return NOTOK;
                        }
                case LX_COMA:
                        if (note) {
-                               free (note);
+                               free(note);
                                note = NULL;
                        }
                        goto again;
@@ -299,46 +299,46 @@ again: ;
 
                case LX_AT:  /* sigh (3) */
                        cp = ap;
-                       if (route_addr (buffer) == NOTOK)
+                       if (route_addr(buffer) == NOTOK)
                                return NOTOK;
                        return OK;  /* why be choosy? */
 
                default:
-                       sprintf (err, "illegal address construct (%s)", buffer);
+                       sprintf(err, "illegal address construct (%s)", buffer);
                        return NOTOK;
        }
 
-       switch (my_lex (buffer)) {
+       switch (my_lex(buffer)) {
                case LX_ATOM:
                case LX_QSTR:
-                       pers = add (buffer, add (" ", pers));
+                       pers = add(buffer, add(" ", pers));
        more_phrase: ;  /* sigh (1) */
-                       if (phrase (buffer) == NOTOK)
+                       if (phrase(buffer) == NOTOK)
                                return NOTOK;
 
                        switch (last_lex) {
                                case LX_LBRK:
                        get_addr: ;
-                                       if (route_addr (buffer) == NOTOK)
+                                       if (route_addr(buffer) == NOTOK)
                                                return NOTOK;
                                        if (last_lex == LX_RBRK)
                                                return OK;
-                                       sprintf (err, "missing right-bracket (%s)", buffer);
+                                       sprintf(err, "missing right-bracket (%s)", buffer);
                                        return NOTOK;
 
                                case LX_COLN:
                        get_group: ;
                                        if (glevel++ > 0) {
-                                               sprintf (err, "nested groups not allowed (%s)", pers);
+                                               sprintf(err, "nested groups not allowed (%s)", pers);
                                                return NOTOK;
                                        }
-                                       grp = add (": ", pers);
+                                       grp = add(": ", pers);
                                        pers = NULL;
                                        {
                                                char   *pp = cp;
 
                                                for (;;)
-                                                       switch (my_lex (buffer)) {
+                                                       switch (my_lex(buffer)) {
                                                                case LX_SEMI:
                                                                case LX_END: /* tsk, tsk */
                                                                        glevel--;
@@ -349,16 +349,16 @@ again: ;
 
                                                                default:
                                                                        cp = pp;
-                                                                       return parse_address ();
+                                                                       return parse_address();
                                                        }
                                        }
 
                                case LX_DOT:  /* sigh (1) */
-                                       pers = add (".", pers);
+                                       pers = add(".", pers);
                                        goto more_phrase;
 
                                default:
-                                       sprintf (err, "no mailbox in address, only a phrase (%s%s)", pers, buffer);
+                                       sprintf(err, "no mailbox in address, only a phrase (%s%s)", pers, buffer);
                                        return NOTOK;
                        }
 
@@ -369,9 +369,9 @@ again: ;
                        goto get_group;
 
                case LX_DOT:
-                       mbox = add (buffer, pers);
+                       mbox = add(buffer, pers);
                        pers = NULL;
-                       if (route_addr (buffer) == NOTOK)
+                       if (route_addr(buffer) == NOTOK)
                                return NOTOK;
                        goto check_end;
 
@@ -379,13 +379,13 @@ again: ;
                        ingrp = glevel;
                        mbox = pers;
                        pers = NULL;
-                       if (domain (buffer) == NOTOK)
+                       if (domain(buffer) == NOTOK)
                                return NOTOK;
        check_end: ;
                        switch (last_lex) {
                                case LX_SEMI:
                                        if (glevel-- <= 0) {
-                                               strcpy (err, "extraneous semi-colon");
+                                               strcpy(err, "extraneous semi-colon");
                                                return NOTOK;
                                        }
                                case LX_COMA:
@@ -393,7 +393,7 @@ again: ;
                                        return OK;
 
                                default:
-                                       sprintf (err, "junk after local@domain (%s)", buffer);
+                                       sprintf(err, "junk after local@domain (%s)", buffer);
                                        return NOTOK;
                        }
 
@@ -402,7 +402,7 @@ again: ;
                case LX_END:
                        ingrp = glevel;
                        if (last_lex == LX_SEMI && glevel-- <= 0) {
-                               strcpy (err, "extraneous semi-colon");
+                               strcpy(err, "extraneous semi-colon");
                                return NOTOK;
                        }
                        mbox = pers;
@@ -410,20 +410,20 @@ again: ;
                        return OK;
 
                default:
-                       sprintf (err, "missing mailbox (%s)", buffer);
+                       sprintf(err, "missing mailbox (%s)", buffer);
                        return NOTOK;
        }
 }
 
 
 static int
-phrase (char *buffer)
+phrase(char *buffer)
 {
        for (;;)
-               switch (my_lex (buffer)) {
+               switch (my_lex(buffer)) {
                        case LX_ATOM:
                        case LX_QSTR:
-                               pers = add (buffer, add (" ", pers));
+                               pers = add(buffer, add(" ", pers));
                                continue;
 
                        default:
@@ -433,23 +433,23 @@ phrase (char *buffer)
 
 
 static int
-route_addr (char *buffer)
+route_addr(char *buffer)
 {
        register char *pp = cp;
 
-       if (my_lex (buffer) == LX_AT) {
-               if (route (buffer) == NOTOK)
+       if (my_lex(buffer) == LX_AT) {
+               if (route(buffer) == NOTOK)
                        return NOTOK;
        }
        else
                cp = pp;
 
-       if (local_part (buffer) == NOTOK)
+       if (local_part(buffer) == NOTOK)
                return NOTOK;
 
        switch (last_lex) {
                case LX_AT:
-                       return domain (buffer);
+                       return domain(buffer);
 
                case LX_SEMI:  /* if in group */
                case LX_RBRK:  /* no host */
@@ -458,33 +458,33 @@ route_addr (char *buffer)
                        return OK;
 
                default:
-                       sprintf (err, "no at-sign after local-part (%s)", buffer);
+                       sprintf(err, "no at-sign after local-part (%s)", buffer);
                        return NOTOK;
        }
 }
 
 
 static int
-local_part (char *buffer)
+local_part(char *buffer)
 {
        ingrp = glevel;
 
        for (;;) {
-               switch (my_lex (buffer)) {
+               switch (my_lex(buffer)) {
                        case LX_ATOM:
                        case LX_QSTR:
-                               mbox = add (buffer, mbox);
+                               mbox = add(buffer, mbox);
                                break;
 
                        default:
-                               sprintf (err, "no mailbox in local-part (%s)",
+                               sprintf(err, "no mailbox in local-part (%s)",
                                                buffer);
                                return NOTOK;
                }
 
-               switch (my_lex (buffer)) {
+               switch (my_lex(buffer)) {
                        case LX_DOT:
-                               mbox = add (buffer, mbox);
+                               mbox = add(buffer, mbox);
                                continue;
 
                        default:
@@ -495,28 +495,28 @@ local_part (char *buffer)
 
 
 static int
-domain (char *buffer)
+domain(char *buffer)
 {
        for (;;) {
-               switch (my_lex (buffer)) {
+               switch (my_lex(buffer)) {
                        case LX_ATOM:
                        case LX_DLIT:
-                               host = add (buffer, host);
+                               host = add(buffer, host);
                                break;
 
                        default:
-                               sprintf (err, "no sub-domain in domain-part of address (%s)", buffer);
+                               sprintf(err, "no sub-domain in domain-part of address (%s)", buffer);
                                return NOTOK;
                }
 
-               switch (my_lex (buffer)) {
+               switch (my_lex(buffer)) {
                        case LX_DOT:
-                               host = add (buffer, host);
+                               host = add(buffer, host);
                                continue;
 
                        case LX_AT:  /* sigh (0) */
-                               mbox = add (host, add ("%", mbox));
-                               free (host);
+                               mbox = add(host, add("%", mbox));
+                               free(host);
                                host = NULL;
                                continue;
 
@@ -528,35 +528,35 @@ domain (char *buffer)
 
 
 static int
-route (char *buffer)
+route(char *buffer)
 {
-       path = getcpy ("@");
+       path = getcpy("@");
 
        for (;;) {
-               switch (my_lex (buffer)) {
+               switch (my_lex(buffer)) {
                        case LX_ATOM:
                        case LX_DLIT:
-                               path = add (buffer, path);
+                               path = add(buffer, path);
                                break;
 
                        default:
-                               sprintf (err, "no sub-domain in domain-part of address (%s)", buffer);
+                               sprintf(err, "no sub-domain in domain-part of address (%s)", buffer);
                                return NOTOK;
                }
-               switch (my_lex (buffer)) {
+               switch (my_lex(buffer)) {
                        case LX_COMA:
-                               path = add (buffer, path);
+                               path = add(buffer, path);
                                for (;;) {
-                                       switch (my_lex (buffer)) {
+                                       switch (my_lex(buffer)) {
                                                case LX_COMA:
                                                        continue;
 
                                                case LX_AT:
-                                                       path = add (buffer, path);
+                                                       path = add(buffer, path);
                                                        break;
 
                                                default:
-                                                       sprintf (err, "no at-sign found for next domain in route (%s)",
+                                                       sprintf(err, "no at-sign found for next domain in route (%s)",
                                                                         buffer);
                                        }
                                        break;
@@ -565,15 +565,15 @@ route (char *buffer)
 
                        case LX_AT:  /* XXX */
                        case LX_DOT:
-                               path = add (buffer, path);
+                               path = add(buffer, path);
                                continue;
 
                        case LX_COLN:
-                               path = add (buffer, path);
+                               path = add(buffer, path);
                                return OK;
 
                        default:
-                               sprintf (err, "no colon found to terminate route (%s)", buffer);
+                               sprintf(err, "no colon found to terminate route (%s)", buffer);
                                return NOTOK;
                }
        }
@@ -581,7 +581,7 @@ route (char *buffer)
 
 
 static int
-my_lex (char *buffer)
+my_lex(char *buffer)
 {
        /* buffer should be at least BUFSIZ bytes long */
        int i, gotat = 0;
@@ -604,9 +604,9 @@ my_lex (char *buffer)
        if (!cp)
                return (last_lex = LX_END);
 
-       gotat = isat (cp);
+       gotat = isat(cp);
        c = *cp++;
-       while (isspace (c))
+       while (isspace(c))
                c = *cp++;
        if (c == 0) {
                cp = NULL;
@@ -637,9 +637,8 @@ my_lex (char *buffer)
                                        ADDCHR(c);
                                        if (--i < 0) {
                                                *bp = 0;
-                                               note = note ? add (buffer, add (" ", note))
-                                                       : getcpy (buffer);
-                                               return my_lex (buffer);
+                                               note = note ? add(buffer, add(" ", note)) : getcpy(buffer);
+                                               return my_lex(buffer);
                                        }
                        }
        }
@@ -696,7 +695,7 @@ my_lex (char *buffer)
                if (c == special[i].lx_chr)
                        return (last_lex = special[i].lx_val);
 
-       if (iscntrl (c))
+       if (iscntrl(c))
                return (last_lex = LX_ERR);
 
        for (;;) {
@@ -705,7 +704,7 @@ my_lex (char *buffer)
                for (i = 0; special[i].lx_chr != 0; i++)
                        if (c == special[i].lx_chr)
                                goto got_atom;
-               if (iscntrl (c) || isspace (c))
+               if (iscntrl(c) || isspace(c))
                        break;
                ADDCHR(c);
        }
@@ -727,7 +726,7 @@ got_atom: ;
 
 
 char *
-legal_person (char *p)
+legal_person(char *p)
 {
        int i;
        register char *cp;
@@ -738,7 +737,7 @@ legal_person (char *p)
        for (cp = p; *cp; cp++)
                for (i = 0; special[i].lx_chr; i++)
                        if (*cp == special[i].lx_chr) {
-                               sprintf (buffer, "\"%s\"", p);
+                               sprintf(buffer, "\"%s\"", p);
                                return buffer;
                        }
 
index 55c0f02..3313aef 100644 (file)
--- a/sbr/mts.c
+++ b/sbr/mts.c
 /*
 ** static prototypes
 */
-static char *tailor_value (unsigned char *);
-static void getuserinfo (void);
+static char *tailor_value(unsigned char *);
+static void getuserinfo(void);
 static const char *get_mtsconf_pathname(void);
 static const char *get_mtsuserconf_pathname(void);
-static void mts_read_conf_file (FILE *fp);
+static void mts_read_conf_file(FILE *fp);
 
 /*
 ** *mmdfldir and *uucpldir are the maildrop directories.  If maildrops
@@ -109,25 +109,25 @@ static struct bind binds[] = {
 */
 
 void
-mts_init (char *name)
+mts_init(char *name)
 {
        const char *cp;
        FILE *fp;
        static int inited = 0;
 
-       if (inited++ || (fp = fopen (get_mtsconf_pathname(), "r")) == NULL)
+       if (inited++ || (fp = fopen(get_mtsconf_pathname(), "r")) == NULL)
                return;
        mts_read_conf_file(fp);
-       fclose (fp);
+       fclose(fp);
 
        cp = get_mtsuserconf_pathname();
        if (cp != NULL &&
-               ((fp = fopen (get_mtsuserconf_pathname(), "r")) != NULL)) {
+               ((fp = fopen(get_mtsuserconf_pathname(), "r")) != NULL)) {
                mts_read_conf_file(fp);
-               fclose (fp);
+               fclose(fp);
        }
 
-       Everyone = atoi (everyone);
+       Everyone = atoi(everyone);
 
        if (strstr(masquerade, "draft_from") != NULL)
                draft_from_masquerading = TRUE;
@@ -148,7 +148,7 @@ mts_init (char *name)
 */
 
 static char *
-tailor_value (unsigned char *s)
+tailor_value(unsigned char *s)
 {
        int i, r;
        char *bp;
@@ -171,24 +171,24 @@ tailor_value (unsigned char *s)
                                        break;
 
                                default:
-                                       if (!isdigit (*s)) {
+                                       if (!isdigit(*s)) {
                                                *bp++ = QUOTE;