Main Page

Source Files

Class Hierarchy

Alphabetical List

Compound List

Compound Members

File Members

Related Pages

Search for

---

libsrc/do2.cxx

Go to the documentation of this file.

/**********************************************************************
 * Copyright 2002 Jeff Rush <jrush@taupro.com>
 * Original Copyright 1979-2002 Udanax.com
 *
 * This file is part of the Udanax xanalogical storage system.
 *
 * Udanax is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Udanax is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Udanax; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 **********************************************************************/

/* Modification History:
 * $Log: do2.cxx,v $
 * Revision 1.15  2004/09/11 13:59:21  jrush
 * Changed all fprintf's to stderr to use the Nana library L() macro.  Also
 * removed a 2-3 minor compiler warnings.
 *
 * Revision 1.14  2004/09/04 16:02:17  jrush
 * Added Doxygen headers before each and every function definition.
 *
 * Revision 1.13  2004/09/03 11:38:30  jrush
 * Began adding extensive commenting to functions.
 *
 * Revision 1.12  2002/07/14 08:35:23  jrush
 * Replace gerror(), qerror() with assert()
 *
 * Revision 1.11  2002/05/28 04:22:29  jrush
 * Adjusted source files to comply with GPL licensing.
 *
 * Revision 1.10  2002/04/12 11:56:43  jrush
 * Reorganized include file layout, renamed xanadu.h to udanax.h and
 * typecontext/typecrumcontext to C++ class Context/CrumContext.
 *
 * Revision 1.9  2002/04/10 18:01:54  jrush
 * Renamed class typeisa to IStreamAddr.
 *
 * Revision 1.8  2002/04/09 21:45:46  jrush
 * Renamed class 'tumbler' to 'Tumbler', for consistency with Python sources,
 * and changed typeisa from typedef to a subclass, in preparation for cleaning
 * up the type/class tree.
 *
 * Revision 1.7  2002/04/06 20:42:50  jrush
 * Switch from sess->alloc() style to new(sess) Object parameterized allocator.
 *
 * Revision 1.6  2002/04/06 17:05:57  jrush
 * Switched from referring to 'task' for a client connection to 'session',
 * and converted the typetask typedef/struct into a Session C++ class.
 *
 * Revision 1.5  2002/04/06 15:01:17  jrush
 * Changed INT to just 'int'.
 *
 * Revision 1.4  2002/04/06 14:06:19  jrush
 * Added more debugging messages as I work on getting docopy() to work.
 *
 * Revision 1.3  2002/04/02 18:45:12  jrush
 * Purely cosmetic changes.
 *
 * Revision 1.2  2002/02/14 09:27:43  jrush
 * Cleaned up source:
 *
 * 1. ran thru the indent tool to achieve a standard look,
 * 2. added structured comments at top for use with DOxygen reporting
 *    as well as CVS keywords,
 * 3. fixed compiler warnings re ambiguous assign/compares,
 *    needed casts and unused/uninitialized variables,
 * 4. fixed funcs that didn't specify a return type,
 * 5. centralized prototypes in protos.h, removing incomplete ones,
 * 6. cleaned up use of bool/BOOLEAN type to suit C++ type,
 * 7. fixed initializer nesting in tumbler constants,
 * 8. renamed vars that conflict with C++ keywords (new, this),
 * 9. fixed global/extern confusion re some global vars.
 *
 */

#include "udanax.h"

    // Convert the specification set into a set of spans into the I-stream.
    bool
specset2ispanset(
    Session      *sess,          
    typespecset   specset,
    typeispanset *ispansetptr,
    int           type)
{
    //UNUSED typeispanset *save = ispansetptr;

    *ispansetptr = NULL;
    for (; specset; specset = (typespec *) ((typeitemheader *) specset)->next) {

        if (((typeitemheader *) specset)->itemid == ISPANID) {
            L("specset2ispanset, found an ISPANID\n");

            *ispansetptr = (typeispanset) specset;
            ispansetptr = (typeispanset *) & ((typeitemheader *) specset)->next;

        } else if (((typeitemheader *) specset)->itemid == VSPECID) {
            L("specset2ispanset, found an VSPECID\n");

            assert(!iszerotumbler(&((typevspec *) specset)->docisa)); // ERROR: retrieve called with docisa 0

            typeorgl docorgl;
            if (!(findorgl(sess, granf, &((typevspec *) specset)->docisa, &docorgl, type) /*BERT*/
            && (ispansetptr = vspanset2ispanset(sess, docorgl, ((typevspec *) specset)->vspanset, ispansetptr)))) {
                return false;        /* zzzz */
            }
        }
    }
    return true;
}

    bool
tumbler2spanset(
    Session     *sess,          
    IStreamAddr *tumblerptr,
    typespanset *spansetptr)
{
    typespan *spanptr = new(sess) typespan;
//    typespan *spanptr = (typespan *) sess->alloc(sizeof(typespan));

    spanptr->next   = NULL;
    spanptr->itemid = ISPANID;

    movetumbler(tumblerptr, &spanptr->stream);

    tumblerclear(&spanptr->width);
    tumblerincrement(&spanptr->width, tumblerlength(tumblerptr) - 1 /* zzzzz */ , 1,
                     &spanptr->width);
    *spansetptr = spanptr;

    return true;
}

    void
