Return to path.c CVS log

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

Annotation of 43BSD/contrib/mh/sbr/path.c, revision 1.1.1.1

1.1       root        1: /* path.c - return a pathname */
                      2: 
                      3: #include "../h/mh.h"
                      4: #include <stdio.h>
                      5: 
                      6: #define        CWD     "./"
                      7: #define        NCWD    (sizeof CWD - 1)
                      8: #define        DOT     "."
                      9: #define        DOTDOT  ".."
                     10: #define        PWD     "../"
                     11: #define        NPWD    (sizeof PWD - 1)
                     12: 
                     13: 
                     14: static char *pwds;
                     15: 
                     16: char   *expath ();
                     17: 
                     18: 
                     19: char   *path (name, flag)
                     20: register char   *name;
                     21: register int     flag;
                     22: {
                     23:     register char  *cp,
                     24:                    *ep;
                     25: 
                     26:     if ((cp = expath (name, flag))
                     27:            && (ep = cp + strlen (cp) - 1) > cp
                     28:            && *ep == '/')
                     29:        *ep = NULL;
                     30: 
                     31:     return cp;
                     32: }
                     33: 
                     34: /*  */
                     35: 
                     36: static  char   *expath (name, flag)
                     37: register char   *name;
                     38: register int     flag;
                     39: {
                     40:     register char  *cp,
                     41:                    *ep;
                     42:     char    buffer[BUFSIZ];
                     43: 
                     44:     if (flag == TSUBCWF) {
                     45:        (void) sprintf (buffer, "%s/%s", m_getfolder (), name);
                     46:        name = m_mailpath (buffer);
                     47:        compath (name);
                     48:        (void) sprintf (buffer, "%s/", m_maildir (""));
                     49:        if (ssequal (buffer, name)) {
                     50:            cp = name;
                     51:            name = getcpy (name + strlen (buffer));
                     52:            free (cp);
                     53:        }
                     54:        flag = TFOLDER;
                     55:     }
                     56: 
                     57:     if (*name == '/'
                     58:            || (flag == TFOLDER
                     59:                && (strncmp (name, CWD, NCWD)
                     60:                    && strcmp (name, DOT)
                     61:                    && strcmp (name, DOTDOT)
                     62:                    && strncmp (name, PWD, NPWD))))
                     63:        return getcpy (name);
                     64: 
                     65:     if (pwds == NULL)
                     66:        pwds = pwd ();
                     67: 
                     68:     if (strcmp (name, DOT) == 0 || strcmp (name, CWD) == 0)
                     69:        return getcpy (pwds);
                     70: 
                     71:     ep = pwds + strlen (pwds);
                     72:     if ((cp = rindex (pwds, '/')) == NULL)
                     73:        cp = ep;
                     74:     else
                     75:        if (cp == pwds)
                     76:            cp++;
                     77: 
                     78:     if (strncmp (name, CWD, NCWD) == 0)
                     79:        name += NCWD;
                     80: 
                     81:     if (strcmp (name, DOTDOT) == 0 || strcmp (name, PWD) == 0) {
                     82:        (void) sprintf (buffer, "%.*s", cp - pwds, pwds);
                     83:        return getcpy (buffer);
                     84:     }
                     85: 
                     86:     if (strncmp (name, PWD, NPWD) == 0)
                     87:        name += NPWD;
                     88:     else
                     89:        cp = ep;
                     90: 
                     91:     (void) sprintf (buffer, "%.*s/%s", cp - pwds, pwds, name);
                     92:     return getcpy (buffer);
                     93: }
                     94: 
                     95: /*  */
                     96: 
                     97: static  compath (f)
                     98: register char  *f;
                     99: {
                    100:     register char  *cp,
                    101:                    *dp;
                    102: 
                    103:     if (*f != '/')
                    104:        return;
                    105: 
                    106:     for (cp = f; *cp;)
                    107:        if (*cp == '/') {
                    108:            switch (*++cp) {
                    109:                case NULL: 
                    110:                    if (--cp > f)
                    111:                        *cp = NULL;
                    112:                    break;
                    113: 
                    114:                case '/': 
                    115:                    for (dp = cp; *dp == '/'; dp++)
                    116:                        continue;
                    117:                    (void) strcpy (cp--, dp);
                    118:                    continue;
                    119: 
                    120:                case '.': 
                    121:                    if (strcmp (cp, DOT) == 0) {
                    122:                        if (cp > f + 1)
                    123:                            cp--;
                    124:                        *cp = NULL;
                    125:                        break;
                    126:                    }
                    127:                    if (strcmp (cp, DOTDOT) == 0) {
                    128:                        for (cp -= 2; cp > f; cp--)
                    129:                            if (*cp == '/')
                    130:                                break;
                    131:                        if (cp <= f)
                    132:                            cp = f + 1;
                    133:                        *cp = NULL;
                    134:                        break;
                    135:                    }
                    136:                    if (strncmp (cp, PWD, NPWD) == 0) {
                    137:                        for (dp = cp - 2; dp > f; dp--)
                    138:                            if (*dp == '/')
                    139:                                break;
                    140:                        if (dp <= f)
                    141:                            dp = f;
                    142:                        (void) strcpy (dp, cp + NPWD - 1);
                    143:                        cp = dp;
                    144:                        continue;
                    145:                    }
                    146:                    if (strncmp (cp, CWD, NCWD) == 0) {
                    147:                        (void) strcpy (cp - 1, cp + NCWD - 1);
                    148:                        cp--;
                    149:                        continue;
                    150:                    }
                    151:                    continue;
                    152: 
                    153:                default: 
                    154:                    cp++;
                    155:                    continue;
                    156:            }
                    157:            break;
                    158:        }
                    159:        else
                    160:            cp++;
                    161: }

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