Return to llib-lmh CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / mh / sbr

Annotation of 43BSD/contrib/mh/sbr/llib-lmh, revision 1.1

1.1     ! root        1: /* LINTLIBRARY */
        !             2: 
        !             3: #include "../h/mh.h"
        !             4: #include "../h/addrsbr.h"
        !             5: #include "../h/formatsbr.h"
        !             6: #include <stdio.h>
        !             7: 
        !             8: 
        !             9: char   *add(a,b) char *a,*b; { return add(a,b); }
        !            10:        /* VARARGS2 */
        !            11: void   adios(w,f) char *w,*f; { adios(w,f); }
        !            12:        /* VARARGS2 */
        !            13: void   admonish(w,f) char *w,*f; { admonish(w,f); }
        !            14: char   *adrsprintf(l,d) char *l,*d; { return adrsprintf(l,d); }
        !            15:        /* VARARGS2 */
        !            16: void   advise(w,f) char *w,*f; { advise(w,f); }
        !            17:        /* VARARGS3 */
        !            18: void   advertise(w,t,f) char *w,*t,*f; { advertise(w,t,f); }
        !            19: void   ambigsw(a,s) char *a; struct swit *s; { ambigsw(a,s); }
        !            20: int     atooi(s) char *s; { return atooi(s); }
        !            21: char   *auxformat(m,e) struct mailname *m; { return auxformat(m,e); }
        !            22: char  **brkstring(s,b,t) char *s,*b,*t; { return brkstring(s,b,t); }
        !            23: void   closefds(i) { closefds (i); }
        !            24:        /* VARARGS */
        !            25: char   *concat(s1) char *s1; { return concat(s1); }
        !            26: char   *copy(f,t) char *f,*t; { return copy(f,t); }
        !            27: char  **copyip(f,t) char **f,**t; { return copyip(f,t); }
        !            28: void   cpydata(i,o,f,g) char *f,*g; { cpydata(i,o,f,g); }
        !            29: void   cpydgst(i,o,f,g) char *f,*g; { cpydgst(i,o,f,g); }
        !            30: void   discard(i) FILE *i; { discard(i); }
        !            31: /*
        !            32:  * done should not be defined here because it is designed to be
        !            33:  *  redefined by the parent routines if they need special exit
        !            34:  *  processing.  Definition here causes multiply defined messages
        !            35:  *  from lint.
        !            36:  *
        !            37: void   done(s) { done(s); }
        !            38:  */
        !            39: int     fdcompare(f1,f2) { return fdcompare(f1,f2); }
        !            40: int    fmt_compile(s,f) char *s; struct format **f;
        !            41:        { return fmt_compile(s,f); }
        !            42: int    fmtscan(f,s,w,d) struct format *f; char *s; int d[];
        !            43:        { return fmtscan(f,s,w,d); }
        !            44: /*
        !            45:  * formataddr is also designed to be redefined by the parent routines.
        !            46:  *
        !            47: char   *formataddr(d,e,b,s) char *d,*e,*b,*s;
        !            48:        { return formataddr(d,e,b,s); }
        !            49:  */
        !            50: int     gans(p,s) char *p; struct swit *s; { return gans(p,s); }
        !            51: char  **getans(p,s) char *p; struct swit *s; { return getans(p,s); }
        !            52: int    getanswer(p) char *p; { return getanswer(p); }
        !            53: char   *getcpy(s) char *s; { return getcpy(s); }
        !            54: struct mailname
        !            55:        *getm(s,h,t,w,e) char *s,*h,*e; { return getm(s,h,t,w,e); }
        !            56: char   *getname(a) char *a; { return getname(a); }
        !            57: void   help(s,sw) char *s; struct swit *sw; { help(s,sw); }
        !            58: int    ismymbox(n) struct mailname *n; { return ismymbox(n); }
        !            59: char   *libpath(f) char *f; { return libpath(f); }
        !            60: int    m_atoi(s) char *s; { return m_atoi(s); }
        !            61: char   *m_backup(s) char *s; { return m_backup(s); }
        !            62: int     m_convert(m,s) struct msgs *m; char *s; { return m_convert(m,s); }
        !            63: int     m_delete(s) char *s; { return m_delete(s); }
        !            64: char   *m_draft(f,m,u,i) char *f,*m; int *i; { return m_draft(f,m,u,i); }
        !            65: void   m_eomsbr(a) int (*a)(); { m_eomsbr(a); }
        !            66: char   *m_find(s) char *s; { return s; }
        !            67: void   m_fmsg(m) struct msgs *m; { m_fmsg(m); }
        !            68: void   m_foil(p) char *p; { m_foil(p); }
        !            69: void   m_getdefs() { m_getdefs(); }
        !            70: int     m_getfld(s,n,b,bs,i) char *n,*b; FILE *i; 
        !            71:        { return m_getfld(s,n,b,bs,i); }
        !            72: char   *m_getfolder() { return m_getfolder(); }
        !            73: int     m_gmprot() { return m_gmprot(); }
        !            74: struct msgs
        !            75:        *m_gmsg(s) char *s; { return m_gmsg(s); }
        !            76: char   *m_maildir(s) char *s; { return m_maildir(s); }
        !            77: char   *m_mailpath(s) char *s; { return m_mailpath(s); }
        !            78: char   *m_name(i) { return m_name(i); }
        !            79: void   m_readefs(n,i,f,c) struct node **n; FILE *i; char *f;
        !            80:        { m_readefs(n,i,f,c); }
        !            81: struct msgs
        !            82:        *m_remsg(m,l,h) struct msgs *m; { return m_remsg(m,l,h); }
        !            83: void   m_replace(k,v) char *k,*v; { m_replace(k,v); }
        !            84: char   *m_scratch(s,t) char *s,*t; { return m_scratch (s,t); }
        !            85: char   *m_seq(m,c) struct msgs *m; char *c; { return m_seq(m,c); }
        !            86: int    m_seqadd (m,c,j,p) struct msgs *m; char *c;
        !            87:        { return m_seqadd (m,c,j,p); }
        !            88: char   *m_seqbits (m) struct msgs *m; { return m_seqbits (m); }
        !            89: int    m_seqdel (m,c,j) struct msgs *m; char *c; { return m_seqdel (m,c,j); }
        !            90: int    m_seqflag (m,c) struct msgs *m; char *c; { return m_seqflag (m,c); }
        !            91: int    m_seqnew (m,c,p) struct msgs *m; char *c; { return m_seqnew (m,c,p); }
        !            92: void   m_setcur(m,i) struct msgs *m; { m_setcur(m,i); }
        !            93: void   m_setseq(m) struct msgs *m; { m_setseq(m); }
        !            94: void   m_setvis(m,s) struct msgs *m; { m_setvis(m,s); }
        !            95: void   m_sync(m) struct msgs *m; { m_sync(m); }
        !            96: char   *m_tmpfil(t) char *t; { return m_tmpfil (t); }
        !            97: void   m_unknown(f) FILE *f; { m_unknown(f); }
        !            98: void   m_update() { m_update(); }
        !            99: int     m_whatnow(e,n,u,f,a,d,m,t,i,c) struct msgs *m; char *e,*f,*a,*t,*c;
        !           100:        { return m_whatnow (e,n,u,f,a,d,m,t,i,c); }
        !           101: int     makedir(d) char *d; { return makedir(d); }
        !           102: void   mnfree (m) struct mailname *m; { mnfree (m); }
        !           103: char   *new_fs(f,m,d) char *f,*m,*d; { return new_fs(f,m,d); }
        !           104: char   *path(n,t) char *n; { return path(n,t); }
        !           105: int     peekc(i) FILE *i; { return peekc(i); }
        !           106: int    pidwait(i,s) { return pidwait(i,s); }
        !           107: int    pidstatus(s,f,c) FILE *f; char *c; { return pidstatus(s,f,c); }
        !           108: void   printsw(s,sw,p) char *s,*p; struct swit *sw; { printsw(s,sw,p); }
        !           109: void   push() { push(); }
        !           110: int    putenv(a,b) char *a,*b; { return putenv(a,b); }
        !           111: char   *pwd() { return pwd(); }
        !           112: char   *r1bindex(s,c) char *s; { return r1bindex(s,c); }
        !           113: int    refile(a,f) char **a,*f; { return refile(a,f); }
        !           114: int     remdir(d) char *d; { return remdir(d); }
        !           115: int     showfile(a,f) char **a,*f; { return showfile(a,f); }
        !           116: int     smatch(s,sw) char *s; struct swit *sw; { return smatch(s,sw); }
        !           117: char   *sprintb(b,v,f) char *b,*f; unsigned v; { return sprintb(b,v,f); }
        !           118: int    ssequal(a,b) char *a,*b; { return ssequal(a,b); }
        !           119: int    strindex(a,b) char *a,*b; { return strindex(a,b); }
        !           120: char   *trimcpy(s) char *s; { return trimcpy(s); }
        !           121: int     type(fd,s) char *s; { return type(fd,s); }
        !           122: int     uleq(s1,s2) char *s1,*s2; { return uleq(s1,s2); }
        !           123: int    unputenv(a) char *a; { return unputenv(a); }
        !           124: int    uprf(s1,s2) char *s1,*s2; { return uleq(s1,s2); }
        !           125: int    vfgets(i,b) FILE *i; char **b; {return vfgets(i,b); }

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