classfile.c

用于移动设备上的java虚拟机源代码

/*
 * @(#)classfile.c	1.2 02/07/25 @(#)
 *
 * Copyright (c) 2001 Sun Microsystems, Inc.  All rights reserved.
 * PROPRIETARY/CONFIDENTIAL
 * Use is subject to license terms.
 */

/*
 * Simple representation of a single class file.  Does not (currently)
 * include support for the defined attributes, but represents them as
 * unformatted bytes instead.
 */
#include <stdio.h>
#include <stdlib.h>
#include "classfile.h"

static u1 read1(FILE *f);
static u2 read2(FILE *f);
static u4 read4(FILE *f);
static cp_info *readConstantPool(int cnt, FILE *f);
static u2 *readInterfaces(int cnt, FILE *f);
static attribute_info * readAttributes(int cnt, FILE *f);
static field_info *readFieldsAndMethods(int cnt, FILE *f);

/*
 * Read a class into memory from an open file pointer.
 */
ClassFile *readClass(FILE *f)
{
    ClassFile *cf;
    u4 magic = read4(f);

    if (magic != 0xCAFEBABE) {
        return NULL;
    }

    cf = malloc(sizeof(ClassFile));

    cf->magic               = magic;
    cf->minor_version       = read2(f);
    cf->major_version       = read2(f);
    cf->constant_pool_count = read2(f);
    cf->constant_pool       = readConstantPool(cf->constant_pool_count, f);
    cf->access_flags        = read2(f);
    cf->this_class          = read2(f);
    cf->super_class         = read2(f);
    cf->interfaces_count    = read2(f);
    cf->interfaces          = readInterfaces(cf->interfaces_count, f);
    cf->fields_count        = read2(f);
    cf->fields              = readFieldsAndMethods(cf->fields_count, f);
    cf->methods_count       = read2(f);
    cf->methods             = readFieldsAndMethods(cf->methods_count, f);
    cf->attributes_count    = read2(f);
    cf->attributes          = readAttributes(cf->attributes_count, f);

    return cf;
}

static u1 read1(FILE *f)
{
    return (u1) (getc(f) & 0xff);
}

static u2 read2(FILE *f)
{
    u2 hi = (u2) read1(f);
    u2 lo = (u2) read1(f);
    return (hi << 8) | lo;
}

static u4 read4(FILE *f)
{
    u4 hi = (u4) read2(f);
    u4 lo = (u4) read2(f);
    return (hi << 16) | lo;
}

static cp_info *readConstantPool(int cnt, FILE *f)
{
    if (cnt == 0) {
        return NULL;
    } else {
        cp_info *cp = malloc(sizeof(cp_info) * cnt);
        cp_info *this = cp + 1; /* zeroth constant unused */
        int nbytes;

        while (--cnt > 0) {
            u1 tag = read1(f);
            switch (tag) {
            case CONSTANT_Class:
                this->Class_info.tag = tag;
                this->Class_info.name_index = read2(f);
                break;

            case CONSTANT_Fieldref:
            case CONSTANT_Methodref:
            case CONSTANT_InterfaceMethodref:
                this->Fieldref_info.tag = tag;
                this->Fieldref_info.class_index = read2(f);
                this->Fieldref_info.name_and_type_index = read2(f);
                break;

            case CONSTANT_String:
                this->String_info.tag = tag;
                this->String_info.string_index = read2(f);
                break;

            case CONSTANT_Integer:
            case CONSTANT_Float:
                this->Integer_info.tag = tag;
                this->Integer_info.bytes = read4(f);
                break;

            case CONSTANT_Long:
            case CONSTANT_Double:
                this->Long_info.tag = tag;
                this->Long_info.high_bytes = read4(f);
                this->Long_info.low_bytes = read4(f);

                ++this;         /* these take two slots.  Sigh. */
                --cnt;
                break;

            case CONSTANT_NameAndType:
                this->NameAndType_info.tag = tag;
                this->NameAndType_info.name_index = read2(f);
                this->NameAndType_info.descriptor_index = read2(f);
                break;

            case CONSTANT_Utf8:
                this->Utf8_info.tag = tag;
                this->Utf8_info.length = read2(f);
                if (this->Utf8_info.length == 0) {
                  this->Utf8_info.bytes = NULL;
                } else {
                  this->Utf8_info.bytes = malloc(this->Utf8_info.length);
                  /* REMIND: theoretically we could get a short read! */
                  nbytes = fread(this->Utf8_info.bytes, 1,
                                 this->Utf8_info.length, f);
                }
                break;

            default:
                fprintf(stderr, "Bad constant tag value %d\n", tag);
            }

            ++this;
        }

        return cp;
    }
}

static u2 *
readInterfaces(int cnt, FILE *f)
{
    if (cnt == 0) {
        return NULL;
    } else {
        u2 *data = malloc(sizeof(u2) * cnt);
        u2 *this = data;
        while (--cnt >= 0) {
            *this++ = read2(f);
        }

        return data;
    }
}

static attribute_info *
readAttributes(int cnt, FILE *f)
{
    if (cnt == 0) {
        return NULL;
    } else {
        attribute_info *ai = malloc(sizeof(attribute_info) * cnt);
        attribute_info *this = ai;

        while (--cnt >= 0) {
            this->attribute_name_index = read2(f);
            this->attribute_length = read4(f);
            this->info = malloc(this->attribute_length);
            /* REMIND: beware of short read! */
            fread(this->info, 1, this->attribute_length, f);

            ++this;
        }

        return ai;
    }
}

static field_info *
readFieldsAndMethods(int cnt, FILE *f)
{
    if (cnt == 0) {
        return NULL;
    } else {
        field_info *fi = malloc(sizeof(field_info) * cnt);
        field_info *this = fi;

        while (--cnt >= 0) {
            this->access_flags = read2(f);
            this->name_index = read2(f);
            this->descriptor_index = read2(f);
            this->attributes_count = read2(f);
            this->attributes = readAttributes(this->attributes_count, f);

            ++this;
        }

        return fi;
    }
}