vtable shits

//structs
typedef struct pair{
    int meth, submeth;
}pair;
typedef struct vstruct{
    int sub;
    int mic;
    pair* methpairs;
}vstruct;

void genVT() {
    /* gen vtable */

    //get sub class counts
    int **vt;
    int i, j;
    int *subClassCounts = (int*)malloc(sizeof(int)*numClasses);
    memset(subClassCounts, 0, sizeof(int)*numClasses);
    int nextClass;
    for(i = 0; i < numClasses; i++) {

        nextClass = classesST[i].superclass;
        while(nextClass >= 0) {
            subClassCounts[nextClass]++;
            nextClass = classesST[nextClass].superclass;
        }
    }
    // //print subclass counts, DEBUG
    // for(i = 0; i < numClasses; i++)
    //  printf("\nClass %d has %d subclasses\n", i, subClassCounts[i]);

    //gets the actual classes that are subs
    int **subClasses = (int**)malloc(sizeof(int*)*numClasses);
    int temp;
    for(i = 0; i < numClasses; i++) {
        subClasses[i] = (int*)malloc(sizeof(int)*subClassCounts[i]);
        temp = 0;
        for(j = i+1; j < numClasses; j++) {

            if(isSubtype(j, i)) {
                subClasses[i][temp] = j;
                temp++;
            }
        }
    }
    //prints subtypes DEBUG
    // for(i = 0; i < numClasses; i++) {

    //  printf("\nClass %d has subtypes: ", i);
    //  for(j = 0; j < subClassCounts[i]; j++) {
    //      printf("%d ", subClasses[i][j]);
    //  }
    // }
    // printf("\n");

    //finds methods in common
    int **numMethodsIC = (int**)malloc(sizeof(int*)*numClasses);
    for(i = 0; i < numClasses; i++) {
        numMethodsIC[i] = (int*)malloc(sizeof(int)*subClassCounts[i]);
        memset(numMethodsIC[i], 0, sizeof(int)*subClassCounts[i]);
    }

    int k, l;
    for(i = 1; i < numClasses; i++) {

        for(j = 0; j < subClassCounts[i]; j++) {
            temp = subClasses[i][j];

            for(k = 0; k < classesST[i].numMethods; k++) {

                for(l = 0; l < classesST[temp].numMethods; l++) {
                    if(!strcmp(classesST[i].methodList[k].methodName, classesST[temp].methodList[l].methodName)) {
                        numMethodsIC[i][j]++;
                    }
                }
            }
        }
    }
    // for(i = 0; i < numClasses; i++) {

    //  printf("\nClass %d has subtypes (st, mic): ", i);
    //  for(j = 0; j < subClassCounts[i]; j++) {
    //      printf("(%d, %d) ", subClasses[i][j], numMethodsIC[i][j]);
    //  }
    // }
    // printf("\n");

    //malloc final shit
    vstruct **vtable = (vstruct**)malloc(sizeof(vstruct*)*numClasses);
    for(i = 0; i < numClasses; i++) {

        vtable[i] = (vstruct*)malloc(sizeof(vstruct)*subClassCounts[i]);
        for(j = 0; j < subClassCounts[i]; j++) {
            vtable[i][j].sub = subClasses[i][j];
            vtable[i][j].mic = numMethodsIC[i][j];

            if(vtable[i][j].mic) {

                vtable[i][j].methpairs = (pair*)malloc(sizeof(pair)*vtable[i][j].mic);

                temp = 0;
                for(k = 0; k < classesST[i].numMethods; k++) {

                    for(l = 0; l < classesST[subClasses[i][j]].numMethods; l++) {
                        if(!strcmp(classesST[i].methodList[k].methodName, classesST[subClasses[i][j]].methodList[l].methodName)) {
                            vtable[i][j].methpairs[temp].meth = k;
                            vtable[i][j].methpairs[temp].submeth = l;
                            temp++;
                            break;
                        }
                    }
                }
            }
        }
    }
    //prints vtable info DEBUG
    // for(i = 0; i < numClasses; i++) {

    //  printf("\nClass %d:\n", i);
    //  for(j = 0; j < subClassCounts[i]; j++) {

    //      printf("\t%d. Sub %d Meths In Common (meth, submeth):\n", j+1, vtable[i][j].sub);
    //      for(k = 0; k < vtable[i][j].mic; k++) {
    //          printf("\t\t%d. (%d, %d)\n", k+1, vtable[i][j].methpairs[k].meth, vtable[i][j].methpairs[k].submeth);
    //      }
    //  }
    // }

    //create vtable logic using vstruct vtable and subClassesCounts
    int vtsize = 0;
    for(i = 0; i < numClasses; i++) {
        vtsize += (1 + subClassCounts[i]) * classesST[i].numMethods;
    }
    //printf("\nvtsize = %d\n", vtsize);

    vt = (int**)malloc(sizeof(int*)*vtsize);
    for(i = 0; i < vtsize; i++) {
        vt[i] = (int*)malloc(sizeof(int)*5);
        memset(vt[i], 0, sizeof(int)*5);
    }

    int class, meth, flag;
    temp = 0;
    for(i = 0; i < numClasses; i++) {

        for(j = 0; j < classesST[i].numMethods; j++) {

            vt[temp][0] = i;
            vt[temp][1] = j;
            vt[temp][2] = i;
            vt[temp][3] = i;
            vt[temp][4] = j;
            temp++;
            for(k = 0; k < subClassCounts[i]; k++) {

                vt[temp][0] = i;
                vt[temp][1] = j;
                vt[temp][2] = subClasses[i][k];

                flag = 0;
                if(vtable[i][k].mic) {
                    for(l = 0; l < vtable[i][k].mic; l++) {
                        if(j == vtable[i][k].methpairs[l].meth) {
                            flag = 1;
                            class = subClasses[i][k];
                            meth = vtable[i][k].methpairs[l].submeth;
                            break;
                        }
                    }
                }
                if(flag) {
                    vt[temp][3] = class;
                    vt[temp][4] = meth;
                }
                else {
                    vt[temp][3] = i;
                    vt[temp][4] = j;
                }

                temp++;
            }
        }
    }
    //prints vt DEBUG
    // printf("VTABLE:\n");
    // for(i = 0; i < vtsize; i++) {

    //  printf("%d. ", i+1);
    //  for(j = 0; j < 5; j++) {
    //      printf("%d ", vt[i][j]);
    //  }
    //  printf("\n");
    // }

    //gets num static classes in vt
    int check = -1, scCount = 0;
    for(i = 0; i < vtsize; i++) {
        if(check != vt[i][0]) {
            scCount++;
            check = vt[i][0];
        }
    }
    //printf("\nStatic Class Count = %d\n", scCount);

    int *vtclist = (int*)malloc(sizeof(int)*scCount);
    check = -1;
    temp = 0;
    for(i = 0; i < vtsize; i++) {
        if(check != vt[i][0]) {
            vtclist[temp++] = vt[i][0];
            check = vt[i][0];
        }
    }
    // //debug
    // printf("\nClasses in vt: ");
    // for(i = 0; i < scCount; i++) {
    //  printf("%d ", vtclist[i]);
    // }
    // printf("\n");



    //codegens vtable
    int count = 0;
    fprintf(fout, "#VTABLE: mov 0 0 ;VTABLE-START\n");

    //gets position on stack
    fprintf(fout, "add 4 6 0\n");
    fprintf(fout, "mov 1 1\n");
    fprintf(fout, "add 4 4 1\n"); //r4 = #arg addr
    fprintf(fout, "lod 1 4 0\n"); //r1 = #args
    //fprintf(fout, "ptn 1\n"); //ptns num args debug
    fprintf(fout, "add 4 4 1\n");

    //sets r3 = static method
    fprintf(fout, "lod 3 4 1\n");

    //sets r2 = static class
    fprintf(fout, "lod 2 4 2\n");

    //sets r1 = dyn type
    fprintf(fout, "lod 1 4 3\n");
    fprintf(fout, "lod 1 1 0\n");

    //debug
    // fprintf(fout, "ptn 1\n");
    // fprintf(fout, "ptn 2\n");
    // fprintf(fout, "ptn 3\n");

    for(i = 0; i < scCount; i++) {
        fprintf(fout, "mov 4 %d\n", vtclist[i]);
        fprintf(fout, "beq 2 4 #VTCLASS%d  ;vt-class-branch\n", vtclist[i]);
    }
    fprintf(fout, "mov 4 777  ;vt-class-dne\n");
    fprintf(fout, "ptn 4\n");
    fprintf(fout, "jmp 0 #END\n");



    for(i = 0; i < scCount; i++) {

        fprintf(fout, "#VTCLASS%d: mov 0 0\n", vtclist[i]);
        for(j = 0; j < classesST[vtclist[i]].numMethods; j++) {

            fprintf(fout, "mov 4 %d\n", j);
            fprintf(fout, "beq 3 4 #VTCLASS%dMETH%d\n", vtclist[i], j);
        }
    }
    fprintf(fout, "mov 4 777  ;vt-class-dne\n");
    fprintf(fout, "ptn 4\n");
    fprintf(fout, "jmp 0 #END  ;vt-meth-dne\n");



    count = 0;
    for(i = 0; i < scCount; i++) {

        for(j = 0; j < classesST[vtclist[i]].numMethods; j++) {

            fprintf(fout, "#VTCLASS%dMETH%d: mov 0 0 \n", vtclist[i], j);

            for(k = 0; k < (1 + subClassCounts[vtclist[i]]); k++) {

                count += k;

                fprintf(fout, "mov 4 %d\n", vt[count][2]);
                fprintf(fout, "beq 1 4 #Class%dMethod%d\n", vt[count][3], vt[count][4]);
            }
            count++;
        }
    }
    fprintf(fout, "mov 4 777  ;vt-class-dne\n");
    fprintf(fout, "ptn 4\n");
    fprintf(fout, "jmp 0 #END\n");
}