зеркало из https://github.com/mozilla/gecko-dev.git
1314 строки
30 KiB
C++
1314 строки
30 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
#include "ClassGen.h"
|
|
|
|
/* getType(char *constantType)
|
|
*
|
|
* function: Compares the passed string to the list of Constant Types.
|
|
* Returns the constant type of the given string.
|
|
*
|
|
*/
|
|
int getType(char *constantType) {
|
|
|
|
if (strcmp(constantType,"Class") == 0) return 7;
|
|
if (strcmp(constantType,"FieldRef") == 0) return 9;
|
|
if (strcmp(constantType,"MethodRef") == 0) return 10;
|
|
if (strcmp(constantType,"InterfaceMethodRef") == 0) return 11;
|
|
if (strcmp(constantType,"String") == 0) return 8;
|
|
if (strcmp(constantType,"Integer") == 0) return 3;
|
|
if (strcmp(constantType,"Float") == 0) return 4;
|
|
if (strcmp(constantType,"Long") == 0) return 5;
|
|
if (strcmp(constantType,"Double") == 0) return 6;
|
|
if (strcmp(constantType,"NameAndType") == 0) return 12;
|
|
if (strcmp(constantType,"Utf8") == 0) return 1;
|
|
|
|
//The type is unknown. Return 0 to cause an error.
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* getStringLength(char *line)
|
|
*
|
|
* function: Finds the length of the passed string array.
|
|
* Returns the length of the string from index 0 to '\n'.
|
|
*
|
|
*/
|
|
int getStringLength(char *line) {
|
|
|
|
int i = 0;
|
|
while (line[i] != '\0') {
|
|
i++;
|
|
};
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
/* isBlankLine(const char *line)
|
|
*
|
|
*function: Checks if the passed string is a blank line.
|
|
*Returns true/false if the string is a blank line or not.
|
|
*
|
|
*/
|
|
bool isBlankLine(const char *line) {
|
|
|
|
for (; *line; line++) {
|
|
|
|
if (!isspace(*line)) return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
/* getItem(const char *line)
|
|
*
|
|
* function: Returns the appropriate classfile item.
|
|
*
|
|
*/
|
|
int getItem(const char *line) {
|
|
|
|
if (strcmp(line,"#magic\n") == 0) return CG_MAGIC;
|
|
if (strcmp(line,"#minor_version\n") == 0) return CG_MINORVERSION;
|
|
if (strcmp(line,"#major_version\n") == 0) return CG_MAJORVERSION;
|
|
if (strcmp(line,"#constant_pool_count\n") == 0) return CG_CONSTANTPOOL;
|
|
if (strcmp(line,"#access_flags\n") == 0) return CG_ACCESSFLAGS;
|
|
if (strcmp(line,"#this_class\n") == 0) return CG_THISCLASS;
|
|
if (strcmp(line,"#super_class\n") == 0) return CG_SUPERCLASS;
|
|
if (strcmp(line,"#interfaces_count\n") == 0) return CG_INTERFACES;
|
|
if (strcmp(line,"#fields_count\n") == 0) return CG_FIELDS;
|
|
if (strcmp(line,"#methods_count\n") == 0) return CG_METHODS;
|
|
if (strcmp(line,"#attributes_count\n") == 0) return CG_ATTRIBUTES;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* getAttribute(const char *line)
|
|
*
|
|
* function: Returns the appropriate attribute.
|
|
*
|
|
*/
|
|
int getAttribute(const char *line) {
|
|
|
|
if (strcmp(line,"SourceFile") == 0) return CR_ATTRIBUTE_SOURCEFILE;
|
|
if (strcmp(line,"ConstantValue") == 0) return CR_ATTRIBUTE_CONSTANTVALUE;
|
|
if (strcmp(line,"LineNumberTable") == 0) return CR_ATTRIBUTE_LINENUMBERTABLE;
|
|
if (strcmp(line,"LocalVariableTable") == 0) return CR_ATTRIBUTE_LOCALVARIABLETABLE;
|
|
if (strcmp(line,"Code") == 0) return CR_ATTRIBUTE_CODE;
|
|
if (strcmp(line,"Exceptions") == 0) return CR_ATTRIBUTE_EXCEPTIONS;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* stripLine(char* line,int size,byte c)
|
|
*
|
|
* function: Removes the specified char from the line.
|
|
*
|
|
*/
|
|
void stripLine(char* line,int size,byte c) {
|
|
|
|
int i = 0;
|
|
int j = 0;
|
|
|
|
while ( line[i] == c ) i++;
|
|
|
|
for (j = 0; j < (size - i); j++) {
|
|
|
|
line[j] = line[j+i];
|
|
if (line[j] == '\n') break;
|
|
|
|
}
|
|
|
|
/* Empty the rest of the string. */
|
|
j++;
|
|
while ( j < size ) {
|
|
|
|
line[j] = '\0';
|
|
j++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* parseBytecodes(FILE *fp, FileWriter &writer)
|
|
*
|
|
*function: Parses and generates the bytecodes.
|
|
*
|
|
*/
|
|
void parseBytecodes(FILE *fp,FileWriter &writer) {
|
|
|
|
char line[256];
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
stripLine(line,sizeof(line),' ');
|
|
|
|
while (strcmp(line,"#end_bytecodes\n") != 0) {
|
|
|
|
/* Need to add code here. */
|
|
//printf("%s\n",line);
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
stripLine(line,sizeof(line),' ');
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* createConstantPool(FILE *fp, FileWriter &writer)
|
|
*
|
|
*function: Creates the constant pool.
|
|
*
|
|
*/
|
|
void createConstantPool(FILE *fp,FileWriter &writer) {
|
|
|
|
char line[256];
|
|
char stringTag[256];
|
|
|
|
/* Init string. */
|
|
for (int m = 0; m < 256; m++) {
|
|
|
|
line[m] = '\0';
|
|
stringTag[m] = '\0';
|
|
|
|
}
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_constant_pool */
|
|
fgets(line,sizeof(line),fp); /* #0 Reserved */
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
while (strcmp(line,"#end_constant_pool\n") != 0) {
|
|
|
|
printf("string: %s", line);
|
|
|
|
int index;
|
|
char tag;
|
|
|
|
/* Get the index and constant tag from the string read. */
|
|
sscanf(line,"\t#%i %s\n",&index,stringTag);
|
|
|
|
/* Get the constant type and generate the correct info. */
|
|
|
|
switch(getType(stringTag)) {
|
|
|
|
case CR_CONSTANT_UTF8: { /* Utf8 */
|
|
|
|
uint16 utf8Length;
|
|
char utf8[256];
|
|
|
|
/* Init utf8. */
|
|
for (int i = 0; i < 256; i++) utf8[i] = '\0';
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"%s",utf8);
|
|
|
|
tag = 1;
|
|
utf8Length = getStringLength(utf8);
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU2(&utf8Length,1);
|
|
|
|
printf("length: %i utf8: ",getStringLength(utf8));
|
|
|
|
for (int j = 0; j < getStringLength(utf8); j++) {
|
|
writer.writeU1(&utf8[j],1);
|
|
printf("%c",utf8[j]);
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
break;
|
|
}
|
|
|
|
case CR_CONSTANT_INTEGER: { /* Integer */
|
|
|
|
int tempValue;
|
|
uint32 value;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tvalue %i",&tempValue);
|
|
value = (uint32)tempValue;
|
|
|
|
tag = 3;
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU4(&value,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_CONSTANT_FLOAT: { /* Float */
|
|
int s,e,m;
|
|
uint32 s32,e32,m32;
|
|
uint32 value;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
/* This will need to be refined later on. */
|
|
sscanf(line,"\tvalue s %i e %i m %i",&s,&e,&m);
|
|
e32 = (uint32)e;
|
|
m32 = (uint32)m;
|
|
|
|
tag = 4;
|
|
|
|
/* Compute value. */
|
|
if (s == 1) s32 = 0;
|
|
else s32 = 1;
|
|
value = (s32 << 31) | (e32 << 23) | (m32 & 0x00ffffff);
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU4(&value,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_CONSTANT_LONG: { /* Long */
|
|
|
|
int tempHi,tempLo;
|
|
uint32 hi,lo;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
/* This will need to be refined later on. */
|
|
sscanf(line,"\tvalue hi %i lo %i",&tempHi,&tempLo);
|
|
hi = (uint32)tempHi;
|
|
lo = (uint32)tempLo;
|
|
|
|
tag = 5;
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU4(&hi,1);
|
|
writer.writeU4(&lo,1);
|
|
|
|
break;
|
|
}
|
|
|
|
case CR_CONSTANT_DOUBLE: { /* Double */
|
|
|
|
char data[8];
|
|
int byte;
|
|
|
|
/* This will need to be refined later on. */
|
|
fscanf(fp,"\tvalue ");
|
|
for (int i = 0; i < 7; i++) {
|
|
fscanf(fp,"%x ",&byte);
|
|
data[i] = byte;
|
|
}
|
|
fscanf(fp,"%x",&byte);
|
|
data[7] = byte;
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
tag = 6;
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU1(data,8);
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_CONSTANT_CLASS: { /* Class */
|
|
|
|
int tempTagInfo;
|
|
uint16 tagInfo;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
sscanf(line,"\tindex %i",&tempTagInfo);
|
|
tagInfo = (uint16)tempTagInfo;
|
|
|
|
tag = 7;
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU2(&tagInfo,1);
|
|
|
|
break;
|
|
}
|
|
|
|
case CR_CONSTANT_STRING: { /* String */
|
|
|
|
int tempTagInfo;
|
|
uint16 tagInfo;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
sscanf(line,"\tindex %i",&tempTagInfo);
|
|
tagInfo = (uint16)tempTagInfo;
|
|
|
|
tag = 8;
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU2(&tagInfo,1);
|
|
|
|
break;
|
|
}
|
|
|
|
case CR_CONSTANT_FIELDREF: { /* FieldRef */
|
|
|
|
int tempClassIndex, tempTypeIndex;
|
|
uint16 classIndex;
|
|
uint16 typeIndex;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tclassIndex %i typeIndex %i",&tempClassIndex,&tempTypeIndex);
|
|
classIndex = (uint16)tempClassIndex;
|
|
typeIndex = (uint16)tempTypeIndex;
|
|
|
|
tag = 9;
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU2(&classIndex,1);
|
|
writer.writeU2(&typeIndex,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_CONSTANT_METHODREF: { /* MethodRef */
|
|
|
|
int tempClassIndex, tempTypeIndex;
|
|
uint16 classIndex;
|
|
uint16 typeIndex;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tclassIndex %i typeIndex %i",&tempClassIndex,&tempTypeIndex);
|
|
classIndex = (uint16)tempClassIndex;
|
|
typeIndex = (uint16)tempTypeIndex;
|
|
|
|
tag = 10;
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU2(&classIndex,1);
|
|
writer.writeU2(&typeIndex,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_CONSTANT_INTERFACEMETHODREF: { /* InterfaceMethodRef */
|
|
|
|
int tempClassIndex, tempTypeIndex;
|
|
uint16 classIndex;
|
|
uint16 typeIndex;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tclassIndex %i typeIndex %i",&tempClassIndex,&tempTypeIndex);
|
|
classIndex = (uint16)tempClassIndex;
|
|
typeIndex = (uint16)tempTypeIndex;
|
|
|
|
tag = 11;
|
|
|
|
printf("InterfaceMethodRef classIndex: %i typeIndex: %i\n",classIndex,typeIndex);
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU2(&classIndex,1);
|
|
writer.writeU2(&typeIndex,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_CONSTANT_NAMEANDTYPE: { /* NameAndType */
|
|
|
|
int tempNameIndex, tempDescIndex;
|
|
uint16 nameIndex;
|
|
uint16 descIndex;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tnameIndex %i descIndex %i",&tempNameIndex,&tempDescIndex);
|
|
nameIndex = (uint16)tempNameIndex;
|
|
descIndex = (uint16)tempDescIndex;
|
|
|
|
tag = 12;
|
|
|
|
writer.writeU1(&tag,1);
|
|
writer.writeU2(&nameIndex,1);
|
|
writer.writeU2(&descIndex,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: {
|
|
|
|
printf("Error: problem with constantpool\n");
|
|
printf("%s",line);
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Read next line. */
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
printf("next line: %s\n",line);
|
|
|
|
}
|
|
|
|
printf("Done with constant pool.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* createInterfaces(FILE *fp, FileWriter &writer)
|
|
*
|
|
*function: Creates the interfaces structure.
|
|
*
|
|
*/
|
|
void createInterfaces(FILE *fp,FileWriter &writer) {
|
|
|
|
char line[256];
|
|
int tempIndex;
|
|
uint16 index;
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_interfaces */
|
|
fgets(line,sizeof(line),fp); /* #<number> */
|
|
|
|
while (strcmp(line,"#end_interfaces\n") != 0) {
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tindex %i\n",&tempIndex);
|
|
index = (uint16)tempIndex;
|
|
|
|
writer.writeU2(&index, 1);
|
|
|
|
/* Read next line. */
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* createFields(FILE *fp, FileWriter &writer, ClassFileReader &reader)
|
|
*
|
|
*function: Creates the fields structure.
|
|
*
|
|
*/
|
|
void createFields(FILE *fp,FileWriter &writer,ClassFileReader &reader) {
|
|
|
|
char line[256];
|
|
uint16 accessFlags;
|
|
uint16 nameIndex;
|
|
uint16 descIndex;
|
|
uint16 attrCount;
|
|
int tempFlags, tempNameIndex, tempDescIndex, tempCount;
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_fields */
|
|
fgets(line,sizeof(line),fp); /* #<number> */
|
|
|
|
while (strcmp(line,"#end_fields\n") != 0) {
|
|
|
|
/* Access flags */
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\taccess_flags %x\n",&tempFlags);
|
|
accessFlags = (uint16)tempFlags;
|
|
writer.writeU2(&accessFlags,1);
|
|
|
|
/* Name/Descriptor index */
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tnameIndex %i descIndex %i\n",&tempNameIndex,&tempDescIndex);
|
|
nameIndex = (uint16)tempNameIndex;
|
|
descIndex = (uint16)tempDescIndex;
|
|
writer.writeU2(&nameIndex,1);
|
|
writer.writeU2(&descIndex,1);
|
|
|
|
/* Attributes count */
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tattributes_count %i\n",&tempCount);
|
|
attrCount = (uint16)tempCount;
|
|
writer.writeU2(&attrCount,1);
|
|
|
|
/* Attributes structure */
|
|
if ( tempCount > 0 ) {
|
|
|
|
char attribute[256];
|
|
int attrIndex;
|
|
|
|
/* Init attribute. */
|
|
for (int i = 0; i < 256; i++) attribute[i] = '\0';
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_attributes */
|
|
fgets(line,sizeof(line),fp); /* #<number> Attribute */
|
|
|
|
while (strcmp(line,"\t#end_attributes\n") != 0) {
|
|
|
|
/* Get the attribute string. */
|
|
sscanf(line,"\t\t#%i %s\n",&attrIndex,attribute);
|
|
|
|
createAttributes(fp,writer,reader,getAttribute(attribute));
|
|
|
|
/* Read the next line. */
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* createMethods(FILE *fp, FileWriter &writer,ClassFileReader &reader)
|
|
*
|
|
*function: Creates the methods structure.
|
|
*
|
|
*/
|
|
void createMethods(FILE *fp,FileWriter &writer,ClassFileReader &reader) {
|
|
|
|
char line[256];
|
|
uint16 accessFlags;
|
|
uint16 nameIndex;
|
|
uint16 descIndex;
|
|
uint16 attrCount;
|
|
int tempFlags, tempNameIndex, tempDescIndex, tempCount;
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_methods */
|
|
fgets(line,sizeof(line),fp); /* #<number> */
|
|
|
|
while (strcmp(line,"#end_methods\n") != 0) {
|
|
|
|
/* Access flags */
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\taccess_flags %i\n",&tempFlags);
|
|
accessFlags = (uint16)tempFlags;
|
|
writer.writeU2(&accessFlags,1);
|
|
|
|
/* Name/Descriptor index */
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tnameIndex %i descIndex %i\n",&tempNameIndex,&tempDescIndex);
|
|
nameIndex = (uint16)tempNameIndex;
|
|
descIndex = (uint16)tempDescIndex;
|
|
writer.writeU2(&nameIndex,1);
|
|
writer.writeU2(&descIndex,1);
|
|
|
|
/* Attributes count */
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"\tattributes_count %i\n",&tempCount);
|
|
attrCount = (uint16)tempCount;
|
|
writer.writeU2(&attrCount,1);
|
|
|
|
/* Attributes structure */
|
|
if (tempCount > 0) {
|
|
|
|
char attribute[256];
|
|
int attrIndex;
|
|
|
|
/* Init attribute. */
|
|
for (int i = 0; i < 256; i++) attribute[i] = '\0';
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_attributes */
|
|
fgets(line,sizeof(line),fp); /* #<number> Attribute */
|
|
|
|
while (strcmp(line,"\t#end_attributes\n") != 0) {
|
|
|
|
/* Get the attribute string. */
|
|
sscanf(line,"\t\t#%i %s\n",&attrIndex,attribute);
|
|
|
|
createAttributes(fp,writer,reader,getAttribute(attribute));
|
|
|
|
/* Read the next line. */
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Read next line. */
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* createAttributes(FILE *fp, FileWriter &writer,ClassFileReader &reader,int attribute)
|
|
*
|
|
*function: Creates the attribute structure.
|
|
*
|
|
*/
|
|
void createAttributes(FILE *fp,FileWriter &writer,ClassFileReader &reader,int attribute) {
|
|
|
|
char line[256];
|
|
|
|
/* Init attribute. */
|
|
for (int i = 0; i < 256; i++) line[i] = '\0';
|
|
|
|
/* Generate the correct attribute. */
|
|
switch(attribute) {
|
|
|
|
case CR_ATTRIBUTE_SOURCEFILE: { /* SourceFile */
|
|
|
|
uint16 nameIndex;
|
|
uint32 length;
|
|
uint16 index;
|
|
int tempNameIndex, tempLength, tempIndex;
|
|
|
|
fgets(line,sizeof(line),fp); /* nameIndex <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"nameIndex %i\n",&tempNameIndex);
|
|
nameIndex = (uint16)tempNameIndex;
|
|
writer.writeU2(&nameIndex,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"length %i\n",&tempLength);
|
|
length = (uint16)tempLength;
|
|
writer.writeU4(&length,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* index <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"index %i\n",&tempIndex);
|
|
index = (uint16)tempIndex;
|
|
writer.writeU2(&index,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_ATTRIBUTE_CONSTANTVALUE: { /* Constant Value */
|
|
|
|
uint16 nameIndex;
|
|
uint32 length;
|
|
uint16 index;
|
|
int tempNameIndex, tempLength, tempIndex;
|
|
|
|
fgets(line,sizeof(line),fp); /* nameIndex <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"nameIndex %i\n",&tempNameIndex);
|
|
nameIndex = (uint16)tempNameIndex;
|
|
writer.writeU2(&nameIndex,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"length %i\n",&tempLength);
|
|
length = (uint16)tempLength;
|
|
writer.writeU4(&length,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* index <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"index %i\n",&tempIndex);
|
|
index = (uint16)tempIndex;
|
|
writer.writeU2(&index,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_ATTRIBUTE_LINENUMBERTABLE: { /* LineNumberTable Value */
|
|
|
|
uint16 nameIndex;
|
|
uint32 length;
|
|
uint16 lineNoTableLength;
|
|
int tempNameIndex, tempLength, tempCount;
|
|
|
|
fgets(line,sizeof(line),fp); /* nameIndex <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"nameIndex %i\n",&tempNameIndex);
|
|
nameIndex = (uint16)tempNameIndex;
|
|
writer.writeU2(&nameIndex,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"length %i\n",&tempLength);
|
|
length = (uint32)tempLength;
|
|
writer.writeU4(&length,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* table_length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"table_length %i\n",&tempCount);
|
|
lineNoTableLength = (uint16)tempCount;
|
|
writer.writeU2(&lineNoTableLength,1);
|
|
|
|
/* Line number table. */
|
|
if (tempCount > 0) {
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_line_number_table */
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
fgets(line,sizeof(line),fp); /* #<index> */
|
|
|
|
while (strcmp(line,"#end_line_number_table\n") != 0) {
|
|
|
|
uint16 startPc;
|
|
uint16 lineNo;
|
|
int temp;
|
|
|
|
fgets(line,sizeof(line),fp); /* start_pc <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"start_pc %i\n",&temp);
|
|
startPc = (uint16)temp;
|
|
writer.writeU2(&startPc,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* line_number <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"line_number %i\n",&temp);
|
|
lineNo = (uint16)temp;
|
|
writer.writeU2(&lineNo,1);
|
|
|
|
/* Read next entry. */
|
|
fgets(line,sizeof(line),fp);
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_ATTRIBUTE_LOCALVARIABLETABLE: { /* LocalVariableTable */
|
|
|
|
uint16 nameIndex;
|
|
uint32 length;
|
|
uint16 localVarTableLength;
|
|
int tempNameIndex, tempLength, tempCount;
|
|
|
|
fgets(line,sizeof(line),fp); /* nameIndex <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"nameIndex %i\n",&tempNameIndex);
|
|
nameIndex = (uint16)tempNameIndex;
|
|
writer.writeU2(&nameIndex,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"length %i\n",&tempLength);
|
|
length = (uint32)tempLength;
|
|
writer.writeU4(&length,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* table_length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"table_length %i\n",&tempCount);
|
|
localVarTableLength = (uint16)tempCount;
|
|
writer.writeU2(&localVarTableLength,1);
|
|
|
|
/* Local variable table. */
|
|
if (tempCount > 0) {
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_local_variable_table */
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
fgets(line,sizeof(line),fp); /* #<index> */
|
|
|
|
while (strcmp(line,"#end_local_variable_table\n") != 0) {
|
|
|
|
uint16 startPc;
|
|
uint16 length;
|
|
uint16 nameIndex;
|
|
uint16 descIndex;
|
|
uint16 index;
|
|
int temp;
|
|
|
|
fgets(line,sizeof(line),fp); /* start_pc <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"start_pc %i\n",&temp);
|
|
startPc = (uint16)temp;
|
|
writer.writeU2(&startPc,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"length %i\n",&temp);
|
|
length = (uint16)temp;
|
|
writer.writeU2(&length,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* nameIndex <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"nameIndex %i\n",&temp);
|
|
nameIndex = (uint16)temp;
|
|
writer.writeU2(&nameIndex,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* descIndex <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"descIndex %i\n",&temp);
|
|
descIndex = (uint16)temp;
|
|
writer.writeU2(&descIndex,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* index <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"index %i\n",&temp);
|
|
index = (uint16)temp;
|
|
writer.writeU2(&index,1);
|
|
|
|
/* Read next entry. */
|
|
fgets(line,sizeof(line),fp);
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_ATTRIBUTE_CODE: { /* Code */
|
|
|
|
uint16 nameIndex;
|
|
uint32 length;
|
|
uint16 maxStack;
|
|
uint16 maxLocals;
|
|
uint32 codeLength;
|
|
uint16 exceptionTableLength;
|
|
uint16 attrCount;
|
|
int temp, tempCount, bytecodeLength;
|
|
|
|
fgets(line,sizeof(line),fp); /* nameIndex <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"nameIndex %i\n",&temp);
|
|
nameIndex = (uint16)temp;
|
|
writer.writeU2(&nameIndex,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"length %i\n",&temp);
|
|
length = (uint32)temp;
|
|
writer.writeU4(&length,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* max_stack <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"max_stack %i\n",&temp);
|
|
maxStack = (uint16)temp;
|
|
writer.writeU2(&maxStack,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* maxLocals <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"max_locals %i\n",&temp);
|
|
maxLocals = (uint16)temp;
|
|
writer.writeU2(&maxLocals,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* code_length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"code_length %i\n",&bytecodeLength);
|
|
codeLength = (uint32)bytecodeLength;
|
|
writer.writeU4(&codeLength,1);
|
|
|
|
/* Temp way for handling bytecodes. */
|
|
if ( bytecodeLength > 0 ) {
|
|
|
|
unsigned int bytecodeFromFile;
|
|
unsigned char bytecode;
|
|
|
|
fgetc(fp);
|
|
fgetc(fp);
|
|
fscanf(fp,"#bytecodes ");
|
|
|
|
/* This needs to be refined. */
|
|
for (int i = 0; i < bytecodeLength - 1; i++) {
|
|
|
|
fscanf(fp,"%x ",&bytecodeFromFile);
|
|
printf("bytcode: %x\n",bytecode);
|
|
bytecode = (unsigned char) bytecodeFromFile;
|
|
writer.writeU1((char *)(&bytecode),1);
|
|
|
|
}
|
|
fscanf(fp,"%x",&bytecodeFromFile);
|
|
printf("bytcode: %x\n",bytecodeFromFile);
|
|
bytecode = (unsigned char) bytecodeFromFile;
|
|
writer.writeU1((char *)(&bytecode),1);
|
|
fgets(line,sizeof(line),fp);
|
|
|
|
}
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_bytecodes */
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
/* Bytecodes */
|
|
parseBytecodes(fp,writer);
|
|
|
|
fgets(line,sizeof(line),fp); /* exception_table_length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"exception_table_length %i\n",&tempCount);
|
|
exceptionTableLength = (uint16)tempCount;
|
|
writer.writeU2(&exceptionTableLength,1);
|
|
|
|
/* Create exception table length. */
|
|
if ( tempCount > 0 ) {
|
|
|
|
uint16 startPc;
|
|
uint16 endPc;
|
|
uint16 handlerPc;
|
|
uint16 catchType;
|
|
int temp1, temp2;
|
|
|
|
fgets(line,sizeof(line),fp); /* start_pc <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"start_pc %i end_pc %i\n",&temp1,&temp2);
|
|
startPc = (uint16)temp;
|
|
endPc = (uint16)temp;
|
|
writer.writeU2(&startPc,1);
|
|
writer.writeU2(&endPc,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* handler_pc <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"handler_pc %i\n",&temp1);
|
|
handlerPc = (uint16)temp1;
|
|
writer.writeU2(&handlerPc,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* catch_type <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"catch_type %i\n",&temp1);
|
|
catchType = (uint16)temp1;
|
|
writer.writeU2(&catchType,1);
|
|
|
|
}
|
|
|
|
fgets(line,sizeof(line),fp); /* attributes_count <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"attributes_count %i\n",&tempCount);
|
|
attrCount = (uint16)tempCount;
|
|
writer.writeU2(&attrCount,1);
|
|
|
|
/* Attributes structure */
|
|
if (tempCount > 0) {
|
|
|
|
char attribute[256];
|
|
int attrIndex;
|
|
|
|
|
|
/* Init attribute. */
|
|
for (int j = 0; j < 256; j++) attribute[j] = '\0';
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_attributes */
|
|
fgets(line,sizeof(line),fp); /* #<number> Attribute */
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
while (strcmp(line,"#end_attributes\n") != 0) {
|
|
|
|
/* Get the attribute string. */
|
|
sscanf(line,"#%i %s\n",&attrIndex,attribute);
|
|
|
|
createAttributes(fp,writer,reader,getAttribute(attribute));
|
|
|
|
/* Read the next line. */
|
|
fgets(line,sizeof(line),fp);
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CR_ATTRIBUTE_EXCEPTIONS: { /* Exceptions */
|
|
|
|
uint16 nameIndex;
|
|
uint32 length;
|
|
uint16 numExceptions;
|
|
int tempNameIndex, tempLength, tempCount;
|
|
|
|
fgets(line,sizeof(line),fp); /* nameIndex <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"nameIndex %i\n",&tempNameIndex);
|
|
nameIndex = (uint16)tempNameIndex;
|
|
writer.writeU2(&nameIndex,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* length <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"length %i\n",&tempLength);
|
|
length = (uint32)tempLength;
|
|
writer.writeU4(&length,1);
|
|
|
|
fgets(line,sizeof(line),fp); /* exceptions_count <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"exceptions_count %i\n",&tempCount);
|
|
numExceptions = (uint16)tempCount;
|
|
writer.writeU2(&numExceptions,1);
|
|
|
|
/* Excpetion index table. */
|
|
if (tempCount > 0) {
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_exception_index_table */
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
fgets(line,sizeof(line),fp); /* #<index> */
|
|
|
|
while (strcmp(line,"#end_exception_index_table\n") != 0) {
|
|
|
|
uint16 index;
|
|
int temp;
|
|
|
|
fgets(line,sizeof(line),fp); /* index <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"index %i\n",&temp);
|
|
index = (uint16)temp;
|
|
writer.writeU2(&index,1);
|
|
|
|
/* Read next entry. */
|
|
fgets(line,sizeof(line),fp);
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: { /* Ignore everything else. */
|
|
|
|
printf("Error: problems attribute\n");
|
|
printf("%s",line);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* createClass(FILE *fp,FileWriter &writer,ClassFileReader &reader)
|
|
*
|
|
* function: Create the class file.
|
|
*
|
|
*/
|
|
void createClass(FILE *fp,FileWriter &writer,ClassFileReader &reader) {
|
|
|
|
char line[256];
|
|
|
|
/* Read line by line. */
|
|
while (fgets(line,sizeof(line),fp) != NULL) {
|
|
|
|
if (!isBlankLine(line)) {
|
|
|
|
switch (getItem(line)) {
|
|
|
|
case CG_MAGIC: { /* Magic */
|
|
|
|
uint32 magic;
|
|
|
|
fgets(line, sizeof(line), fp);
|
|
sscanf(line,"%x\n",&magic);
|
|
writer.writeU4(&magic,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_MINORVERSION: { /* Minor version */
|
|
|
|
int tempMinor;
|
|
uint16 minor;
|
|
|
|
fgets(line, sizeof(line), fp);
|
|
sscanf(line,"%i\n",&tempMinor);
|
|
minor = (uint16)tempMinor;
|
|
writer.writeU2(&minor,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_MAJORVERSION: { /* Major version */
|
|
|
|
int tempMajor;
|
|
uint16 major;
|
|
|
|
fgets(line, sizeof(line), fp);
|
|
sscanf(line,"%i\n",&tempMajor);
|
|
major = (uint16)tempMajor;
|
|
writer.writeU2(&major,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_CONSTANTPOOL: { /* Constant pool */
|
|
|
|
int tempCount;
|
|
uint16 constantpoolcount;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"%i\n",&tempCount);
|
|
constantpoolcount = (uint16)tempCount;
|
|
writer.writeU2(&constantpoolcount,1);
|
|
|
|
createConstantPool(fp,writer);
|
|
|
|
printf("Done with ConstantPool\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_ACCESSFLAGS: { /* Access flags */
|
|
|
|
int tempFlags;
|
|
uint16 accessFlags;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"%i\n",&tempFlags);
|
|
accessFlags = (uint16)tempFlags;
|
|
writer.writeU2(&accessFlags,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_THISCLASS: { /* This class */
|
|
|
|
int tempClass;
|
|
uint16 thisClass;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"%i\n",&tempClass);
|
|
thisClass = (uint16)tempClass;
|
|
writer.writeU2(&thisClass,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_SUPERCLASS: { /* Super class */
|
|
|
|
int tempClass;
|
|
uint16 superClass;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"%i\n",&tempClass);
|
|
superClass = (uint16)tempClass;
|
|
writer.writeU2(&superClass,1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_INTERFACES: { /* Interfaces */
|
|
|
|
int tempCount;
|
|
uint16 interfacesCount;
|
|
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"%i\n",&tempCount);
|
|
interfacesCount = (uint16)tempCount;
|
|
writer.writeU2(&interfacesCount,1);
|
|
|
|
if ( tempCount > 0 ) createInterfaces(fp,writer);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_FIELDS: { /* Fields */
|
|
|
|
int tempCount;
|
|
uint16 fieldsCount;
|
|
|
|
/* Fields count */
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"%i\n",&tempCount);
|
|
fieldsCount = (uint16)tempCount;
|
|
writer.writeU2(&fieldsCount,1);
|
|
|
|
if ( tempCount > 0 ) createFields(fp,writer,reader);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_METHODS: { /* Methods */
|
|
|
|
int tempCount;
|
|
uint16 methodsCount;
|
|
|
|
/* Mehtods count */
|
|
fgets(line,sizeof(line),fp);
|
|
sscanf(line,"%i\n",&tempCount);
|
|
methodsCount = (uint16)tempCount;
|
|
writer.writeU2(&methodsCount,1);
|
|
|
|
if ( tempCount > 0 ) createMethods(fp,writer,reader);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CG_ATTRIBUTES: { /* Attributes */
|
|
|
|
int tempCount;
|
|
uint16 attrCount;
|
|
|
|
/* Attributes count */
|
|
fgets(line,sizeof(line),fp); /* <value> */
|
|
stripLine(line,sizeof(line),'\t');
|
|
sscanf(line,"%i\n",&tempCount);
|
|
attrCount = (uint16)tempCount;
|
|
writer.writeU2(&attrCount,1);
|
|
|
|
/* Attributes structure */
|
|
if (tempCount > 0) {
|
|
|
|
char attribute[256];
|
|
int attrIndex;
|
|
|
|
/* Init attribute. */
|
|
for (int i = 0; i < 256; i++) attribute[i] = '\0';
|
|
|
|
fgets(line,sizeof(line),fp); /* #begin_attributes */
|
|
fgets(line,sizeof(line),fp); /* #<number> Attribute */
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
while (strcmp(line,"#end_attributes\n") != 0) {
|
|
|
|
/* Get the attribute string. */
|
|
sscanf(line,"#%i %s\n",&attrIndex,attribute);
|
|
|
|
createAttributes(fp,writer,reader,getAttribute(attribute));
|
|
|
|
/* Read the next line. */
|
|
fgets(line,sizeof(line),fp);
|
|
stripLine(line,sizeof(line),'\t');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
default: { /* Ignore other strings read. */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|