843 lines
27 KiB
Java
843 lines
27 KiB
Java
// Source code is decompiled from a .class file using FernFlower decompiler.
|
|
package re3lib;
|
|
|
|
import ghidra.program.model.data.*;
|
|
import ghidra.program.model.data.Enum;
|
|
import ghidra.util.Msg;
|
|
import ghidra.util.exception.CancelledException;
|
|
import ghidra.util.task.TaskMonitor;
|
|
import java.io.IOException;
|
|
import java.io.Writer;
|
|
import java.util.ArrayDeque;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
public class DataTypeWriter {
|
|
public HashSet<String> blacklistedTypes;
|
|
|
|
private static String[] INTEGRAL_TYPES = new String[] { "char", "short", "int", "long", "long long", "__int64",
|
|
"float", "double", "long double", "void" };
|
|
private static String[] INTEGRAL_MODIFIERS = new String[] { "signed", "unsigned", "const", "static", "volatile",
|
|
"mutable" };
|
|
private static String EOL = System.getProperty("line.separator");
|
|
private Set<DataType> resolved;
|
|
private Map<String, DataType> resolvedTypeMap;
|
|
private Set<Composite> deferredCompositeDeclarations;
|
|
private ArrayDeque<DataType> deferredTypeFIFO;
|
|
private Set<DataType> deferredTypes;
|
|
private int writerDepth;
|
|
private Writer writer;
|
|
private DataTypeManager dtm;
|
|
private DataOrganization dataOrganization;
|
|
private AnnotationHandler annotator;
|
|
private boolean cppStyleComments;
|
|
|
|
public DataTypeWriter(DataTypeManager dtm, Writer writer) throws IOException {
|
|
this(dtm, writer, new DefaultAnnotationHandler());
|
|
}
|
|
|
|
public DataTypeWriter(DataTypeManager dtm, Writer writer, boolean cppStyleComments) throws IOException {
|
|
this(dtm, writer, new DefaultAnnotationHandler(), cppStyleComments);
|
|
}
|
|
|
|
public DataTypeWriter(DataTypeManager dtm, Writer writer, AnnotationHandler annotator) throws IOException {
|
|
this(dtm, writer, annotator, false);
|
|
}
|
|
|
|
public DataTypeWriter(DataTypeManager dtm, Writer writer, AnnotationHandler annotator, boolean cppStyleComments)
|
|
throws IOException {
|
|
this.blacklistedTypes = new HashSet<>();
|
|
this.resolved = new HashSet();
|
|
this.resolvedTypeMap = new HashMap();
|
|
this.deferredCompositeDeclarations = new HashSet();
|
|
this.deferredTypeFIFO = new ArrayDeque();
|
|
this.deferredTypes = new HashSet();
|
|
this.writerDepth = 0;
|
|
this.cppStyleComments = false;
|
|
this.dtm = dtm;
|
|
if (dtm != null) {
|
|
this.dataOrganization = dtm.getDataOrganization();
|
|
}
|
|
|
|
if (this.dataOrganization == null) {
|
|
this.dataOrganization = DataOrganizationImpl.getDefaultOrganization();
|
|
}
|
|
|
|
this.writer = writer;
|
|
this.annotator = annotator;
|
|
this.cppStyleComments = cppStyleComments;
|
|
if (dtm != null) {
|
|
// this.writeBuiltInDeclarations(dtm);
|
|
}
|
|
}
|
|
|
|
private String comment(String text) {
|
|
if (text == null) {
|
|
return "";
|
|
} else {
|
|
return this.cppStyleComments ? "// " + text : "/* " + text + " */";
|
|
}
|
|
}
|
|
|
|
public void write(DataTypeManager dataTypeManager, TaskMonitor monitor) throws IOException, CancelledException {
|
|
this.write(dataTypeManager.getRootCategory(), monitor);
|
|
}
|
|
|
|
public void write(Category category, TaskMonitor monitor) throws IOException, CancelledException {
|
|
DataType[] dataTypes = category.getDataTypes();
|
|
this.write(dataTypes, monitor);
|
|
Category[] subCategories = category.getCategories();
|
|
Category[] var5 = subCategories;
|
|
int var6 = subCategories.length;
|
|
|
|
for (int var7 = 0; var7 < var6; ++var7) {
|
|
Category subCategory = var5[var7];
|
|
if (monitor.isCancelled()) {
|
|
return;
|
|
}
|
|
|
|
this.write(subCategory, monitor);
|
|
}
|
|
|
|
}
|
|
|
|
public void write(DataType[] dataTypes, TaskMonitor monitor) throws IOException, CancelledException {
|
|
monitor.initialize((long) dataTypes.length);
|
|
int cnt = 0;
|
|
DataType[] var4 = dataTypes;
|
|
int var5 = dataTypes.length;
|
|
|
|
for (int var6 = 0; var6 < var5; ++var6) {
|
|
DataType dataType = var4[var6];
|
|
monitor.checkCancelled();
|
|
this.write(dataType, monitor);
|
|
++cnt;
|
|
monitor.setProgress((long) cnt);
|
|
}
|
|
|
|
}
|
|
|
|
public void write(List<DataType> dataTypes, TaskMonitor monitor) throws IOException, CancelledException {
|
|
this.write(dataTypes, monitor, true);
|
|
}
|
|
|
|
public void write(List<DataType> dataTypes, TaskMonitor monitor, boolean throwExceptionOnInvalidType)
|
|
throws IOException, CancelledException {
|
|
monitor.initialize((long) dataTypes.size());
|
|
int cnt = 0;
|
|
Iterator var5 = dataTypes.iterator();
|
|
|
|
while (var5.hasNext()) {
|
|
DataType dataType = (DataType) var5.next();
|
|
monitor.checkCancelled();
|
|
this.write(dataType, monitor, throwExceptionOnInvalidType);
|
|
++cnt;
|
|
monitor.setProgress((long) cnt);
|
|
}
|
|
|
|
}
|
|
|
|
private void deferWrite(DataType dt) {
|
|
if (!this.resolved.contains(dt) && !this.deferredTypes.contains(dt)) {
|
|
this.deferredTypes.add(dt);
|
|
this.deferredTypeFIFO.addLast(dt);
|
|
}
|
|
|
|
}
|
|
|
|
void write(DataType dt, TaskMonitor monitor) throws IOException, CancelledException {
|
|
this.doWrite(dt, monitor, true);
|
|
}
|
|
|
|
void write(DataType dt, TaskMonitor monitor, boolean throwExceptionOnInvalidType)
|
|
throws IOException, CancelledException {
|
|
this.doWrite(dt, monitor, throwExceptionOnInvalidType);
|
|
}
|
|
|
|
private void doWrite(DataType dt, TaskMonitor monitor, boolean throwExceptionOnInvalidType)
|
|
throws IOException, CancelledException {
|
|
if (dt != null) {
|
|
if (blacklistedTypes.contains(dt.getDisplayName()))
|
|
return;
|
|
if (!(dt instanceof FunctionDefinition)) {
|
|
if (dt instanceof FactoryDataType) {
|
|
IllegalArgumentException iae = new IllegalArgumentException("Factory data types may not be written");
|
|
if (throwExceptionOnInvalidType) {
|
|
throw iae;
|
|
}
|
|
|
|
Msg.error(this, "Factory data types may not be written - type: " + dt);
|
|
}
|
|
|
|
if (!(dt instanceof Pointer) && !(dt instanceof Array) && !(dt instanceof BitFieldDataType)) {
|
|
dt = dt.clone(this.dtm);
|
|
if (!this.resolved.contains(dt)) {
|
|
this.resolved.add(dt);
|
|
DataType resolvedType = (DataType) this.resolvedTypeMap.get(dt.getName());
|
|
if (resolvedType != null) {
|
|
if (!resolvedType.isEquivalent(dt)) {
|
|
if (dt instanceof TypeDef) {
|
|
DataType baseType = ((TypeDef) dt).getBaseDataType();
|
|
if ((resolvedType instanceof Composite || resolvedType instanceof Enum)
|
|
&& baseType.isEquivalent(resolvedType)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
this.writer.write(EOL);
|
|
Writer var10000 = this.writer;
|
|
String var10002 = dt.getPathName();
|
|
var10000.write(this
|
|
.comment("WARNING! conflicting data type names: " + var10002 + " - " + resolvedType.getPathName()));
|
|
this.writer.write(EOL);
|
|
this.writer.write(EOL);
|
|
}
|
|
} else {
|
|
this.resolvedTypeMap.put(dt.getName(), dt);
|
|
++this.writerDepth;
|
|
if (dt.equals(DataType.DEFAULT)) {
|
|
this.writer.write("typedef unsigned char " + DataType.DEFAULT.getName() + ";");
|
|
this.writer.write(EOL);
|
|
this.writer.write(EOL);
|
|
} else if (dt instanceof Dynamic) {
|
|
this.writeDynamicBuiltIn((Dynamic) dt, monitor);
|
|
} else if (dt instanceof Structure) {
|
|
Structure struct = (Structure) dt;
|
|
this.writeCompositePreDeclaration(struct, monitor);
|
|
this.deferredCompositeDeclarations.add(struct);
|
|
} else if (dt instanceof Union) {
|
|
Union union = (Union) dt;
|
|
this.writeCompositePreDeclaration(union, monitor);
|
|
this.deferredCompositeDeclarations.add(union);
|
|
} else if (dt instanceof Enum) {
|
|
this.writeEnum((Enum) dt, monitor);
|
|
} else if (dt instanceof TypeDef) {
|
|
this.writeTypeDef((TypeDef) dt, monitor);
|
|
} else if (dt instanceof BuiltInDataType) {
|
|
this.writeBuiltIn((BuiltInDataType) dt, monitor);
|
|
} else if (!(dt instanceof BitFieldDataType)) {
|
|
this.writer.write(EOL);
|
|
this.writer.write(EOL);
|
|
this.writer.write(this.comment("Unable to write datatype. Type unrecognized: " + dt.getClass()));
|
|
this.writer.write(EOL);
|
|
this.writer.write(EOL);
|
|
}
|
|
|
|
if (this.writerDepth == 1) {
|
|
this.writeDeferredDeclarations(monitor);
|
|
}
|
|
|
|
--this.writerDepth;
|
|
}
|
|
}
|
|
} else {
|
|
this.write(this.getBaseDataType(dt), monitor);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void writeDeferredDeclarations(TaskMonitor monitor) throws IOException, CancelledException {
|
|
while (!this.deferredTypes.isEmpty()) {
|
|
DataType dt = (DataType) this.deferredTypeFIFO.removeFirst();
|
|
this.deferredTypes.remove(dt);
|
|
this.write(dt, monitor);
|
|
}
|
|
|
|
this.writeDeferredCompositeDeclarations(monitor);
|
|
this.deferredCompositeDeclarations.clear();
|
|
}
|
|
|
|
private DataType getBaseArrayTypedefType(DataType dt) {
|
|
while (true) {
|
|
if (dt != null) {
|
|
if (dt instanceof TypeDef) {
|
|
dt = ((TypeDef) dt).getBaseDataType();
|
|
continue;
|
|
}
|
|
|
|
if (dt instanceof Array) {
|
|
dt = ((Array) dt).getDataType();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return dt;
|
|
}
|
|
}
|
|
|
|
private boolean containsComposite(Composite container, Composite contained) {
|
|
DataTypeComponent[] var3 = container.getDefinedComponents();
|
|
int var4 = var3.length;
|
|
|
|
for (int var5 = 0; var5 < var4; ++var5) {
|
|
DataTypeComponent component = var3[var5];
|
|
DataType dt = this.getBaseArrayTypedefType(component.getDataType());
|
|
if (dt instanceof Composite && dt.getName().equals(contained.getName()) && dt.isEquivalent(contained)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void writeDeferredCompositeDeclarations(TaskMonitor monitor) throws IOException, CancelledException {
|
|
int cnt = this.deferredCompositeDeclarations.size();
|
|
if (cnt != 0) {
|
|
LinkedList<Composite> list = new LinkedList(this.deferredCompositeDeclarations);
|
|
if (list.size() > 1) {
|
|
int sortChange = 1;
|
|
|
|
while (sortChange != 0) {
|
|
sortChange = 0;
|
|
|
|
for (int i = cnt - 1; i > 0; --i) {
|
|
if (this.resortComposites(list, i)) {
|
|
++sortChange;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Iterator var6 = list.iterator();
|
|
|
|
while (var6.hasNext()) {
|
|
Composite composite = (Composite) var6.next();
|
|
this.writeCompositeBody(composite, monitor);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private boolean resortComposites(List<Composite> list, int index) {
|
|
int listSize = list.size();
|
|
if (listSize <= 0) {
|
|
return false;
|
|
} else {
|
|
Composite composite = (Composite) list.get(index);
|
|
|
|
for (int i = 0; i < index; ++i) {
|
|
Composite other = (Composite) list.get(i);
|
|
if (this.containsComposite(other, composite)) {
|
|
list.remove(index);
|
|
list.add(i, composite);
|
|
composite = null;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private String getDynamicComponentString(Dynamic dynamicType, String fieldName, int length) {
|
|
if (dynamicType.canSpecifyLength()) {
|
|
DataType replacementBaseType = dynamicType.getReplacementBaseType();
|
|
if (replacementBaseType != null) {
|
|
replacementBaseType = replacementBaseType.clone(this.dtm);
|
|
int elementLen = replacementBaseType.getLength();
|
|
if (elementLen > 0) {
|
|
int elementCnt = (length + elementLen - 1) / elementLen;
|
|
return replacementBaseType.getDisplayName() + " " + fieldName + "[" + elementCnt + "]";
|
|
}
|
|
|
|
String var10001 = dynamicType.getClass().getSimpleName();
|
|
Msg.error(this,
|
|
var10001 + " returned bad replacementBaseType: " + replacementBaseType.getClass().getSimpleName());
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void writeCompositePreDeclaration(Composite composite, TaskMonitor monitor)
|
|
throws IOException, CancelledException {
|
|
String compositeType = composite instanceof Structure ? "struct" : "union";
|
|
this.writer.write("typedef " + compositeType + " " + composite.getDisplayName() + " " + composite.getDisplayName()
|
|
+ ", *P" + composite.getDisplayName() + ";");
|
|
this.writer.write(EOL);
|
|
this.writer.write(EOL);
|
|
DataTypeComponent[] var4 = composite.getComponents();
|
|
int var5 = var4.length;
|
|
|
|
for (int var6 = 0; var6 < var5; ++var6) {
|
|
DataTypeComponent component = var4[var6];
|
|
if (monitor.isCancelled()) {
|
|
break;
|
|
}
|
|
|
|
DataType componentType = component.getDataType();
|
|
this.deferWrite(componentType);
|
|
this.getTypeDeclaration((String) null, componentType, component.getLength(), true, monitor);
|
|
}
|
|
|
|
}
|
|
|
|
private void writeCompositeBody(Composite composite, TaskMonitor monitor) throws IOException, CancelledException {
|
|
String compositeType = composite instanceof Structure ? "struct" : "union";
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(compositeType + " " + composite.getDisplayName() + " {");
|
|
String descrip = composite.getDescription();
|
|
if (descrip != null && descrip.length() > 0) {
|
|
String var10001 = this.comment(descrip);
|
|
sb.append(" " + var10001);
|
|
}
|
|
|
|
sb.append(EOL);
|
|
DataTypeComponent[] var6 = composite.getComponents();
|
|
int var7 = var6.length;
|
|
|
|
for (int var8 = 0; var8 < var7; ++var8) {
|
|
DataTypeComponent component = var6[var8];
|
|
monitor.checkCancelled();
|
|
this.writeComponent(component, composite, sb, monitor);
|
|
}
|
|
|
|
sb.append(this.annotator.getSuffix(composite, (DataTypeComponent) null));
|
|
sb.append("};");
|
|
this.writer.write(sb.toString());
|
|
this.writer.write(EOL);
|
|
this.writer.write(EOL);
|
|
}
|
|
|
|
private void writeComponent(DataTypeComponent component, Composite composite, StringBuilder sb, TaskMonitor monitor)
|
|
throws IOException, CancelledException {
|
|
sb.append(" ");
|
|
sb.append(this.annotator.getPrefix(composite, component));
|
|
String fieldName = component.getFieldName();
|
|
if (fieldName == null || fieldName.length() == 0) {
|
|
fieldName = component.getDefaultFieldName();
|
|
}
|
|
|
|
DataType componentDataType = component.getDataType();
|
|
sb.append(this.getTypeDeclaration(fieldName, componentDataType, component.getLength(), false, monitor));
|
|
sb.append(";");
|
|
sb.append(this.annotator.getSuffix(composite, component));
|
|
String comment = component.getComment();
|
|
if (comment != null && comment.length() > 0) {
|
|
String var10001 = this.comment(comment);
|
|
sb.append(" " + var10001);
|
|
}
|
|
|
|
sb.append(EOL);
|
|
}
|
|
|
|
private String getTypeDeclaration(String name, DataType dataType, int instanceLength, boolean writeEnabled,
|
|
TaskMonitor monitor) throws IOException, CancelledException {
|
|
if (name == null) {
|
|
name = "";
|
|
}
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
String componentString = null;
|
|
if (dataType instanceof Dynamic) {
|
|
componentString = this.getDynamicComponentString((Dynamic) dataType, name, instanceLength);
|
|
if (componentString != null) {
|
|
sb.append(componentString);
|
|
} else {
|
|
sb.append(this.comment("ignoring dynamic datatype inside composite: " + dataType.getDisplayName()));
|
|
sb.append(EOL);
|
|
}
|
|
}
|
|
|
|
if (componentString == null) {
|
|
if (dataType instanceof BitFieldDataType) {
|
|
BitFieldDataType bfDt = (BitFieldDataType) dataType;
|
|
name = name + ":" + bfDt.getDeclaredBitSize();
|
|
dataType = bfDt.getBaseDataType();
|
|
}
|
|
|
|
label44: while (true) {
|
|
while (!(dataType instanceof Array)) {
|
|
if (!(dataType instanceof Pointer)) {
|
|
break label44;
|
|
}
|
|
|
|
Pointer pointer = (Pointer) dataType;
|
|
DataType elem = pointer.getDataType();
|
|
if (elem == null) {
|
|
break label44;
|
|
}
|
|
|
|
name = "*" + name;
|
|
dataType = elem;
|
|
if (elem instanceof Array) {
|
|
name = "(" + name + ")";
|
|
}
|
|
}
|
|
|
|
Array array = (Array) dataType;
|
|
name = name + "[" + array.getNumElements() + "]";
|
|
dataType = array.getDataType();
|
|
}
|
|
|
|
DataType baseDataType = this.getBaseDataType(dataType);
|
|
if (baseDataType instanceof FunctionDefinition) {
|
|
componentString = this.getFunctionPointerString((FunctionDefinition) baseDataType, name, dataType, writeEnabled,
|
|
monitor);
|
|
} else {
|
|
String var10000 = this.getDataTypePrefix(dataType);
|
|
componentString = var10000 + dataType.getDisplayName();
|
|
if (name.length() != 0) {
|
|
componentString = componentString + " " + name;
|
|
}
|
|
}
|
|
|
|
sb.append(componentString);
|
|
}
|
|
|
|
return sb.toString();
|
|
}
|
|
|
|
private String getDataTypePrefix(DataType dataType) {
|
|
dataType = this.getBaseDataType(dataType);
|
|
if (dataType instanceof Structure) {
|
|
return "struct ";
|
|
} else if (dataType instanceof Union) {
|
|
return "union ";
|
|
} else {
|
|
return dataType instanceof Enum ? "enum " : "";
|
|
}
|
|
}
|
|
|
|
private void writeEnum(Enum enumm, TaskMonitor monitor) throws IOException {
|
|
String enumName = enumm.getDisplayName();
|
|
Writer var10000;
|
|
String var10001;
|
|
if (enumName.startsWith("define_") && enumName.length() > 7 && enumm.getCount() == 1) {
|
|
long val = enumm.getValues()[0];
|
|
var10000 = this.writer;
|
|
var10001 = enumName.substring(7);
|
|
var10000.append("#define " + var10001 + " " + Long.toString(val));
|
|
this.writer.write(EOL);
|
|
this.writer.write(EOL);
|
|
} else {
|
|
this.writer.write("enum " + enumName + " {");
|
|
String description = enumm.getDescription();
|
|
if (description != null && description.length() != 0) {
|
|
var10000 = this.writer;
|
|
var10001 = this.comment(description);
|
|
var10000.write(" " + var10001);
|
|
}
|
|
|
|
this.writer.write(EOL);
|
|
String[] names = enumm.getNames();
|
|
|
|
for (int j = 0; j < names.length; ++j) {
|
|
this.writer.write(" ");
|
|
this.writer.write(this.annotator.getPrefix(enumm, names[j]));
|
|
this.writer.write(names[j]);
|
|
this.writer.write("=");
|
|
this.writer.write(Long.toString(enumm.getValue(names[j])));
|
|
String comment = enumm.getComment(names[j]);
|
|
if (!comment.isBlank()) {
|
|
var10000 = this.writer;
|
|
var10001 = this.comment(comment);
|
|
var10000.write(" " + var10001);
|
|
}
|
|
|
|
this.writer.write(this.annotator.getSuffix(enumm, names[j]));
|
|
if (j < names.length - 1) {
|
|
this.writer.write(",");
|
|
}
|
|
|
|
this.writer.write(EOL);
|
|
}
|
|
|
|
this.writer.write("};");
|
|
this.writer.write(EOL);
|
|
this.writer.write(EOL);
|
|
}
|
|
}
|
|
|
|
private void writeTypeDef(TypeDef typeDef, TaskMonitor monitor) throws IOException, CancelledException {
|
|
String typedefName = typeDef.getDisplayName();
|
|
DataType dataType = typeDef.getDataType();
|
|
String dataTypeName = dataType.getDisplayName();
|
|
if (!this.isIntegral(typedefName, dataTypeName)) {
|
|
DataType baseType = typeDef.getBaseDataType();
|
|
|
|
label125: {
|
|
try {
|
|
if (!(baseType instanceof Composite) && !(baseType instanceof Enum)) {
|
|
if (!(baseType instanceof Pointer) || !typedefName.startsWith("P")) {
|
|
break label125;
|
|
}
|
|
|
|
DataType dt = ((Pointer) baseType).getDataType();
|
|
if (dt instanceof TypeDef) {
|
|
dt = ((TypeDef) dt).getBaseDataType();
|
|
}
|
|
|
|
if (!(dt instanceof Composite) || !dt.getName().equals(typedefName.substring(1))) {
|
|
break label125;
|
|
}
|
|
|
|
this.resolvedTypeMap.remove(typedefName);
|
|
return;
|
|
}
|
|
|
|
if (!typedefName.equals(baseType.getName())) {
|
|
break label125;
|
|
}
|
|
|
|
this.resolvedTypeMap.remove(typedefName);
|
|
} finally {
|
|
this.write(dataType, monitor);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (baseType instanceof Array && this.getBaseArrayTypedefType(baseType) instanceof Composite) {
|
|
this.writeDeferredDeclarations(monitor);
|
|
}
|
|
|
|
String typedefString = this.getTypeDeclaration(typedefName, dataType, -1, true, monitor);
|
|
this.writer.write("typedef " + typedefString + ";");
|
|
this.writer.write(EOL);
|
|
this.writer.write(EOL);
|
|
}
|
|
}
|
|
|
|
private boolean isIntegral(String typedefName, String basetypeName) {
|
|
String[] var3 = INTEGRAL_TYPES;
|
|
int var4 = var3.length;
|
|
|
|
int var5;
|
|
for (var5 = 0; var5 < var4; ++var5) {
|
|
String type = var3[var5];
|
|
if (typedefName.equals(type)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
boolean endsWithIntegralType = false;
|
|
String[] var10 = INTEGRAL_TYPES;
|
|
var5 = var10.length;
|
|
|
|
int var13;
|
|
for (var13 = 0; var13 < var5; ++var13) {
|
|
String type = var10[var13];
|
|
if (typedefName.endsWith(" " + type)) {
|
|
endsWithIntegralType = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
boolean containsIntegralModifier = false;
|
|
String[] var12 = INTEGRAL_MODIFIERS;
|
|
var13 = var12.length;
|
|
|
|
for (int var14 = 0; var14 < var13; ++var14) {
|
|
String modifier = var12[var14];
|
|
if (typedefName.indexOf(modifier + " ") >= 0 || typedefName.indexOf(" " + modifier) >= 0) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (endsWithIntegralType && containsIntegralModifier) {
|
|
return true;
|
|
} else if (typedefName.endsWith(" " + basetypeName)) {
|
|
return containsIntegralModifier;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private void writeDynamicBuiltIn(Dynamic dt, TaskMonitor monitor) throws IOException, CancelledException {
|
|
DataType baseDt = dt.getReplacementBaseType();
|
|
if (baseDt != null) {
|
|
this.write(baseDt, monitor);
|
|
}
|
|
|
|
}
|
|
|
|
private void writeBuiltIn(BuiltInDataType dt, TaskMonitor monitor) throws IOException {
|
|
String declaration = dt.getCTypeDeclaration(this.dataOrganization);
|
|
if (declaration != null) {
|
|
if (dt.getDisplayName() == "bool")
|
|
return;
|
|
this.writer.write(declaration);
|
|
this.writer.write(EOL);
|
|
}
|
|
}
|
|
|
|
private void writeBuiltInDeclarations(DataTypeManager manager) throws IOException {
|
|
try {
|
|
this.write(DataType.DEFAULT, TaskMonitor.DUMMY);
|
|
SourceArchive builtInArchive = manager.getSourceArchive(DataTypeManager.BUILT_IN_ARCHIVE_UNIVERSAL_ID);
|
|
if (builtInArchive == null) {
|
|
return;
|
|
}
|
|
|
|
Iterator var3 = manager.getDataTypes(builtInArchive).iterator();
|
|
|
|
while (var3.hasNext()) {
|
|
DataType dt = (DataType) var3.next();
|
|
if (!(dt instanceof Pointer) && !(dt instanceof FactoryDataType) && !(dt instanceof Dynamic)) {
|
|
this.write(dt, TaskMonitor.DUMMY);
|
|
}
|
|
}
|
|
} catch (CancelledException var5) {
|
|
}
|
|
|
|
this.writer.flush();
|
|
}
|
|
|
|
private static String getArrayDimensions(Array arrayDt) {
|
|
String dimensionString = "[" + arrayDt.getNumElements() + "]";
|
|
DataType dataType = arrayDt.getDataType();
|
|
if (dataType instanceof Array) {
|
|
dimensionString = dimensionString + getArrayDimensions((Array) dataType);
|
|
}
|
|
|
|
return dimensionString;
|
|
}
|
|
|
|
private DataType getBaseDataType(DataType dt) {
|
|
while (true) {
|
|
if (dt != null) {
|
|
if (dt instanceof Array) {
|
|
Array array = (Array) dt;
|
|
dt = array.getDataType();
|
|
continue;
|
|
}
|
|
|
|
if (dt instanceof Pointer) {
|
|
Pointer pointer = (Pointer) dt;
|
|
dt = pointer.getDataType();
|
|
continue;
|
|
}
|
|
|
|
if (dt instanceof BitFieldDataType) {
|
|
BitFieldDataType bitfieldDt = (BitFieldDataType) dt;
|
|
dt = bitfieldDt.getBaseDataType();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return dt;
|
|
}
|
|
}
|
|
|
|
private DataType getArrayBaseType(Array arrayDt) {
|
|
DataType dataType;
|
|
for (dataType = arrayDt.getDataType(); dataType instanceof Array; dataType = ((Array) dataType).getDataType()) {
|
|
}
|
|
|
|
return dataType;
|
|
}
|
|
|
|
private DataType getPointerBaseDataType(Pointer p) {
|
|
DataType dt;
|
|
for (dt = p.getDataType(); dt instanceof Pointer; dt = ((Pointer) dt).getDataType()) {
|
|
}
|
|
|
|
return dt;
|
|
}
|
|
|
|
private int getPointerDepth(Pointer p) {
|
|
int depth = 1;
|
|
|
|
for (DataType dt = p.getDataType(); dt instanceof Pointer; dt = ((Pointer) dt).getDataType()) {
|
|
++depth;
|
|
}
|
|
|
|
return depth;
|
|
}
|
|
|
|
private String getFunctionPointerString(FunctionDefinition fd, String name, DataType functionPointerArrayType,
|
|
boolean writeEnabled, TaskMonitor monitor) throws IOException, CancelledException {
|
|
DataType originalType = functionPointerArrayType;
|
|
StringBuilder sb = new StringBuilder();
|
|
DataType returnType = fd.getReturnType();
|
|
if (writeEnabled) {
|
|
this.write(returnType, monitor);
|
|
}
|
|
|
|
sb.append("(");
|
|
String arrayDecorations = "";
|
|
if (functionPointerArrayType instanceof Array a) {
|
|
functionPointerArrayType = this.getArrayBaseType(a);
|
|
arrayDecorations = getArrayDimensions(a);
|
|
}
|
|
|
|
if (functionPointerArrayType instanceof Pointer p) {
|
|
for (int i = 0; i < this.getPointerDepth(p); ++i) {
|
|
sb.append('*');
|
|
}
|
|
|
|
if (name != null) {
|
|
sb.append(' ');
|
|
}
|
|
|
|
functionPointerArrayType = this.getPointerBaseDataType(p);
|
|
}
|
|
|
|
if (!(functionPointerArrayType instanceof FunctionDefinition)) {
|
|
this.writer.append(this
|
|
.comment("Attempting output of invalid function pointer type declaration: " + originalType.getDisplayName()));
|
|
}
|
|
|
|
if (name != null) {
|
|
sb.append(name);
|
|
}
|
|
|
|
if (arrayDecorations.length() != 0) {
|
|
sb.append(arrayDecorations);
|
|
}
|
|
|
|
sb.append(")");
|
|
sb.append(this.getParameterListString(fd, false, writeEnabled, monitor));
|
|
DataType baseReturnType = this.getBaseDataType(returnType);
|
|
if (baseReturnType instanceof FunctionDefinition) {
|
|
return this.getFunctionPointerString((FunctionDefinition) baseReturnType, sb.toString(), returnType, writeEnabled,
|
|
monitor);
|
|
} else {
|
|
String var10000 = returnType.getDisplayName();
|
|
return var10000 + " " + sb.toString();
|
|
}
|
|
}
|
|
|
|
private String getParameterListString(FunctionDefinition fd, boolean includeParamNames, boolean writeEnabled,
|
|
TaskMonitor monitor) throws IOException, CancelledException {
|
|
StringBuilder buf = new StringBuilder();
|
|
buf.append("(");
|
|
boolean hasVarArgs = fd.hasVarArgs();
|
|
ParameterDefinition[] parameters = fd.getArguments();
|
|
int n = parameters.length;
|
|
|
|
for (int i = 0; i < n; ++i) {
|
|
ParameterDefinition param = parameters[i];
|
|
String paramName = includeParamNames ? param.getName() : null;
|
|
DataType dataType = param.getDataType();
|
|
if (writeEnabled) {
|
|
this.write(dataType, monitor);
|
|
}
|
|
|
|
String argument = this.getTypeDeclaration(paramName, dataType, param.getLength(), writeEnabled, monitor);
|
|
buf.append(argument);
|
|
if (i < n - 1 || hasVarArgs) {
|
|
buf.append(", ");
|
|
}
|
|
}
|
|
|
|
if (hasVarArgs) {
|
|
buf.append("...");
|
|
}
|
|
|
|
if (n == 0 && !hasVarArgs) {
|
|
buf.append(VoidDataType.dataType.getName());
|
|
}
|
|
|
|
buf.append(")");
|
|
return buf.toString();
|
|
}
|
|
}
|