tools/GenerateCharacter/check_class.c.template

/*
 * Copyright (c) 2002, 2008, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/* This file was generated AUTOMATICALLY from a template file Wed Jun 17 10:43:47 PDT 1998 */

/*-
 *      code for verifying the date in a ClassClass structure for internal
 *      consistency.
 */

#include <ctype.h>

#include "oobj.h"
#include "interpreter.h"
#include "bool.h"
#include "utf.h"
#include "tree.h"

extern bool_t verify_class_codes(ClassClass *cb);

static bool_t verify_constant_pool(ClassClass *cb);

static bool_t is_legal_fieldname(ClassClass *cb, char *name, int type);
static bool_t is_legal_method_signature(ClassClass *cb, char *name, char *signature);
static bool_t is_legal_field_signature(ClassClass *cb, char *name, char *signature);

static char *skip_over_fieldname(char *name, bool_t slash_okay);
static char *skip_over_field_signature(char *name, bool_t void_okay);

static void CCerror (ClassClass *cb, char *format, ...);


/* Argument for is_legal_fieldname */
enum { LegalClass, LegalField, LegalMethod };


bool_t
VerifyClass(ClassClass *cb)
{
    bool_t result = TRUE;
    struct methodblock *mb;
    struct fieldblock *fb;
    int i;
    if (CCIs(cb, Verified))
    return TRUE;
    if (!verify_constant_pool(cb))
        return FALSE;
    /* Make sure all the method names and signatures are okay */
    for (i = cbMethodsCount(cb), mb = cbMethods(cb); --i >= 0; mb++) {
    char *name = mb->fb.name;
    char *signature = mb->fb.signature;
    if (! (is_legal_fieldname(cb, name, LegalMethod)  &&
           is_legal_method_signature(cb, name, signature)))
        result = FALSE;
    }
    /* Make sure all the field names and signatures are okay */
    for (i = cbFieldsCount(cb), fb = cbFields(cb); --i >= 0; fb++) {
    if (!  (is_legal_fieldname(cb, fb->name, LegalField) &&
        is_legal_field_signature(cb, fb->name, fb->signature)))
        result = FALSE;
    }
    /* Make sure we are not overriding any final methods or classes*/
    if (cbIsInterface(cb)) {
    struct methodblock *mb;
    if ((cbSuperclass(cb) == NULL) ||
        (cbSuperclass(cb) != classJavaLangObject)) {
        CCerror(cb, "Interface %s has bad superclass", cbName(cb));
        result = FALSE;
    }
    for (i = cbMethodsCount(cb), mb = cbMethods(cb); --i >= 0; mb++) {
        if (mb->fb.access & ACC_STATIC) {
        if (mb->fb.name[0] != '<') {
            /* Only internal methods can be static */
            CCerror(cb, "Illegal static method %s in interface %s",
                mb->fb.name, cbName(cb));
            result = FALSE;
        }
        }
    }
    } else if (cbSuperclass(cb)) {
    ClassClass *super_cb;
    unsigned bitvector_size = (unsigned)(cbMethodTableSize(cb) + 31) >> 5;
    long *bitvector = sysCalloc(bitvector_size, sizeof(long));
    for (super_cb = cbSuperclass(cb); ; super_cb = cbSuperclass(super_cb)) {
        if (cbAccess(super_cb) & ACC_FINAL) {
        CCerror(cb, "Class %s is subclass of final class %s",
            cbName(cb), cbName(super_cb));
        result = FALSE;
        }
        mb = cbMethods(super_cb);
        for (i = cbMethodsCount(super_cb); --i >= 0; mb++) {
        if (mb->fb.access & ACC_FINAL) {
            unsigned offset = mb->fb.u.offset;
            bitvector[offset >> 5] |= (1 << (offset & 0x1F));
        }
        }
        if (cbSuperclass(super_cb) == NULL) break;
    }
    for (i = cbMethodsCount(cb), mb = cbMethods(cb); --i >= 0; mb++) {
        unsigned offset = mb->fb.u.offset;
        if ((offset > 0)
           && bitvector[offset >> 5] & (1 << (offset & 0x1F))) {
        CCerror(cb, "Class %s overrides final method %s.%s",
            cbName(cb), mb->fb.name, mb->fb.signature);
        result = FALSE;
        }
    }
    sysFree(bitvector);
    } else if (cb != classJavaLangObject) {
    CCerror(cb, "Class %s does not have superclass", cbName(cb));
    result = FALSE;
    }

    if (result)
    result = verify_class_codes(cb);
    if (result)
    CCSet(cb, Verified);
    return result;
}


