Return to ocat.c CVS log

Up to [Research Unix] / researchv10dc / cmd / icon / src / iconx

Annotation of researchv10dc/cmd/icon/src/iconx/ocat.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * File: ocat.c
        !             3:  *  Contents: cat, lconcat
        !             4:  */
        !             5: 
        !             6: #include "../h/rt.h"
        !             7: 
        !             8: /*
        !             9:  * x || y - concatenate strings x and y.
        !            10:  */
        !            11: 
        !            12: /* >cat */
        !            13: OpDcl(cat,2,"||")
        !            14:    {
        !            15:    char sbuf1[MaxCvtLen];      /* buffers for conversion to string */
        !            16:    char sbuf2[MaxCvtLen];
        !            17:    extern char *alcstr();
        !            18: 
        !            19:    /*
        !            20:     *  Convert arguments to strings if necessary.
        !            21:     */
        !            22:    if (cvstr(&Arg1, sbuf1) == NULL)
        !            23:       runerr(103, &Arg1);
        !            24:    if (cvstr(&Arg2, sbuf2) == NULL)
        !            25:       runerr(103, &Arg2);
        !            26: 
        !            27:    /*
        !            28:     * Ensure space for the resulting string.
        !            29:     */
        !            30:    strreq(StrLen(Arg1) + StrLen(Arg2));
        !            31: 
        !            32:    if (StrLoc(Arg1) + StrLen(Arg1) == strfree)
        !            33:       /*
        !            34:        * The end of Arg1 is at the end of the string space.  Hence, Arg1
        !            35:        *  was the last string allocated.  Arg1 is not copied.  Instead,
        !            36:        *  Arg2 is appended to the string space and the result is pointed
        !            37:        *  to the start of Arg1.
        !            38:        */
        !            39:       StrLoc(Arg0) = StrLoc(Arg1);
        !            40:    else
        !            41:       /*
        !            42:        * Otherwise, append Arg1 to the end of the string space and point
        !            43:        *  the result to the start of Arg1.
        !            44:        */
        !            45:       StrLoc(Arg0) = alcstr(StrLoc(Arg1),StrLen(Arg1));
        !            46:    /*
        !            47:     * Append Arg2 to the end of the string space.
        !            48:     */
        !            49:    alcstr(StrLoc(Arg2),StrLen(Arg2));
        !            50:    /*
        !            51:     *  Set the length of the result and return.
        !            52:     */
        !            53:    StrLen(Arg0) = StrLen(Arg1) + StrLen(Arg2);
        !            54:    Return;
        !            55:    }
        !            56: /* <cat */
        !            57: 
        !            58: 
        !            59: /*
        !            60:  * x ||| y - concatenate lists x and y.
        !            61:  */
        !            62: 
        !            63: OpDcl(lconcat,2,"|||")
        !            64:    {
        !            65:    register struct b_list *bp1, *bp2;
        !            66:    register struct b_lelem *lp1, *lp2;
        !            67:    word size1, size2;
        !            68: 
        !            69:    /*
        !            70:     * x and y must be lists.
        !            71:     */
        !            72:    if (Qual(Arg1) || Arg1.dword != D_List)
        !            73:       runerr(108, &Arg1);
        !            74:    if (Qual(Arg2) || Arg2.dword != D_List)
        !            75:       runerr(108, &Arg2);
        !            76: 
        !            77:    /*
        !            78:     * Get the size of both lists.
        !            79:     */
        !            80:    size1 = BlkLoc(Arg1)->list.size;
        !            81:    size2 = BlkLoc(Arg2)->list.size;
        !            82: 
        !            83:    /*
        !            84:     * Make a copy of both lists.
        !            85:     */
        !            86:    cplist(&Arg1, &Arg1, (word)1, size1 + 1);
        !            87:    cplist(&Arg2, &Arg2, (word)1, size2 + 1);
        !            88: 
        !            89:    /*
        !            90:     * Get a pointer to both lists.  bp1 points to the copy of x and is
        !            91:     *  the list that will be returned.
        !            92:     */
        !            93:    bp1 = (struct b_list *) BlkLoc(Arg1);
        !            94:    bp2 = (struct b_list *) BlkLoc(Arg2);
        !            95: 
        !            96:    /*
        !            97:     * Perform the concatenation by hooking the lists together so
        !            98:     *  that the next list of x is y and the previous list of y is x.
        !            99:     */
        !           100:    lp1 = (struct b_lelem *) BlkLoc(bp1->listtail);
        !           101:    lp2 = (struct b_lelem *) BlkLoc(bp2->listhead);
        !           102: 
        !           103:    lp1->listnext.dword = D_Lelem;
        !           104:    BlkLoc(lp1->listnext) = (union block *) lp2;
        !           105: 
        !           106:    lp2->listprev.dword = D_Lelem;
        !           107:    BlkLoc(lp2->listprev) = (union block *) lp1;
        !           108: 
        !           109:    /*
        !           110:     * Adjust the size field to reflect the length of the concatenated lists.
        !           111:     */
        !           112:    bp1->size = size1 + size2;
        !           113:    BlkLoc(bp1->listtail) = BlkLoc(bp2->listtail);
        !           114: 
        !           115:    Arg0 = Arg1;
        !           116:    Return;
        !           117:    }

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