Return to m_readefs.c CVS log

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

Annotation of 43BSD/contrib/mh/sbr/m_readefs.c, revision 1.1

1.1     ! root        1: /* m_readefs.c - read a profile/context file */
        !             2: 
        !             3: #include "../h/mh.h"
        !             4: #include <stdio.h>
        !             5: 
        !             6: 
        !             7: static struct procs {
        !             8:        char    *procname;
        !             9:        char    **procnaddr;
        !            10: } procs [] = {
        !            11:        { "context",    &context        },
        !            12:        { "mh-sequences",
        !            13:                        &mh_seq         },
        !            14:        { "fileproc",   &fileproc       },
        !            15:        { "incproc",    &incproc        },
        !            16:        { "installproc",&installproc    },
        !            17:        { "lproc",      &lproc          },
        !            18:        { "mailproc",   &mailproc       },
        !            19:        { "mhlproc",    &mhlproc        },
        !            20:        { "moreproc",   &moreproc       },
        !            21:        { "mshproc",    &mshproc        },
        !            22:        { "packproc",   &packproc       },
        !            23:        { "postproc",   &postproc       },
        !            24:        { "rmfproc",    &rmfproc        },
        !            25:        { "rmmproc",    &rmmproc        },
        !            26:        { "sendproc",   &sendproc       },
        !            27:        { "showproc",   &showproc       },
        !            28:        { "slocalproc", &slocalproc     },
        !            29:        { "vmhproc",    &vmhproc        },
        !            30:        { "whatnowproc",
        !            31:                        &whatnowproc    },
        !            32:        { "whomproc",   &whomproc       },
        !            33:        { NULL,         NULL            }
        !            34: };
        !            35: 
        !            36: static struct node **opp = NULL;
        !            37: 
        !            38: 
        !            39: void   m_readefs (npp, ib, file, ctx)
        !            40: register struct node **npp;
        !            41: register FILE   *ib;
        !            42: register char   *file;
        !            43: register int     ctx;
        !            44: {
        !            45:     register int    state;
        !            46:     register char  *cp;
        !            47:     char    name[NAMESZ],
        !            48:             field[BUFSIZ];
        !            49:     register struct node   *np;
        !            50:     register struct procs  *ps;
        !            51: 
        !            52:     if (npp == NULL && (npp = opp) == NULL) {
        !            53:        admonish (NULLCP, "bug: m_readefs called but pump not primed");
        !            54:        return;
        !            55:     }
        !            56: 
        !            57:     for (state = FLD;;) {
        !            58:        switch (state = m_getfld (state, name, field, sizeof field, ib)) {
        !            59:            case FLD:
        !            60:            case FLDPLUS:
        !            61:            case FLDEOF:
        !            62:                np = (struct node *) malloc (sizeof *np);
        !            63:                if (np == NULL)
        !            64:                    adios (NULLCP, "unable to allocate profile storage");
        !            65:                *npp = np;
        !            66:                *(npp = &np -> n_next) = NULL;
        !            67:                np -> n_name = getcpy (name);
        !            68:                if (state == FLDPLUS) {
        !            69:                    cp = getcpy (field);
        !            70:                    while (state == FLDPLUS) {
        !            71:                        state = m_getfld
        !            72:                                    (state, name, field, sizeof field, ib);
        !            73:                        cp = add (field, cp);
        !            74:                    }
        !            75:                    np -> n_field = trimcpy (cp);
        !            76:                    free (cp);
        !            77:                }
        !            78:                else
        !            79:                    np -> n_field = trimcpy (field);
        !            80:                np -> n_context = ctx;
        !            81:                for (ps = procs; ps -> procname; ps++)
        !            82:                    if (strcmp (np -> n_name, ps -> procname) == 0) {
        !            83:                        *ps -> procnaddr = np -> n_field;
        !            84:                        break;
        !            85:                    }
        !            86:                if (state == FLDEOF)
        !            87:                    break;
        !            88:                continue;
        !            89: 
        !            90:            case BODY:
        !            91:            case BODYEOF:
        !            92:                adios (NULLCP, "no blank lines are permitted in %s", file);
        !            93: 
        !            94:            case FILEEOF:
        !            95:                break;
        !            96: 
        !            97:            default:
        !            98:                adios (NULLCP, "%s is poorly formatted", file);
        !            99:        }
        !           100:        break;
        !           101:     }
        !           102: 
        !           103:     opp = npp;
        !           104: }

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