static bool_t
verify_constant_pool(ClassClass *cb)
{
    union cp_item_type *cp = cbConstantPool(cb);
    long cp_count = cbConstantPoolCount(cb);
    unsigned char *type_table;
    int i, type;

    const int utf8_resolved = (CONSTANT_Utf8 | CONSTANT_POOL_ENTRY_RESOLVED);

    if (cp_count == 0) /* Primitive classes */
        return TRUE;
    type_table = cp[CONSTANT_POOL_TYPE_TABLE_INDEX].type;
    /* Let's make two quick passes over the constant pool. The first one
     * checks that everything is of the right type.            */
    for (i = 1; i < cp_count; i++) {
    switch(type = type_table[i]) {
        case CONSTANT_String:
        case CONSTANT_Class: {
        int index = cp[i].i;
        if (   (index < 1)
               || (index >= cp_count)
               || (type_table[index] != utf8_resolved)) {
            CCerror(cb, "Bad index in constant pool #%d", i);
            return FALSE;
        }
        break;
        }

        case CONSTANT_String | CONSTANT_POOL_ENTRY_RESOLVED:
        /* This can only happen if a string is the "initial" value of
         * some final static String.  We assume that the checking has
         * already been done.
         */
        break;

        case CONSTANT_Fieldref:
        case CONSTANT_Methodref:
        case CONSTANT_InterfaceMethodref:
        case CONSTANT_NameAndType: {
        unsigned index = (unsigned)(cp[i].i);
        int key1 = index >> 16;
        int key2 = index & 0xFFFF;
        if (key1 < 1 || key1 >= cp_count
              || key2 < 1 || key2 >= cp_count) {
            CCerror(cb, "Bad index in constant pool #%d", i);
            return FALSE;
        }
        if (type == CONSTANT_NameAndType) {
            if (   (type_table[key1] != utf8_resolved)
            || (type_table[key2] != utf8_resolved)) {
            CCerror(cb, "Bad index in constant pool.");
            return FALSE;
            }
        } else {
            if (     ((type_table[key1] & CONSTANT_POOL_ENTRY_TYPEMASK)
                    != CONSTANT_Class)
              || ((type_table[key2] != CONSTANT_NameAndType))) {
            CCerror(cb, "Bad index in constant pool #%d", i);
            return FALSE;
            }
        }
        break;
        }

        case CONSTANT_Fieldref | CONSTANT_POOL_ENTRY_RESOLVED:
        case CONSTANT_Methodref | CONSTANT_POOL_ENTRY_RESOLVED:
        case CONSTANT_InterfaceMethodref | CONSTANT_POOL_ENTRY_RESOLVED:
        case CONSTANT_NameAndType | CONSTANT_POOL_ENTRY_RESOLVED:
            CCerror(cb, "Improperly resolved constant pool #%d", i);
            return FALSE;


        case CONSTANT_Class | CONSTANT_POOL_ENTRY_RESOLVED:
        case CONSTANT_Utf8 | CONSTANT_POOL_ENTRY_RESOLVED:
        case CONSTANT_Integer | CONSTANT_POOL_ENTRY_RESOLVED:
        case CONSTANT_Float | CONSTANT_POOL_ENTRY_RESOLVED:
        break;

        case CONSTANT_Long | CONSTANT_POOL_ENTRY_RESOLVED:
        case CONSTANT_Double | CONSTANT_POOL_ENTRY_RESOLVED:
        if ((i + 1 >= cp_count) ||
            (type_table[i + 1] != CONSTANT_POOL_ENTRY_RESOLVED)) {
            CCerror(cb, "Improper constant pool long/double #%d", i);
            return FALSE;
        } else {
            i++;
            break;
        }

        case CONSTANT_Integer:
        case CONSTANT_Float:
        case CONSTANT_Long:
        case CONSTANT_Double:
        case CONSTANT_Utf8:
            CCerror(cb, "Improperly unresolved constant pool #%d", i);
            return FALSE;


        default:
            CCerror(cb, "Illegal constant pool type at #%d", i);
            return FALSE;


    }
    }
    for (i = 1; i < cp_count; i++) {
    switch(type = type_table[i]) {
        case CONSTANT_Class: {
        int index = cp[i].i;
        if (!is_legal_fieldname(cb, cp[index].cp, LegalClass))
            return FALSE;
        break;
        }

        case CONSTANT_Fieldref:
        case CONSTANT_Methodref:
        case CONSTANT_InterfaceMethodref: {
        unsigned index = (unsigned)(cp[i].i);
        int name_type_index = index & 0xFFFF;
        int name_type_key = cp[name_type_index].i;
        int name_index = name_type_key >> 16;
        int signature_index = name_type_key & 0xFFFF;
        char *name = cp[name_index].cp;
        char *signature = cp[signature_index].cp;

        if (type == CONSTANT_Fieldref) {
            if (! (is_legal_fieldname(cb, name, LegalField) &&
               is_legal_field_signature(cb, name, signature)))
                return FALSE;
        } else {
            if (! (is_legal_fieldname(cb, name, LegalMethod) &&
               is_legal_method_signature(cb, name, signature)))
                return FALSE;
        }
        break;
        }
    }
    }
    return TRUE;
}


