int decode_recr(struct decode_state *ds, char *wp)
{
    uint64_t cmd;
    GBI_MATERAL_NODE *matp;
    GBI_TRIANGLE_NODE *trip;
//    GBI_VERTEX_NODE *verp[3];
    int i;

    for (;;) {
        if (wp < ds->buf || (wp+8) > ds->buf_end) {
            printf("wp has gone out of bounds in decode_recr()\n");
            return 0;
        }
        cmd = rbeu64(wp);
        //printf("%02x ", (int)(*wp));
        wp+=8;
        printf("%08x : %016llx %02x\n", ((int)(wp-ds->buf)), cmd, GBI_EX_CMD(cmd));
        
        switch (GBI_EX_CMD(cmd)) {
        case F3D_NOOP:
            break;
        
        case F3D_VTX:
            if (ds->seg != (exfld64(cmd, 24, 8))) {
                printf("vertex reference to other segment\n");
                return 0;
            } else {
                int i;
                int j;
                char *vwp;
                char *vwp_end;
                
                i = exfld64(cmd, 52, 4); /* number of vertices -1 */
                j = exfld64(cmd, 48, 4); /* where to load */
                if ((i+1)*16 != exfld64(cmd, 32, 16)) {
                    printf("vertex command not consistant with self\n");
                    return 0;
                }
                if (i+j > 0x0f) {
                    printf("vertex command would overflow vertex cache\n");
                    return 0;
                }
                vwp = ds->buf + exfld64(cmd,0,24);
                vwp_end = vwp + (i+1)*16;
                if (vwp_end > ds->buf_end) {
                    printf("vertex command points past end of segment\n");
                    return 0;
                }
                while (vwp < vwp_end) {
                    ds->vertex_cache[j].pt[0] = rbes16(vwp);
                    ds->vertex_cache[j].pt[1] = rbes16(vwp+2);
                    ds->vertex_cache[j].pt[2] = rbes16(vwp+4);
                    /*todo: support colors and normals*/
                    ds->vertex_cache[j].tc[0] = rbes16(vwp+8);
                    ds->vertex_cache[j].tc[1] = rbes16(vwp+10);
                    vwp+=16;
                    j++;
                }
            }
            break;
            
        case F3D_DL:
            if (ds->seg != exfld64(cmd, 24, 8)) {
                printf("Ignoring external DL at this time.\n");
            } else {
                if (!(decode_recr(ds, ds->buf+exfld64(cmd, 0, 24)))) {
                    return 0;
                }
            }
            break;
            
        case F3D_ENDDL:
            return 1;
        
        case F3D_TRI1:
            /*Search materals until a match is found*/
            matp = ds->lg->mat_head;
            while (matp && !(ds->curr_mat.is_same_as(matp))) {
                matp = matp->next;
            }
            if (!matp) {
                GBI_MATERAL_NODE *matq;
                
                matq = new GBI_MATERAL_NODE;
                if (!matq) {
                    printf("out of memory\n");
                    return 0;
                }
                
                *matq = ds->curr_mat;
                matq->next = ds->lg->mat_head;
                ds->lg->mat_head = matq;
                matp = matq;
            }
            
            trip = new GBI_TRIANGLE_NODE;
            if (!trip) {
                printf("out of memory\n");
                return 0;
            }

            for (i=0; i<3; i++) {
                GBI_VERTEX_NODE *srchpat;
                /* search vertices until a match is found */
                srchpat = &(ds->vertex_cache[exfld64(cmd, 8*(2-i), 8)/10]);
                trip->v[i] = ds->lg->vertex_head;
                while (trip->v[i] && !(srchpat->is_same_as(trip->v[i]))) {
                    trip->v[i] = trip->v[i]->next;
                }
                /* if no matching vertex is found, create a new one */
                if (!trip->v[i]) {
                    GBI_VERTEX_NODE *nvn;
                    
                    nvn = new GBI_VERTEX_NODE;
                    if (!nvn) {
                        printf("out of memory\n");
                    }
                    *nvn = *srchpat;
                    nvn->next = ds->lg->vertex_head;
                    ds->lg->vertex_head = nvn;
                    trip->v[i] = nvn;
                }
            }
            /* triangle complete! join the other triangles! */
            trip->next = matp->triangles;
            matp->triangles = trip;
            break; /*phew!*/
            
        case RDP_RDPLOADSYNC:
            break;
        
        case RDP_SETTILE:
            
        
        case RDP_SETTIMG: /* 0xfd - 11111101 fffss... ....wwww wwwwwwww pppppppp pppppppp pppppppp pppppppp*/
            ds->curr_mat.tex.img.pixelformat = exfld64(cmd, 53, 3);
            ds->curr_mat.tex.img.pixelsize = exfld64(cmd, 51, 2);
            ds->curr_mat.tex.img.width = exfld64(cmd, 32, 12);
            ds->curr_mat.tex.img.segptr = exfld64(cmd, 0, 32);
            ds->curr_mat.tex.img_defined = 1;
            break;
            
        default:
            printf("unknown GBI command %x\n", (int)(GBI_EX_CMD(cmd)));
        }
    }
}

Posted by Stifu

---

On the other hand, it would take up a fair load of database space, making backups bigger, etc... *shrugs*

---

Posted by Peardian

---

Personally, I think DST wastes more energy than it saves.

...somehow.

---

Posted by Kernal

---

So, to you people who use K&R style, why don't you also put the closing curly bracket at the end of the last line of the block?

---

if ($log) {
    if ($isstaff || $loguserid==$uid) {
        $level = 3;
    } else if ($isbanned) {
        $level = 1;
    } else {
        $level = 2;
} else {
    $level = 0;
}      
$contacts = mysql_query("SELECT contact_type, template, content FROM contacts, contact_classes WHERE contacts.ccid = contact_classes.id AND uid=$uid AND level>=$level ORDER BY contact_classes.id, contact.id");
$curr_contact_type = "";
while ($contactrow = mysql_fetch_array($contacts)) {
    $tmplex=explode('$', $contactrow['template']);
    $n = count($tmplex);
    for ($i = 1; $i < $n; $i += 2) {
        switch ($tmplex[$i]) {
        case "CONTACT_STRING_BARE":
            $tmplex[$i] = $contactrow['content'];
            break;
        case "CONTACT_STRING_SAFE":
            $tmplex[$i] = htmlspecialchars($contactrow['content']);
            break;
        }
    }
    if ($curr_contact_type == $contactrow['contact_type']) {
        $accumulated_contacts .= "<br/>".implode("", $tmplex);
    } else {
        if ($curr_contact_type) {
            /* TODO
             * display a row in the profile with
             * $curr_contact_type on the left and
             * $accumulated_contacts on the right
             */
        }
        $accumulated_contacts = implode("", $tmplex);
        $curr_contact_type = $contactrow['contact_type'];
    }
}
if ($curr_contact_type) {
    /* TODO
     * display a row in the profile with
     * $curr_contact_type on the left and
     * $accumulated_contacts on the right
     */
}

astuff.h

---

#ifdef _ASTUFF_H_
#define _ASTUFF_H_

#include "bstuff.h"

class aclass {
    bclass *b;
    void some_method();
};

#endif /* _ASTUF_H_ */

---

bstuff.h

---

#ifdef _BSTUFF_H_#define _BSTUFF_H_

#include "astuff.h"

class bclass {
    aclass *a;
    void some_other_method();
};

#endif /* _BSTUF_H_ */

---