jdk8-mips64-public/corba: comparison src/share/classes/sun/rmi/rmic/iiop/ValueType.java

--1:000000000000
+:7ef37b2cdcad
+/*
+* Copyright (c) 1998, 2007, 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.
+*/
+/*
+* Licensed Materials - Property of IBM
+* RMI-IIOP v1.0
+* Copyright IBM Corp. 1998 1999  All Rights Reserved
+*
+*/
+package sun.rmi.rmic.iiop;
+import java.util.Vector;
+import sun.tools.java.ClassNotFound;
+import sun.tools.java.ClassDeclaration;
+import sun.tools.java.ClassDefinition;
+import sun.tools.java.MemberDefinition;
+import java.util.Hashtable;
+import java.io.ObjectStreamClass;
+import java.io.ObjectStreamField;
+/**
+* ValueType represents any non-special class which does inherit from
+* java.io.Serializable and does not inherit from java.rmi.Remote.
+* <p>
+* The static forValue(...) method must be used to obtain an instance, and
+* will return null if the ClassDefinition is non-conforming.
+*
+* @author      Bryan Atsatt
+*/
+public class ValueType extends ClassType {
+private boolean isCustom;
+//_____________________________________________________________________
+// Public Interfaces
+//_____________________________________________________________________
+/**
+* Create an ValueType object for the given class.
+*
+* If the class is not a properly formed or if some other error occurs, the
+* return value will be null, and errors will have been reported to the
+* supplied BatchEnvironment.
+*/
+public static ValueType forValue(ClassDefinition classDef,
+ContextStack stack,
+boolean quiet) {
+if (stack.anyErrors()) return null;
+// Do we already have it?
+sun.tools.java.Type theType = classDef.getType();
+String typeKey = theType.toString();
+Type existing = getType(typeKey,stack);
+if (existing != null) {
+if (!(existing instanceof ValueType)) return null; // False hit.
+// Yep, so return it...
+return (ValueType) existing;
+}
+// Is this java.lang.Class?
+boolean javaLangClass = false;
+if (classDef.getClassDeclaration().getName() == idJavaLangClass) {
+// Yes, so replace classDef with one for
+// javax.rmi.CORBA.ClassDesc...
+javaLangClass = true;
+BatchEnvironment env = stack.getEnv();
+ClassDeclaration decl = env.getClassDeclaration(idClassDesc);
+ClassDefinition def = null;
+try {
+def = decl.getClassDefinition(env);
+} catch (ClassNotFound ex) {
+classNotFound(stack,ex);
+return null;
+}
+classDef = def;
+}
+// Could this be a value?
+if (couldBeValue(stack,classDef)) {
+// Yes, so check it...
+ValueType it = new ValueType(classDef,stack,javaLangClass);
+putType(typeKey,it,stack);
+stack.push(it);
+if (it.initialize(stack,quiet)) {
+stack.pop(true);
+return it;
+} else {
+removeType(typeKey,stack);
+stack.pop(false);
+return null;
+}
+} else {
+return null;
+}
+}
+/**
+* Return a string describing this type.
+*/
+public String getTypeDescription () {
+String result = addExceptionDescription("Value");
+if (isCustom) {
+result = "Custom " + result;
+}
+if (isIDLEntity) {
+result = result + " [IDLEntity]";
+}
+return result;
+}
+/**
+* Return true if this type is a "custom" type (i.e.
+* it implements java.io.Externalizable or has a
+* method with the following signature:
+*
+*  private void writeObject(java.io.ObjectOutputStream out);
+*
+*/
+public boolean isCustom () {
+return isCustom;
+}
+//_____________________________________________________________________
+// Subclass/Internal Interfaces
+//_____________________________________________________________________
+/**
+* Create a ValueType instance for the given class.  The resulting
+* object is not yet completely initialized.
+*/
+private ValueType(ClassDefinition classDef,
+ContextStack stack,
+boolean isMappedJavaLangClass) {
+super(stack,classDef,TYPE_VALUE | TM_CLASS | TM_COMPOUND);
+isCustom = false;
+// If this is the mapped version of java.lang.Class,
+// set the non-IDL names back to java.lang.Class...
+if (isMappedJavaLangClass) {
+setNames(idJavaLangClass,IDL_CLASS_MODULE,IDL_CLASS);
+}
+}
+//_____________________________________________________________________
+// Internal Interfaces
+//_____________________________________________________________________
+/**
+* Initialize this instance.
+*/
+private static boolean couldBeValue(ContextStack stack, ClassDefinition classDef) {
+boolean result = false;
+ClassDeclaration classDecl = classDef.getClassDeclaration();
+BatchEnvironment env = stack.getEnv();
+try {
+// Make sure it's not remote...
+if (env.defRemote.implementedBy(env, classDecl)) {
+failedConstraint(10,false,stack,classDef.getName());
+} else {
+// Make sure it's Serializable...
+if (!env.defSerializable.implementedBy(env, classDecl)) {
+failedConstraint(11,false,stack,classDef.getName());
+} else {
+result = true;
+}
+}
+} catch (ClassNotFound e) {
+classNotFound(stack,e);
+}
+return result;
+}
+/**
+* Initialize this instance.
+*/
+private boolean initialize (ContextStack stack, boolean quiet) {
+ClassDefinition ourDef = getClassDefinition();
+ClassDeclaration ourDecl = getClassDeclaration();
+try {
+// Make sure our parentage is ok...
+if (!initParents(stack)) {
+failedConstraint(12,quiet,stack,getQualifiedName());
+return false;
+}
+// We're ok, so make up our collections...
+Vector directInterfaces = new Vector();
+Vector directMethods = new Vector();
+Vector directMembers = new Vector();
+// Get interfaces...
+if (addNonRemoteInterfaces(directInterfaces,stack) != null) {
+// Get methods...
+if (addAllMethods(ourDef,directMethods,false,false,stack) != null) {
+// Update parent class methods
+if (updateParentClassMethods(ourDef,directMethods,false,stack) != null) {
+// Get constants and members...
+if (addAllMembers(directMembers,false,false,stack)) {
+// We're ok, so pass 'em up...
+if (!initialize(directInterfaces,directMethods,directMembers,stack,quiet)) {
+return false;
+}
+// Is this class Externalizable?
+boolean externalizable = false;
+if (!env.defExternalizable.implementedBy(env, ourDecl)) {
+// No, so check to see if we have a serialPersistentField
+// that will modify the members.
+if (!checkPersistentFields(getClassInstance(),quiet)) {
+return false;
+}
+} else {
+// Yes.
+externalizable = true;
+}
+// Should this class be considered "custom"? It is if
+// it is Externalizable OR if it has a method with the
+// following signature:
+//
+//  private void writeObject(java.io.ObjectOutputStream out);
+//
+if (externalizable) {
+isCustom = true;
+} else {
+for (MemberDefinition member = ourDef.getFirstMember();
+member != null;
+member = member.getNextMember()) {
+if (member.isMethod() &&
+!member.isInitializer() &&
+member.isPrivate() &&
+member.getName().toString().equals("writeObject")) {
+// Check return type, arguments and exceptions...
+sun.tools.java.Type methodType = member.getType();
+sun.tools.java.Type rtnType = methodType.getReturnType();
+if (rtnType == sun.tools.java.Type.tVoid) {
+// Return type is correct. How about arguments?
+sun.tools.java.Type[] args = methodType.getArgumentTypes();
+if (args.length == 1 &&
+args[0].getTypeSignature().equals("Ljava/io/ObjectOutputStream;")) {
+// Arguments are correct, so it is a custom
+// value type...
+isCustom = true;
+}
+}
+}
+}
+}
+}
+return true;
+}
+}
+}
+} catch (ClassNotFound e) {
+classNotFound(stack,e);
+}
+return false;
+}
+private boolean checkPersistentFields (Class clz, boolean quiet) {
+// Do we have a writeObject method?
+for (int i = 0; i < methods.length; i++) {
+if (methods[i].getName().equals("writeObject") &&
+methods[i].getArguments().length == 1) {
+Type returnType = methods[i].getReturnType();
+Type arg = methods[i].getArguments()[0];
+String id = arg.getQualifiedName();
+if (returnType.isType(TYPE_VOID) &&
+id.equals("java.io.ObjectOutputStream")) {
+// Got one, so there's nothing to do...
+return true;
+}
+}
+}
+// Do we have a valid serialPersistentField array?
+MemberDefinition spfDef = null;
+for (int i = 0; i < members.length; i++) {
+if (members[i].getName().equals("serialPersistentFields")) {
+Member member = members[i];
+Type type = member.getType();
+Type elementType = type.getElementType();
+// We have a member with the correct name. Make sure
+// we have the correct signature...
+if (elementType != null &&
+elementType.getQualifiedName().equals(
+"java.io.ObjectStreamField")
+) {
+if (member.isStatic() &&
+member.isFinal() &&
+member.isPrivate()) {
+// We have the correct signature
+spfDef = member.getMemberDefinition();
+} else {
+// Bad signature...
+failedConstraint(4,quiet,stack,getQualifiedName());
+return false;
+}
+}
+}
+}
+// If we do not have a serialPersistentField,
+// there's nothing to do, so return with no error...
+if (spfDef == null) {
+return true;
+}
+// Ok, now we must examine the contents of the array -
+// then validate them...
+Hashtable fields = getPersistentFields(clz);
+boolean result = true;
+for (int i = 0; i < members.length; i++) {
+String fieldName = members[i].getName();
+String fieldType = members[i].getType().getSignature();
+// Is this field present in the array?
+String type = (String) fields.get(fieldName);
+if (type == null) {
+// No, so mark it transient...
+members[i].setTransient();
+} else {
+// Yes, does the type match?
+if (type.equals(fieldType)) {
+// Yes, so remove it from the fields table...
+fields.remove(fieldName);
+} else {
+// No, so error...
+result = false;
+failedConstraint(2,quiet,stack,fieldName,getQualifiedName());
+}
+}
+}
+// Ok, we've checked all of our fields. Are there any left in the "array"?
+// If so, it's an error...
+if (result && fields.size() > 0) {
+result = false;
+failedConstraint(9,quiet,stack,getQualifiedName());
+}
+// Return result...
+return result;
+}
+/**
+* Get the names and types of all the persistent fields of a Class.
+*/
+private Hashtable getPersistentFields (Class clz) {
+Hashtable result = new Hashtable();
+ObjectStreamClass osc = ObjectStreamClass.lookup(clz);
+if (osc != null) {
+ObjectStreamField[] fields = osc.getFields();
+for (int i = 0; i < fields.length; i++) {
+String typeSig;
+String typePrefix = String.valueOf(fields[i].getTypeCode());
+if (fields[i].isPrimitive()) {
+typeSig = typePrefix;
+} else {
+if (fields[i].getTypeCode() == '[') {
+typePrefix = "";
+}
+typeSig = typePrefix + fields[i].getType().getName().replace('.','/');
+if (typeSig.endsWith(";")) {
+typeSig = typeSig.substring(0,typeSig.length()-1);
+}
+}
+result.put(fields[i].getName(),typeSig);
+}
+}
+return result;
+}
+}

Mercurial > jdk8-mips64-public > corba / file comparison

comparison: src/share/classes/sun/rmi/rmic/iiop/ValueType.java

src/share/classes/sun/rmi/rmic/iiop/ValueType.java