/* Return true if the entire second argument consists of a legal fieldname
 * (or classname, if the third argument is LegalClass).
 */

static bool_t
is_legal_fieldname(ClassClass *cb, char *name, int type)
{
    bool_t result;
    if (name[0] == '<') {
    result = (type == LegalMethod) &&
             ((strcmp(name, "<init>") == 0) ||
          (strcmp(name, "<clinit>") == 0));
    } else {
    char *p;
    if (type == LegalClass && name[0] == SIGNATURE_ARRAY) {
        p = skip_over_field_signature(name, FALSE);
    } else {
        p = skip_over_fieldname(name, type == LegalClass);
    }
    result = (p != 0 && p[0] == '\0');
    }
    if (!result) {
    char *thing =    (type == LegalField) ? "Field"
                   : (type == LegalMethod) ? "Method" : "Class";

    CCerror(cb, "Illegal %s name \"%s\"", thing, name);
    return FALSE;
    } else {
        return TRUE;

    }
}

/* Return true if the entire string consists of a legal field signature */
static bool_t
is_legal_field_signature(ClassClass *cb, char *fieldname, char *signature)
{
    char *p = skip_over_field_signature(signature, FALSE);
    if (p != 0 && p[0] == '\0') {
    return TRUE;
    } else {
    CCerror(cb, "Field \"%s\" has illegal signature \"%s\"",
           fieldname, signature);
    return FALSE;
    }
}


static bool_t
is_legal_method_signature(ClassClass *cb, char *methodname, char *signature)
{
    char *p = signature;
    char *next_p;
    /* The first character must be a '(' */
    if (*p++ == SIGNATURE_FUNC) {
    /* Skip over however many legal field signatures there are */
    while ((next_p = skip_over_field_signature(p, FALSE)) != 0)
        p = next_p;
    /* The first non-signature thing better be a ')' */
    if (*p++ == SIGNATURE_ENDFUNC) {
        if (methodname[0] == '<') {
        /* All internal methods must return void */
        if ((p[0] == SIGNATURE_VOID) && (p[1] == '\0'))
            return TRUE;
        } else {
        /* Now, we better just have a return value. */
        next_p =  skip_over_field_signature(p, TRUE);
        if (next_p && next_p[0] == '\0')
            return TRUE;
        }
    }
    }
    CCerror(cb, "Method \"%s\" has illegal signature \"%s\"",
       methodname, signature);
    return FALSE;
}

  $$Tables

