/*----------------------------------------------------------------------------
Copyright (c)2000 TogetherSoft LLC. Patents pending. All rights reserved.
----------------------------------------------------------------------------*/
package com.togethersoft.modules.genidl;
import java.util.Hashtable;
import com.togethersoft.openapi.scriptapi.UML.UMLElement;
/** Type converter. Used to convert standard language types into ones of the IDL. */
class IdlTypeConverter {
/**
* Constructor. Language is mandatory.
* @param language one of UMLElement.JAVA, UMLElement.CPP
* @see com.togethersoft.openapi.scriptapi.UML.UMLElement
*/
public IdlTypeConverter(String language) {
myLanguage = language;
createLanguageToIdlTable();
}
public String getLanguage() {
return myLanguage;
}
public void setLanguage(String lang) {
myLanguage = lang;
}
/**
* Check for Standard idl type. Is return substring of given type( all decl ) if it's Standard type.
* Ex: int d, f, t => int NOTE : don't used now... only for deep parsing of the tags
*/
public String getStandardIdlType(String atype) {
final String type = atype.trim();
final int typeLength = type.length();
//check at next type such : < scope_name > <Standard type>
for (int i = 0; i < idlTypes.length; i++) {
if (idlTypes[i].equals(type)) {
return type;
}
}
// check for sequence , fixed.
if (type.startsWith("sequence") || type.startsWith("fixed")) {
int counter = 0;
for (int i = 4; i < typeLength; i++) {
if (type.charAt(i) == '<') {
counter++;
}
if (type.charAt(i) == '>') {
counter--;
if (counter == 0) {
return type.substring(0, i + 1);
}
}
}
}
// check for string or wstring
if (type.startsWith(IdlType.STRING) || type.startsWith(IdlType.WSTRING)) {
String idlType = "";
if (type.startsWith("w")) {
idlType = type.substring(7, typeLength).trim();
}
else {
idlType = type.substring(6, typeLength).trim();
}
if (!idlType.startsWith("<")) {
return type;
}
else {
// " string<20>"
int counter = 0;
for (int i = 6; i < typeLength; i++) {
if (type.charAt(i) == '<') {
counter++;
}
if (type.charAt(i) == '>') {
counter--;
if (counter == 0) {
return type.substring(0, i + 1);
}
}
}
}
}
return null;
}
/** Check for Standard cpp type. It may be : MPoint int - then return int!!! */
public String getCppType(String type) {
//check at next type such : < scope_name > <Standard type>
int pointer;
for (int i = 0; i < cppTypes.length; i++) {
pointer = -1;
if (type.length() > cppTypes[i].length()) {
pointer = type.indexOf(" " + cppTypes[i]);
if (pointer == -1) {
pointer = type.indexOf(cppTypes[i] + " ");
}
}
if (type.equals(cppTypes[i]) || pointer != -1) {
return cppTypes[i]; // ex: "LALA unsigned char"
}
}
return null;
}
/** Check for Standard Java type. It may be : MPoint int - then return int!!! */
public String getJavaType(String type) {
//check at next type such : < scope_name > <Standard type>
int pointer;
for (int i = 0; i < javaTypes.length; i++) {
pointer = -1;
if (type.length() > javaTypes[i].length()) {
pointer = type.indexOf(" " + javaTypes[i]);
if (pointer == -1) {
pointer = type.indexOf(javaTypes[i] + " ");
}
}
if (type.equals(javaTypes[i]) || pointer != -1) {
return javaTypes[i]; // ex: "KAKA unsigned char"
}
}
return null;
}
/** Is to receive converted type to idlType */
public String getConvertedType(String type) {
String myType = null;
if (getLanguage().equals(UMLElement.CPP)) {
myType = getCppType(type.trim());
}
else {
if (getLanguage().equals(UMLElement.JAVA)) {
myType = getJavaType(type.trim());
}
}
if (myType != null && languageToIdlTable.containsKey(myType)) {
return (String)languageToIdlTable.get(myType);
}
// if unable convert, it's prolly a referenced type
return null;
}
private void createLanguageToIdlTable() {
languageToIdlTable = new Hashtable();
if (getLanguage().equals(UMLElement.CPP)) {
for (int i = 0; i < (cppToIdlTypes.length); i++) {
languageToIdlTable.put(cppToIdlTypes[i][0], cppToIdlTypes[i][1]);
}
}
if (getLanguage().equals(UMLElement.JAVA)) {
for (int i = 0; i < (javaToIdlTypes.length); i++) {
languageToIdlTable.put(javaToIdlTypes[i][0], javaToIdlTypes[i][1]);
}
}
}
// -------------------------------------------------------------------------------
// private attributes
// -------------------------------------------------------------------------------
private String myLanguage;
private Hashtable languageToIdlTable;
private String[] idlTypes = {
"float",
"double",
"long double",
"long",
"long long",
"boolean",
"short",
"unsigned short",
"unsigned long",
"unsigned long long",
"char",
"wchar",
"octet",
"any",
"Object",
"native",
"void"
};
// don't change this order !!!
private String[] cppTypes = {
"long double",
"unsigned char",
"unsigned short int",
"unsigned int",
"unsigned long int",
"signed char",
"signed short int",
"signed int",
"signed long int",
"short int",
"long int",
"boolean",
"string",
"String",
"BOOL",
"bool",
"LONG",
"ULONG",
"DWORD",
"void",
"char",
"int",
"long",
"float",
"double"
};
private String[] javaTypes = {
"long",
"int",
"short",
"byte",
"char",
"double",
"float",
"boolean",
"Long",
"Integer",
"Short",
"Byte",
"Character",
"Double",
"Float",
"Boolean",
"String",
"StringBuffer",
"void",
"Object",
"Vector",
"Hashtable",
"Enumeration",
"Calendar",
"Date"
};
private String[][] javaToIdlTypes = {
{ "long", "long long" },
{ "int", "long" },
{ "short", "short" },
{ "byte", "octet" },
{ "char", "wchar" },
{ "double", "double" },
{ "float", "float" },
{ "boolean", "boolean" },
{ "Long", "long long" },
{ "Integer", "long" },
{ "Short", "short" },
{ "Byte", "octet" },
{ "Character", "wchar" },
{ "Double", "double" },
{ "Float", "float" },
{ "Boolean", "boolean" },
{ "String", "string" },
{ "StringBuffer", "string" },
{ "void", "void" },
{ "Object", "Object" },
{ "Vector", "any" },
{ "Hashtable", "any" },
{ "Enumeration", "any" },
{ "Calendar", "any" },
{ "Date", "any"}};
//Array for compatible types from Cpp to Idl
private String[][] cppToIdlTypes = {
{ "char", "char"},
{ "short int", "short"},
{ "int", "long"},
{ "long", "long"},
{ "long int", "long long"},
{ "boolean", "boolean"},
{ "float", "float"},
{ "double", "double"},
{ "long double", "double"},
{ "unsigned char", "char"},
{ "unsigned short int", "unsigned short"},
{ "unsigned int", "unsigned long"},
{ "unsigned long int", "unsigned long long"},
{ "signed char", "short"},
{ "signed short int", "short"},
{ "signed int", "long"},
{ "signed long int", "long long"},
{ "string", "string"},
{ "String", "string"},
{ "BOOL", "boolean"},
{ "bool", "boolean"},
{ "LONG", "long long"},
{ "ULONG", "unsigned long"},
{ "DWORD", "long"},
{ "void", "void"}};
}
|