2005-02-15 06:05:36 -05:00
|
|
|
/*
|
2008-04-07 14:36:09 -04:00
|
|
|
* Copyright (c) 2002-2008 LWJGL Project
|
2005-02-15 06:05:36 -05:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are
|
|
|
|
* met:
|
|
|
|
*
|
|
|
|
* * Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
*
|
|
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* * Neither the name of 'LWJGL' nor the names of
|
|
|
|
* its contributors may be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
2005-02-20 14:28:34 -05:00
|
|
|
package org.lwjgl.util.generator;
|
2005-02-15 06:05:36 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
*
|
|
|
|
* This class represent a parameter configuration. There are multiple
|
|
|
|
* TypeInfos in case of multityped parameters.
|
|
|
|
*
|
|
|
|
* @author elias_naur <elias_naur@users.sourceforge.net>
|
|
|
|
* @version $Revision$
|
2006-03-23 14:32:21 -05:00
|
|
|
* $Id$
|
2005-02-15 06:05:36 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
import com.sun.mirror.declaration.*;
|
|
|
|
import com.sun.mirror.type.*;
|
|
|
|
|
|
|
|
import java.util.*;
|
|
|
|
import java.nio.*;
|
|
|
|
|
|
|
|
public class TypeInfo {
|
2005-02-15 12:13:05 -05:00
|
|
|
public static final String UNSIGNED_PARAMETER_NAME = "unsigned";
|
2005-02-15 06:05:36 -05:00
|
|
|
|
|
|
|
private final Signedness signedness;
|
|
|
|
private final Class type;
|
|
|
|
private final String auto_type;
|
|
|
|
|
|
|
|
private TypeInfo(Class type, Signedness signedness, String auto_type) {
|
|
|
|
this.type = type;
|
|
|
|
this.signedness = signedness;
|
|
|
|
this.auto_type = auto_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Class getType() {
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Signedness getSignedness() {
|
|
|
|
return signedness;
|
|
|
|
}
|
2005-02-15 12:13:05 -05:00
|
|
|
|
2005-02-15 06:05:36 -05:00
|
|
|
public String getAutoType() {
|
|
|
|
if (auto_type == null)
|
|
|
|
throw new RuntimeException("No auto type assigned");
|
|
|
|
return auto_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
private static Class getTypeFromPrimitiveKind(PrimitiveType.Kind kind) {
|
|
|
|
Class type;
|
|
|
|
switch (kind) {
|
2006-02-26 06:44:34 -05:00
|
|
|
case LONG:
|
|
|
|
type = long.class;
|
|
|
|
break;
|
2005-02-15 06:05:36 -05:00
|
|
|
case INT:
|
|
|
|
type = int.class;
|
|
|
|
break;
|
|
|
|
case FLOAT:
|
|
|
|
type = float.class;
|
|
|
|
break;
|
|
|
|
case DOUBLE:
|
|
|
|
type = double.class;
|
|
|
|
break;
|
|
|
|
case SHORT:
|
|
|
|
type = short.class;
|
|
|
|
break;
|
|
|
|
case BYTE:
|
|
|
|
type = byte.class;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
throw new RuntimeException(kind + " is not allowed");
|
|
|
|
}
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
|
|
|
private static Class getBufferTypeFromPrimitiveKind(PrimitiveType.Kind kind) {
|
|
|
|
Class type;
|
|
|
|
switch (kind) {
|
|
|
|
case INT:
|
|
|
|
type = IntBuffer.class;
|
|
|
|
break;
|
|
|
|
case FLOAT:
|
|
|
|
type = FloatBuffer.class;
|
|
|
|
break;
|
|
|
|
case DOUBLE:
|
|
|
|
type = DoubleBuffer.class;
|
|
|
|
break;
|
|
|
|
case SHORT:
|
|
|
|
type = ShortBuffer.class;
|
|
|
|
break;
|
2006-05-25 09:03:35 -04:00
|
|
|
case LONG:
|
|
|
|
type = LongBuffer.class;
|
|
|
|
break;
|
2005-02-15 06:05:36 -05:00
|
|
|
case BYTE: /* fall through */
|
|
|
|
case BOOLEAN:
|
|
|
|
type = ByteBuffer.class;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
throw new RuntimeException(kind + " is not allowed");
|
|
|
|
}
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
|
|
|
private static TypeInfo getDefaultTypeInfo(TypeMirror t) {
|
|
|
|
Class java_type = Utils.getJavaType(t);
|
|
|
|
return new TypeInfo(java_type, Signedness.NONE, null);
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Map<ParameterDeclaration, TypeInfo> getDefaultTypeInfoMap(MethodDeclaration method) {
|
|
|
|
Map<ParameterDeclaration, TypeInfo> map = new HashMap<ParameterDeclaration, TypeInfo>();
|
|
|
|
for (ParameterDeclaration param : method.getParameters()) {
|
|
|
|
TypeInfo type_info = getDefaultTypeInfo(param.getType());
|
|
|
|
map.put(param, type_info);
|
|
|
|
}
|
|
|
|
return map;
|
|
|
|
}
|
|
|
|
|
|
|
|
private static Collection<TypeInfo> getTypeInfos(TypeMap type_map, Declaration param, TypeMirror decl_type) {
|
|
|
|
Collection<AnnotationMirror> annotations = Utils.getSortedAnnotations(param.getAnnotationMirrors());
|
|
|
|
Map<Class, TypeInfo> types = new HashMap<Class, TypeInfo>();
|
2005-02-16 16:46:03 -05:00
|
|
|
Collection<TypeInfo> multityped_result = new ArrayList<TypeInfo>();
|
2005-02-15 06:05:36 -05:00
|
|
|
boolean add_default_type = true;
|
|
|
|
for (AnnotationMirror annotation : annotations) {
|
|
|
|
NativeType native_type_annotation = NativeTypeTranslator.getAnnotation(annotation, NativeType.class);
|
|
|
|
if (native_type_annotation != null) {
|
|
|
|
Class annotation_type = NativeTypeTranslator.getClassFromType(annotation.getAnnotationType());
|
|
|
|
Signedness signedness = type_map.getSignednessFromType(annotation_type);
|
|
|
|
Class inverse_type = type_map.getInverseType(annotation_type);
|
|
|
|
String auto_type = type_map.getAutoTypeFromAnnotation(annotation);
|
|
|
|
if (inverse_type != null) {
|
|
|
|
if (types.containsKey(inverse_type)) {
|
2005-02-16 16:46:03 -05:00
|
|
|
TypeInfo inverse_type_info = types.get(inverse_type);
|
|
|
|
String inverse_auto_type = inverse_type_info.getAutoType();
|
2005-02-15 06:05:36 -05:00
|
|
|
auto_type = signedness == Signedness.UNSIGNED ? auto_type + " : " + inverse_auto_type :
|
|
|
|
inverse_auto_type + " : " + auto_type;
|
|
|
|
auto_type = UNSIGNED_PARAMETER_NAME + " ? " + auto_type;
|
|
|
|
signedness = Signedness.BOTH;
|
|
|
|
types.remove(inverse_type);
|
2005-02-16 16:46:03 -05:00
|
|
|
multityped_result.remove(inverse_type_info);
|
2005-02-15 06:05:36 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
Class type;
|
2010-03-11 16:06:49 -05:00
|
|
|
PrimitiveType.Kind kind;
|
|
|
|
GLvoid void_annotation = param.getAnnotation(GLvoid.class);
|
|
|
|
kind = void_annotation == null ? type_map.getPrimitiveTypeFromNativeType(annotation_type) : void_annotation.value();
|
2005-02-15 06:05:36 -05:00
|
|
|
if (Utils.getNIOBufferType(decl_type) != null)
|
|
|
|
type = getBufferTypeFromPrimitiveKind(kind);
|
|
|
|
else
|
|
|
|
type = getTypeFromPrimitiveKind(kind);
|
2005-02-16 16:46:03 -05:00
|
|
|
TypeInfo type_info = new TypeInfo(type, signedness, auto_type);
|
|
|
|
types.put(annotation_type, type_info);
|
|
|
|
multityped_result.add(type_info);
|
2005-02-15 06:05:36 -05:00
|
|
|
add_default_type = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (add_default_type) {
|
|
|
|
TypeInfo default_type_info = getDefaultTypeInfo(decl_type);
|
|
|
|
Collection<TypeInfo> result = new ArrayList<TypeInfo>();
|
|
|
|
result.add(default_type_info);
|
|
|
|
return result;
|
|
|
|
} else
|
2005-02-16 16:46:03 -05:00
|
|
|
return multityped_result;
|
2005-02-15 06:05:36 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
private static Map<ParameterDeclaration, Collection<TypeInfo>> getTypeInfoMap(TypeMap type_map, MethodDeclaration method) {
|
|
|
|
Map<ParameterDeclaration, Collection<TypeInfo>> map = new HashMap<ParameterDeclaration, Collection<TypeInfo>>();
|
|
|
|
for (ParameterDeclaration param : method.getParameters()) {
|
|
|
|
Collection<TypeInfo> types = getTypeInfos(type_map, param, param.getType());
|
|
|
|
map.put(param, types);
|
|
|
|
}
|
|
|
|
return map;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Collection<Map<ParameterDeclaration, TypeInfo>> getTypeInfoCrossProduct(TypeMap type_map, MethodDeclaration method) {
|
|
|
|
Collection<ParameterDeclaration> parameter_collection = method.getParameters();
|
|
|
|
ParameterDeclaration[] parameters = new ParameterDeclaration[parameter_collection.size()];
|
|
|
|
parameter_collection.toArray(parameters);
|
|
|
|
Collection<Map<ParameterDeclaration, TypeInfo>> cross_product = new ArrayList<Map<ParameterDeclaration, TypeInfo>>();
|
|
|
|
getCrossProductRecursive(0, parameters, getTypeInfoMap(type_map, method),
|
|
|
|
new HashMap<ParameterDeclaration, TypeInfo>(), cross_product);
|
|
|
|
return cross_product;
|
|
|
|
}
|
|
|
|
|
|
|
|
private static void getCrossProductRecursive(int index, ParameterDeclaration[] parameters, Map<ParameterDeclaration,
|
2005-02-17 04:44:06 -05:00
|
|
|
Collection<TypeInfo>> typeinfos_map, Map<ParameterDeclaration, TypeInfo> current_instance,
|
2005-02-15 06:05:36 -05:00
|
|
|
Collection<Map<ParameterDeclaration, TypeInfo>> cross_product) {
|
|
|
|
if (index == parameters.length) {
|
|
|
|
cross_product.add(current_instance);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ParameterDeclaration param = parameters[index];
|
|
|
|
Collection<TypeInfo> typeinfos = typeinfos_map.get(param);
|
|
|
|
if (typeinfos != null) {
|
|
|
|
for (TypeInfo typeinfo : typeinfos) {
|
2005-02-17 04:44:06 -05:00
|
|
|
Map<ParameterDeclaration, TypeInfo> instance = new HashMap<ParameterDeclaration, TypeInfo>(current_instance);
|
2005-02-15 06:05:36 -05:00
|
|
|
instance.put(param, typeinfo);
|
|
|
|
getCrossProductRecursive(index + 1, parameters, typeinfos_map, instance, cross_product);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|