[Jilc-patches] CVS: jilc/src codegen.c,1.1,1.2

[Gaurav Vaish <address@hidden>]

Update of /cvsroot/jilc/jilc/src
In directory subversions:/tmp/cvs-serv30108

Modified Files:
        codegen.c 
Log Message:


2002-04-17    Gaurav Vaish <address@hidden>

* codegen.c: Abhaya's code submission.





Index: codegen.c
===================================================================
RCS file: /cvsroot/jilc/jilc/src/codegen.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- codegen.c   12 Apr 2002 15:48:42 -0000      1.1
+++ codegen.c   17 Apr 2002 05:13:34 -0000      1.2
@@ -29,9 +29,49 @@
        fprintf(output,"\n");
 }
 
-int write_class_attributes(UInt16 acc_flag,FILE* output)
+int write_class_attributes(UInt16 acc_flags,FILE* output)
 {
-       fprintf(output,"auto unicode beforefieldinit 
%s",resolve_flags(acc_flag,CLASS));
+       fprintf(output,"auto unicode beforefieldinit 
%s",jilc_access_flags(acc_flags,CLASS));
+}
+
+char* jilc_access_flags(UInt16 flags,UInt32 type)
+{
+       char *retVal = (char *)calloc(101, sizeof(char));
+       if(flags == 0x0000)
+               strcat(retVal, "");
+       if(is_set(flags, ACCESS_PUBLIC))
+               strcat(retVal, "public ");
+       if(is_set(flags, ACCESS_PRIVATE))
+               strcat(retVal, "private ");
+       if(is_set(flags, ACCESS_PROTECTED))
+               strcat(retVal, "famorassem ");
+       if(!is_set(flags,0x0007))
+               strcat(retVal,"assembly ");
+       if(is_set(flags, ACCESS_STATIC))
+               strcat(retVal, "static ");
+       if(is_set(flags, ACCESS_FINAL)){
+               if(type==CLASS)
+                       strcat(retVal, "sealed ");
+               else if(type==FIELD)
+                       strcat(retVal, "initonly ");
+               else if(type==METHOD)
+                       strcat(retVal, "final ");
+       }
+       if(is_set(flags, ACCESS_SYNCHRONIZED)){
+               if(type==CLASS)
+                       strcat(retVal,"specialname ");
+       if(is_set(flags, ACCESS_VOLATILE))
+               strcat(retVal, "volatile ");
+       if(is_set(flags, ACCESS_TRANSIENT))
+               strcat(retVal, "transient ");
+       if(is_set(flags, ACCESS_NATIVE))
+               strcat(retVal, "native ");
+       if(is_set(flags, ACCESS_ABSTRACT))
+               strcat(retVal, "abstract ");
+
+       retVal = (char *)realloc(retVal, strlen(retVal));
+
+       return retVal;
 }
 
 int write_class_name(char * name, FILE * output)
@@ -64,19 +104,81 @@
 
 int write_class_members(JVClass* klass, FILE* output)
 {
-       int i;
+       UInt16 i;
        for(i=0;i<klass->field_count;i++)
-               jilc_field(klass,i,output);
+               write_field(klass,i,output);
        for(i=0;i<klass->method_count;i++)
-               jilc_method(klass,i,output);
+               write_method(klass,i,output);
+}
+
+int write_field_attributes(UInt16 acc_flags,FILE* output)
+{
+       fprintf(output,"%s",jilc_access_flags(acc_flags,FIELD));
+}
+
+int write_field_type(char* descriptor,FILE* output)
+{
+       fprintf(output,"%s",jilc_field_descriptor(descriptor));
+}
+
+int write_field_name(char* full_name,FILE* output)
+{
+       fprintf(output,"%s ",full_name);
+}
+
+int write_field( JVClass* klass, UInt16 index, FILE* output)
+{
+       fprintf(output,".field ");
+       write_field_attributes(klass->field_entries[index].acc_flags,output);
+       write_field_type(klass->field_entries[index].full_type,output);
+       write_field_name(klass->field_entries[index].full_name,output);
+       fprintf(output,"\n");
+}
+
+int write_method(JVClass* klass, UInt16 index, FILE* output)
+{
+       fprintf(output,".method ");
+       write_method_head(klass,index,output);
+       write_method_body(klass,index,output);
+}
+
+int write_method_head(JVClass* klass,UInt16 index,FILE* output)
+{
+       write_method_attributes(klass->method_entries[index].acc_flags,output);
+       write_call_convention(klass,index,output);
+       write_method_type(klass,index,output);
+       write_method_name(klass,index,output);
+       fprintf(output,"( ");
+       write_method_parameters(char* parameters, FILE* output);
+       fprintf(output,") ");
+       write_method_impl_attributes(klass,index,output);
+}
+
+int write_method_parameters(char* parameters, FILE* output)
+{
+}
+
+int write_method_type(klass,index,output)
+{
+}
+
+int    write_method_name(klass,index,output);
+{
 }
 
-int jilc_field( JVClass* klass, int index, FILE* output)
+int    write_method_impl_attributes(klass,index,output)
 {
+}
 
+int write_call_convention(JVClass* klass,UInt16 index,FILE* output)
+{
 }
 
-int jilc_method(JVClass* klass, int index, FILE* output)
+int write_method_attributes(UInt16 acc_flags,FILE* output)
+{
+}
+
+int write_method_body(JVClass* klass,UInt16 index,FILE* output)
 {
 }
 
@@ -91,8 +193,67 @@
 
 /* Auxiliary methods */
 
-int resolve_field_descriptor()
+char* jilc_method_descriptor(char* desriptor)
 {
+}
+
+char* jilc_field_descriptor(char* descriptor)
+{
+       int done=0,pos=0,arrCount=0,i=0;
+       char* retVal=(char *)calloc(1000,sizeof(char));
+       while(!done)
+       {
+               switch(descriptor[pos]){
+                       case 'B':
+                               strcat(retVal,"byte ");
+                               done=1;
+                               break;
+                       case 'C':
+                               strcat(retVal,"char ");
+                               done=1;
+                               break;
+                       case 'D':
+                               strcat(retVal,"double ");
+                               done=1;
+                               break;
+                       case 'F':
+                               strcat(retVal,"float ");
+                               done=1;
+                               break;
+                       case 'I':
+                               strcat(retVal,"int ");
+                               done=1;
+                               break;
+                       case 'J':
+                               strcat(retVal,"long ");
+                               done=1;
+                               break;
+                       case 'S':
+                               strcat(retVal,"short ");
+                               done=1;
+                               break;
+                       case 'Z':
+                               strcat(retVal,"boolean ");
+                               done=1;
+                               break;
+                       case 'L':
+                               
strncat(retVal,descriptor+pos+1,strcspn(descriptor+pos+1,";"));
+                               strcat(retVal," ");
+                               done=1;
+                               break;
+                       case '[':
+                               arrCount++;
+                               pos++;
+                               break;
+               }
+       }
+       for(i=0;i<arrCount;i++)
+               strcat(retVal,"[]");
+       strcat(retVal," ");
+
+       //retVal = (char *)realloc(retVal, strlen(retVal));
+               
+       return retVal;  
 }
 
 ilopcode_map jilc_opcode(jopcode_map opcode)