makehint(
    int          typeabove,
    int          typebelow,
    int          typeofatom,
    IStreamAddr *isaptr,
    typehint    *hintptr)
{
    hintptr->supertype = typeabove;
    hintptr->subtype   = typebelow;
    hintptr->atomtype  = typeofatom;

    movetumbler(isaptr, &hintptr->hintisa);
}

    void
validhint(typehint *hintptr)
{
    if ((hintptr->supertype < NODE)
        || (hintptr->supertype > DOCUMENT)
        || (hintptr->subtype   < ACCOUNT)
        || (hintptr->subtype   > ATOM)
        || (hintptr->atomtype  < 0)
        || (hintptr->atomtype  > 2)
        || (hintptr->subtype   < hintptr->supertype)
        || ((hintptr->subtype - hintptr->supertype) > 1)
        || ((hintptr->subtype == ATOM) == !hintptr->atomtype)) {

#ifndef DISTRIBUTION
/* L("bad hint: supertype = %d subtype = %d atomtype = %d\n", hintptr->supertype, hintptr->subtype,
 * hintptr->atomtype); L("hintisa = "); puttumbler(stderr, &hintptr->hintisa); */
        assert(0); // bad hint
#else
        assert(0);
#endif
    }
}

    bool /* vsa 1 if zenf, else w/in vspan of fullcrum */
acceptablevsa(
    Tumbler  *vsaptr,
    typeorgl  orglptr)
{
    L("--acceptablevsa is a NOP--\n");
    return true;
}

    bool
insertendsetsinspanf(
    Session       *sess,          
    typespanf      spanfptr,
    IStreamAddr   *linkisaptr,
    typesporglset  fromsporglset,
    typesporglset  tosporglset,
    typesporglset  threesporglset)
{
    if (!(insertspanf(sess, spanfptr, linkisaptr, fromsporglset, LINKFROMSPAN)
          && insertspanf(sess, spanfptr, linkisaptr, tosporglset, LINKTOSPAN)))
        return false;

    if (threesporglset) {
        if (!insertspanf(sess, spanfptr, linkisaptr, threesporglset, LINKTHREESPAN)) {
            return false;
        }
    }
    return true;
}

    bool
insertendsetsinorgl(
    Session       *sess,          
    Tumbler       *linkisaptr,
    typeorgl       link,
    Tumbler       *fromvsa,
    typesporglset  fromsporglset,
    Tumbler       *tovsa,
    typesporglset  tosporglset,
    Tumbler       *threevsa,
    typesporglset  threesporglset)
{
    if (!(insertpm(sess, linkisaptr, link, fromvsa, fromsporglset)
          && insertpm(sess, linkisaptr, link, tovsa, tosporglset))) {
        return false;
    }

    if (threevsa && threesporglset) {
        if (!insertpm(sess, linkisaptr, link, threevsa, threesporglset))
            return false;

    } else {
#ifndef DISTRIBUTION
        L("leaving INSERTENDSETSINORGL 4\n");
        L(" threevsa ptr= %x threesporglset ptr = %x threesvsa = \n", (int) threevsa, (int) threesporglset);
        dumptumbler(threevsa);
#endif
    }

    return true;
}

    bool
findnextlinkvsa(
    Session     *sess,          
    IStreamAddr *docisaptr,
    Tumbler     *vsaptr)
{
    Tumbler vspanreach, firstlink;
    typevspan vspan;

    tumblerclear(&firstlink);
    tumblerincrement(&firstlink, 0, 2, &firstlink);
    tumblerincrement(&firstlink, 1, 1, &firstlink);

    doretrievedocvspan(sess, docisaptr, &vspan);

    tumbleradd(&vspan.stream, &vspan.width, &vspanreach);

    if (tumblercmp(&vspanreach, &firstlink) == LESS)
        movetumbler(&firstlink, vsaptr);
    else
        movetumbler(&vspanreach, vsaptr);

    return true;
}

    bool
setlinkvsas(
    Tumbler *fromvsaptr,
    Tumbler *tovsaptr,
    Tumbler *threevsaptr)
{
    tumblerclear(fromvsaptr);
    tumblerincrement(fromvsaptr, 0, 1, fromvsaptr);
    tumblerincrement(fromvsaptr, 1, 1, fromvsaptr);

    tumblerclear(tovsaptr);
    tumblerincrement(tovsaptr, 0, 2, tovsaptr);
    tumblerincrement(tovsaptr, 1, 1, tovsaptr);

    if (threevsaptr) {
        tumblerclear(threevsaptr);
        tumblerincrement(threevsaptr, 0, 3, threevsaptr);
        tumblerincrement(threevsaptr, 1, 1, threevsaptr);
    }

    return true;
}

    bool
ispansetandspecsets2spanpairset(
    Session *sess,          
    typeispanset ispanset,
    typespecset specset1,
    typespecset specset2,
    typespanpairset *pairsetptr)
{
#ifndef DISTRIBUTION
    L("entering ispansetandspecsets2spanpairset\n");
#endif

    if (ispanset == NULL) {
        *pairsetptr = NULL;

#ifndef DISTRIBUTION
        L("ispanset NULL, no relation\n");
#endif

    } else {
        restrictspecsetsaccordingtoispans(sess, ispanset, &specset1, &specset2);
        makespanpairset(sess, ispanset, specset1, specset2, pairsetptr);

#ifndef DISTRIBUTION
        foo("after makespanpairset\n");
        if (debug)
            dumpspanpairset(*pairsetptr);
#endif

    }

#ifndef DISTRIBUTION
    L("leaving ispansetandspecsets2spanpairset\n");
#endif

    return true;
}

---