/*
 * This code mirrors Character.isJavaIdentifierStart.  It determines whether
 * the specified character is a legal start of a Java identifier as per JLS.
 *
 * The parameter ch is the character to be tested; return 1 if the
 * character is a letter, 0 otherwise.
 */
#define isJavaIdentifierStart(ch) ($$Lookup(ch) & $$maskIsJavaIdentifierStart)

/*
 * This code mirrors Character.isJavaIdentifierPart.  It determines whether
 * the specified character is a legal part of a Java identifier as per JLS.
 *
 * The parameter ch is the character to be tested; return 1 if the
 * character is a digit, 0 otherwise.
 */
#define isJavaIdentifierPart(ch) ($$Lookup(ch) & $$maskIsJavaIdentifierPart)

/* Take pointer to a string.  Skip over the longest part of the string that
 * could be taken as a fieldname.  Allow '/' if slash_okay is TRUE.
 *
 * Return a pointer to just past the fieldname.  Return NULL if no fieldname
 * at all was found, or in the case of slash_okay being true, we saw
 * consecutive slashes (meaning we were looking for a qualified path but
 * found something that was badly-formed).
 */
static char *
skip_over_fieldname(char *name, bool_t slash_okay)
{
    bool_t first;
    char *p;
    unicode last_ch = 0;
    for (p = name, first = TRUE; ; first = FALSE) {
    char *old_p = p;
    unicode ch = next_utf2unicode(&p);
    if (isJavaIdentifierStart(ch) || (!first && isJavaIdentifierPart(ch))
          || (slash_okay && ch == '/' && !first)
          || ch == '_' || ch == '$') {
        if (ch == '/' && last_ch == '/') {
        return 0;   /* Don't permit consecutive slashes */
        } else {
        last_ch = ch;
        }
    } else {
        return first ? 0 : old_p;
    }
    }
}

/* Take pointer to a string.  Skip over the longest part of the string that
 * could be taken as a field signature.  Allow "void" if void_okay.
 *
 * Return a pointer to just past the signature.  Return NULL if no legal
 * signature is found.
 */

static char *
skip_over_field_signature(char *name, bool_t void_okay)
{
    for (;;) {
    switch (name[0]) {
            case SIGNATURE_VOID:
        if (!void_okay) return 0;
        /* FALL THROUGH */
            case SIGNATURE_BOOLEAN:
            case SIGNATURE_BYTE:
            case SIGNATURE_CHAR:
            case SIGNATURE_SHORT:
            case SIGNATURE_INT:
            case SIGNATURE_FLOAT:
            case SIGNATURE_LONG:
            case SIGNATURE_DOUBLE:
        return name + 1;

        case SIGNATURE_CLASS: {
        /* Skip over the classname, if one is there. */
        char *p = skip_over_fieldname(name + 1, TRUE);
        /* The next character better be a semicolon. */
        if (p && p[0] == ';')
            return p + 1;
        return 0;
        }

        case SIGNATURE_ARRAY:
        /* The rest of what's there better be a legal signature.  */
        name++;
        void_okay = FALSE;
        break;

        default:
        return 0;
    }
    }
}


static void
CCerror (ClassClass *cb, char *format, ...)
{
    if (verbose) {
    va_list args;
    jio_fprintf(stderr, "VERIFIER CLASS ERROR %s:\n", cbName(cb));
    va_start(args, format);
        jio_vfprintf(stderr, format, args);
    va_end(args);
    jio_fprintf(stderr, "\n");
    }
}

/* For use from outside the file.  Determine if the specified name is legal
 * UTF name for a classname.
 *
 * Note that this routine expects the internal form of qualified classes:
 * the dots should have been replaced by slashes.
 */
bool_t IsLegalClassname(char *name, bool_t allowArrayClass)
{
    char *p;
    if (name[0] == SIGNATURE_ARRAY) {
    if (!allowArrayClass) {
        return FALSE;
    } else {
        /* Everything that's left better be a field signature */
        p = skip_over_field_signature(name, FALSE);
    }
    } else {
    /* skip over the fieldname.  Slashes are okay */
    p = skip_over_fieldname(name, TRUE);
    }
    return (p != 0 && p[0] == '\0');
}