Return to qb2pe.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap

Annotation of 43BSDReno/contrib/isode-beta/psap/qb2pe.c, revision 1.1.1.1

1.1       root        1: /* qb2pe.c - create a variable-depth Inline CONStructor PElement */
                      2: 
                      3: #ifndef        lint
                      4: static char *rcsid = "$Header: /f/osi/psap/RCS/qb2pe.c,v 7.1 90/01/11 23:47:00 mrose Exp $";
                      5: #endif
                      6: 
                      7: /* 
                      8:  * $Header: /f/osi/psap/RCS/qb2pe.c,v 7.1 90/01/11 23:47:00 mrose Exp $
                      9:  *
                     10:  *
                     11:  * $Log:       qb2pe.c,v $
                     12:  * Revision 7.1  90/01/11  23:47:00  mrose
                     13:  * lint
                     14:  * 
                     15:  * Revision 7.0  89/11/23  22:13:28  mrose
                     16:  * Release 6.0
                     17:  * 
                     18:  */
                     19: 
                     20: /*
                     21:  *                               NOTICE
                     22:  *
                     23:  *    Acquisition, use, and distribution of this module and related
                     24:  *    materials are subject to the restrictions of a license agreement.
                     25:  *    Consult the Preface in the User's Manual for the full terms of
                     26:  *    this agreement.
                     27:  *
                     28:  */
                     29: 
                     30: 
                     31: /* LINTLIBRARY */
                     32: 
                     33: #include <stdio.h>
                     34: #include "psap.h"
                     35: #include "tailor.h"
                     36: 
                     37: /*  */
                     38: 
                     39: PE     qb2pe_aux ();
                     40: 
                     41: /*  */
                     42: 
                     43: PE     qb2pe (qb, len, depth, result)
                     44: register struct qbuf *qb;
                     45: int    len,
                     46:        depth;
                     47: int    *result;
                     48: {
                     49:     char   *sp;
                     50:     register struct qbuf *qp;
                     51:     PE     pe;
                     52: 
                     53:     *result = PS_ERR_NONE;
                     54:     if (depth <= 0)
                     55:        return NULLPE;
                     56: 
                     57:     if ((qp = qb -> qb_forw) != qb && qp -> qb_forw == qb)
                     58:        sp = qp -> qb_data;
                     59:     else {
                     60:        qp = NULL;
                     61:        
                     62:        if ((sp = qb2str (qb)) == NULL) {
                     63:            *result = PS_ERR_NMEM;
                     64:            return NULLPE;
                     65:        }
                     66:     }
                     67: 
                     68:     if (pe = qb2pe_aux (sp, len, depth, result)) {
                     69:        if (qp) {
                     70:            pe -> pe_realbase = (char *) qp;
                     71: 
                     72:            remque (qp);
                     73:        }
                     74:        else {
                     75:            pe -> pe_realbase = sp;
                     76: 
                     77:            QBFREE (qb);
                     78:        }
                     79:        pe -> pe_inline = 0;
                     80:     }
                     81:     else
                     82:        if (qp == NULL)
                     83:            free (sp);
                     84: 
                     85: #ifdef DEBUG
                     86:     if (pe && (psap_log -> ll_events & LLOG_PDUS))
                     87:        pe2text (psap_log, pe, 1, len);
                     88: #endif
                     89: 
                     90:     return pe;
                     91: }
                     92: 
                     93: /*  */
                     94: 
                     95: static PE  qb2pe_aux (s, len, depth, result)
                     96: register char  *s;
                     97: register int   len;
                     98: int    depth;
                     99: int    *result;
                    100: {
                    101:     int            i;
                    102:     register PElementData data;
                    103:     register PE            pe,
                    104:                    p,
                    105:                    q;
                    106:     PE     *r,
                    107:            *rp;
                    108: 
                    109:     depth--;
                    110: 
                    111:     if ((pe = str2pe (s, len, &i, result)) == NULLPE)
                    112:        return NULLPE;
                    113: 
                    114:     if (pe -> pe_form == PE_FORM_ICONS) {
                    115:        pe -> pe_form = PE_FORM_CONS;
                    116:        pe -> pe_prim = NULLPED, pe -> pe_inline = 0;
                    117:        pe -> pe_len -= pe -> pe_ilen;
                    118: 
                    119:        p = NULLPE, r = &pe -> pe_cons;
                    120:        for (s += pe -> pe_ilen, len -= pe -> pe_ilen;
                    121:                 len > 0;
                    122:                 s += i, len -= i) {
                    123:            if ((p = str2pe (s, len, &i, result)) == NULLPE)
                    124:                goto out;
                    125: 
                    126:            if (p -> pe_form == PE_FORM_ICONS) {
                    127:                if (depth > 0) {
                    128:                    if ((q = qb2pe_aux ((char *) p -> pe_prim, i, depth,
                    129:                                        result)) == NULLPE)
                    130:                        goto out;
                    131:                    pe_free (p);
                    132:                    p = q;
                    133:                }
                    134:                else {
                    135:                    if ((data = PEDalloc (i)) == NULL) {
                    136:                        *result = PS_ERR_NMEM;
                    137:                        goto out;
                    138:                    }
                    139:                    PEDcpy (p -> pe_prim, data, i);
                    140:                    p -> pe_prim = data, p -> pe_inline = 0;
                    141:                }
                    142:            }
                    143: 
                    144:            *r = p, rp = r, r = &p -> pe_next;
                    145:        }
                    146: 
                    147:        if (p && p -> pe_class == PE_CLASS_UNIV && p -> pe_id == PE_UNIV_EOC) {
                    148:            pe_free (p);
                    149:            *rp = NULLPE;
                    150:        }
                    151:     }
                    152:     
                    153:     return pe;
                    154: 
                    155: out: ;
                    156:     pe_free (pe);
                    157:     return NULLPE;
                    158: }

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