/** @brief Generates the signature for the class constructors */
private static void generateSignature(IndentWriter writer, IXMLElement constructor)
throws IOException {
assert (DebugMsg.debugMsg("ClassWriter", "Begin ClassWriter::generateSignature"));
writer.write("constructor(");
boolean comma = false;
for (Enumeration e = constructor.enumerateChildren(); e.hasMoreElements(); ) {
IXMLElement element = (IXMLElement) e.nextElement();
if (!element.getName().equals("arg")) {
break;
}
String argType = XMLUtil.typeOf(element);
String argName = XMLUtil.getAttribute(element, "name");
if (comma) {
writer.write(", ");
}
// Argument are structured as: <arg name="argName" type="argType"/>
if (argType.equals(NddlXmlStrings.x_int)) writer.write("int " + argName);
else if (argType.equals(NddlXmlStrings.x_float)) writer.write("double " + argName);
else if (argType.equals(NddlXmlStrings.x_boolean)) writer.write("bool " + argName);
else if (argType.equals(NddlXmlStrings.x_string)
|| argType.equals(NddlXmlStrings.x_symbol)
|| ModelAccessor.isEnumeration(argType)) writer.write("const LabelStr& " + argName);
else writer.write("const " + argType + "Id& " + argName);
comma = true;
}
writer.write(")");
assert (DebugMsg.debugMsg("ClassWriter", "End ClassWriter::generateSignature"));
}
/**
* Helper method to generate the signatures for binding the factory. Must account for the
* inheritance relationships for any arguments that are classes. Ths, each argument can
* potentially result in a range of values for type, and we have to handle the cross product of
* all of these.
*/
private static Vector makeFactoryNames(IXMLElement constructor) {
String factoryName = XMLUtil.nameOf(constructor.getParent());
Vector allPermutations = new Vector();
for (Enumeration e = constructor.enumerateChildren(); e.hasMoreElements(); ) {
IXMLElement element = (IXMLElement) e.nextElement();
if (!element.getName().equals("arg")) {
break;
}
String argType = XMLUtil.typeOf(element);
Vector argTypeAlternates = new Vector();
argTypeAlternates.add(argType);
if (ModelAccessor.isClass(argType)) {
List ancestors = ModelAccessor.getAncestors(argType);
if (ancestors != null) argTypeAlternates.addAll(ancestors);
}
allPermutations.add(argTypeAlternates);
}
// Generate all the signatures
Vector factoryNames = new Vector();
makeFactoryNames(factoryName, allPermutations, 0, factoryNames);
return factoryNames;
}
private static void generateChildren(IndentWriter writer, IXMLElement parent) throws IOException {
for (Enumeration e = parent.enumerateChildren(); e.hasMoreElements(); ) {
IXMLElement element = (IXMLElement) e.nextElement();
if (element.getName().equals("enum")) {
EnumerationWriter.generateImplementation(writer, element);
} else if (element.getName().equals("predicate")) {
PredicateWriter.generateImplementation(writer, element);
} else if (element.getName().equals("var")) {
} else if (element.getName().equals("constructor")) {
defineConstructor(writer, element);
generateFactory(writer, element);
} else {
System.err.println("generateImplementation:");
XMLUtil.dump(element);
}
}
}
public void load(IXMLElement xml) throws Exception {
super.load(xml);
final int priority = parameters().getAttribute(PARAM_PRIORITY, 3);
this.socials = new MudObjectInterpreter(getName(), priority, this);
for (Enumeration enu = xml.enumerateChildren(); enu.hasMoreElements(); ) {
IXMLElement nxt = (IXMLElement) enu.nextElement();
String nom = nxt.getName();
if (nom.equals(Social.MARKUP)) {
this.socials.addCommand(Social.loadSocial(nxt));
} else if (nom.equals(PROPERTY_SOCIALS)) {
loadSocialsElement(nxt);
}
}
}
public static void defineConstructor(IndentWriter writer, IXMLElement constructor)
throws IOException {
assert (DebugMsg.debugMsg("ClassWriter", "Begin ClassWriter::defineConstructor"));
IXMLElement klass = constructor.getParent();
SharedWriter.generateFileLocation(writer, klass);
if (klass == null) {
throw new RuntimeException("missing class for constructor");
}
String longname = XMLUtil.nameOf(klass);
writer.write("void " + longname + "::");
generateSignature(writer, constructor);
writer.write(" {\n");
writer.indent();
// If the constructor has a call to the super class, invoke it.
assert (DebugMsg.debugMsg(
"ClassWriter", "ClassWriter::defineConstructor - getting children named 'super'"));
Vector superCalls = constructor.getChildrenNamed("super");
assert (DebugMsg.debugMsg(
"ClassWriter",
"ClassWriter::defineConstructor - " + superCalls.size() + " children named retrieved"));
if (!superCalls.isEmpty()) {
assert (DebugMsg.debugMsg("ClassWriter", "ClassWriter::defineConstructor - calling super"));
if (superCalls.size() > 1) writer.write("!ERROR: AT MOST ONE CALL TO SUPER ALLOWED\n");
IXMLElement superCall = (IXMLElement) superCalls.elementAt(0);
String superClass = ModelAccessor.getParentClassName(klass);
String superCppClass = ModelAccessor.getCppClass(superClass);
writer.write(superCppClass + "::constructor(");
String comma = "";
Enumeration arguments = superCall.enumerateChildren();
while (arguments.hasMoreElements()) {
IXMLElement argument = (IXMLElement) arguments.nextElement();
String value = ModelAccessor.getValue(argument);
if (argument.getName().equals("value")
&& XMLUtil.getAttribute(argument, "type").equals("string"))
writer.write(comma + "\"" + value + "\"");
else writer.write(comma + value);
comma = ", ";
}
writer.write(");\n");
}
Set allocatedMemberVariables = new HashSet(); // Store names as we go for reference
/* Now capture names of constructor arguments */
Set constructorArguments = new HashSet(); // Store for names of constructor arguments
{
Vector args = constructor.getChildrenNamed("arg");
assert (DebugMsg.debugMsg(
"ClassWriter",
"ClassWriter::defineConstructor - getting " + args.size() + " arguments"));
for (int i = 0; i < args.size(); i++) {
IXMLElement arg = (IXMLElement) args.elementAt(i);
String argName = XMLUtil.getAttribute(arg, "name");
constructorArguments.add(argName);
}
}
Vector constructorAssignments = constructor.getChildrenNamed("assign");
Vector classVariables = klass.getChildrenNamed("var");
// Use the set below to track when an assignment is being made more than once for same variable
Set assignmentsMade = new HashSet();
for (int i = 0; i < constructorAssignments.size(); i++) {
IXMLElement element = (IXMLElement) constructorAssignments.elementAt(i);
String target = XMLUtil.getAttribute(element, "name");
if (assignmentsMade.contains(target)) {
writer.write("!ERROR: Duplicate assignment for " + target + "\n");
} else {
assignmentsMade.add(target);
// String type = getVariableType(classVariables, target);
// trust in the parser, for it will assign the correct types
String type = XMLUtil.getAttribute(element, "type");
IXMLElement sourceElement = element.getChildAtIndex(0);
if (sourceElement.getName().equals("new")) { // Handle object allocation
assert (DebugMsg.debugMsg(
"ClassWriter", "ClassWriter::defineConstructor - allocating object for " + target));
String sourceType = XMLUtil.typeOf(sourceElement);
writer.write(target + " = addVariable(");
writer.write(
sourceType
+ "Domain((new "
+ sourceType
+ "(m_id, \""
+ target
+ "\"))->getId(), \""
+ sourceType
+ "\")");
writer.write(", " + makeObjectVariableNameString(target) + ");\n");
writer.write(
"Id<"
+ type
+ ">(singleton("
+ target
+ "))->constructor("
+ buildArguments(
classVariables, constructorArguments, allocatedMemberVariables, sourceElement)
+ ");\n"); // Invoke initialization
writer.write(
"Id<"
+ type
+ ">(singleton("
+ target
+ "))->handleDefaults();\n"); // Default variable setup
} else { // Handle variable allocation
String value = ModelAccessor.getValue(sourceElement);
if (sourceElement.getName().equals("id") && type.equals(NddlXmlStrings.x_string))
value = XMLUtil.escapeQuotes(value);
else if (sourceElement.getName().equals(NddlXmlStrings.x_symbol)
|| XMLUtil.getAttribute(sourceElement, "type").equals(NddlXmlStrings.x_string))
value = "LabelStr(\"" + XMLUtil.escapeQuotes(value) + "\")";
else if (ModelAccessor.isNumericPrimitive(type)
&& !type.equals(NddlXmlStrings.x_boolean)) {
// Set both bounds to singleton value
value = value + ", " + value;
}
writer.write(target + " = addVariable(");
if (allocatedMemberVariables.contains(
value)) // If we are assigning one member to another, we obtain the base domain for it
writer.write(value + "->baseDomain()");
else writer.write(ModelAccessor.getDomain(type) + "(" + value + ", \"" + type + "\")");
writer.write(", " + makeObjectVariableNameString(target) + ");\n");
}
// Add member to the set
allocatedMemberVariables.add(target);
}
}
writer.unindent();
writer.write("}\n");
assert (DebugMsg.debugMsg("ClassWriter", "End ClassWriter::defineConstructor"));
}