Return to list.h CVS log

Up to [Research Unix] / researchv9 / cmd / cfront / CC / common

Annotation of researchv9/cmd/cfront/CC/common/list.h, revision 1.1

1.1     ! root        1: 
        !             2: struct link {
        !             3:        link* next;
        !             4:        common* p;
        !             5:        link(common* pp, link* nn) { p=pp; next=nn; }
        !             6: };
        !             7: 
        !             8: class list : public common {   /* an element can occur more than once */
        !             9:        link* head;
        !            10:        link* tail;
        !            11: public:
        !            12:        list() { head = tail = 0; }
        !            13:        list(common& oo) { head = tail = new link(&oo, 0); }
        !            14:        ~list();
        !            15: 
        !            16:        void    add(common& oo) {
        !            17:                        head = new link(&oo,head);
        !            18:                        if (tail == 0) tail=head;
        !            19:                }
        !            20: 
        !            21:        void    addlast(common& oo) {
        !            22:                if (tail==0)
        !            23:                        head = tail = new link(&oo,0);
        !            24:                else
        !            25:                        tail = tail->next = new link(&oo,0);
        !            26:        }
        !            27: 
        !            28:        common* remove() {
        !            29:                if (head) {
        !            30:                        common* p = head->p;
        !            31:                        if (head == tail)
        !            32:                                head = tail = 0;
        !            33:                        else
        !            34:                                head=head->next;
        !            35:                        return p;
        !            36:                }
        !            37:                else
        !            38:                        return 0;
        !            39:        }
        !            40: 
        !            41:        common* remove(common& oo);
        !            42:        common* first() { return head?head->p:0; }
        !            43:        common* last()  { return tail?tail->p:0; }
        !            44:        int     empty() { return head!=0; }
        !            45: };
        !            46: 
        !            47: class set : public list {      /* unique elements */
        !            48:        common  remove();
        !            49: public:
        !            50:        set();
        !            51:        set(common&);
        !            52:        ~set();
        !            53: 
        !            54:        int     empty();
        !            55:        int     insert(common&);
        !            56:        common* remove(common&);
        !            57:        common* find(char*);
        !            58:        common* find(common&);
        !            59:        int     no_of_mem();
        !            60: };
        !            61: 
        !            62: struct dlink {
        !            63:        dlink* pre, *suc;
        !            64:        common* p;
        !            65:        dlink(dlink* pr, dlink* su, common* pp) { pre=pr; suc=su; p=pp; }
        !            66: }; 
        !            67: 
        !            68: class dlist : public common {
        !            69:        dlink* head;
        !            70: public:
        !            71:        dlist();
        !            72:        dlist(common&);
        !            73:        ~dlist();
        !            74: 
        !            75:        void    insert();
        !            76:        common* remove();
        !            77:        common* remove(common&);
        !            78:        common* curr();
        !            79:        common* next();
        !            80:        common* prev();
        !            81: };
        !            82: 

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