private static boolean hasEnum(Method m) {
boolean result = (Type.ENUM == m.getReturnType().getDetailedType());
Iterator i = m.getArgumentList().iterator();
while (!result && i.hasNext()) {
Argument arg = (Argument) i.next();
result = (arg.getType().getDetailedType() == Type.ENUM);
}
return result;
}
public static String getArgumentWithFormal(
Argument arg, Context context, boolean objPtr, boolean inStub, boolean isExec)
throws CodeGenerationException {
final Type type = arg.getType();
if (Type.ENUM == type.getDetailedType()) {
return getEnumName(type.getSymbolID())
+ ((arg.getMode() != Argument.IN) ? "* " : " ")
+ arg.getFormalName();
} else {
return IOR.getArgumentWithFormal(arg, context, objPtr, inStub, isExec);
}
}
/**
* Create a comment to describe the SIDL type for the C signature.
*
* @param arg the argument to make a comment from
* @return usually this is just the mode as a string. For arrays and rarrays more information is
* returned.
*/
public static String argComment(Argument arg) {
final Type argType = arg.getType();
if (Type.ARRAY == argType.getDetailedType()) {
StringBuffer buf = new StringBuffer(arg.getModeString());
if (argType.isRarray()) {
buf.append(" rarray[");
Iterator i = argType.getArrayIndexExprs().iterator();
while (i.hasNext()) {
AssertionExpression ae = (AssertionExpression) i.next();
buf.append(ae.accept(new CExprString(), null).toString());
if (i.hasNext()) buf.append(',');
}
buf.append(']');
} else {
buf.append(' ');
buf.append(argType.getTypeString());
}
return buf.toString();
} else {
return arg.getModeString();
}
}
/**
* Generate the specified argument list.
*
* @param writer the language writer.
* @param self the String representing the method's self argument name.
* @param args the basic argument list for the method.
* @param isStatic the boolean indicating whether the method is static.
* @param excVar the variable to be used for the exception argument; NULL if no exception argument
* to be generated.
* @param returnType the return type of the method OR null if the method return type should not be
* included.
* @param objPtr TRUE if the object pointer type should be returned; FALSE otherwise.
* @param doRaw the boolean indicating if special raw array argument handling is needed.
* @param deref_inout if true, out and inout arguments are dereferenced in passing. (Used for pre
* and post hooks)
* @exception gov.llnl.babel.backend.CodeGenerationException this is a catch all exception. It can
* be caused by I/O trouble or violations of the data type invariants.
*/
public static void generateArguments(
LanguageWriterForC writer,
Context context,
String self,
List args,
boolean isStatic,
String excVar,
Type returnType,
boolean addType,
boolean objPtr,
boolean doRaw,
boolean deref_inout)
throws CodeGenerationException {
boolean doThrows = (excVar != null) && !excVar.equals("");
boolean doReturn = false; // (returnType != null)
// && (returnType.getType() != Type.VOID);
/*
* If the method is not static, then it will begin with an
* object reference.
*/
if (!isStatic) {
if (addType) {
writer.print("/* in */ ");
}
writer.print(self);
if ((args.size() > 0) || doThrows || doReturn) {
writer.println(",");
}
} else if (addType && (args.size() == 0) && !doThrows && !doReturn) {
writer.print("void");
}
/*
* Output each argument in turn.
*/
for (Iterator a = args.iterator(); a.hasNext(); ) {
Argument arg = (Argument) a.next();
boolean isRaw = doRaw && arg.getType().isRarray();
if (addType) {
writer.print("/* " + argComment(arg) + " */ ");
if (deref_inout && arg.getMode() != Argument.IN) {
writer.print(" *");
}
writer.print(C.getArgumentWithFormal(arg, context, objPtr, isRaw, false));
} else if (isRaw) {
if (arg.getMode() == Argument.INOUT) {
writer.print("&");
}
writer.print(arg.getFormalName() + RAW_ARRAY_EXT);
} else {
if (deref_inout && arg.getMode() != Argument.IN) {
writer.print(" *");
}
if ((arg.getMode() != Argument.IN) && (arg.getType().getDetailedType() == Type.ENUM)) {
writer.print("&_proxy_");
}
writer.print(arg.getFormalName());
}
if (a.hasNext() || doThrows || doReturn) {
writer.println(",");
}
}
/*
* If there is a throws clause that is to be included, return the
* exception type as the last item in the argument list associated with
* the method.
*/
if (doThrows) {
if (addType) {
writer.print("/* out */ ");
if (objPtr) {
writer.print(s_exceptionObjPtr + " *");
} else {
writer.print(s_exceptionType + " *");
}
}
writer.print(excVar);
if (doReturn) {
writer.println(",");
}
}
/*
* Finally, the return type (if appropriate).
*/
if (doReturn) {
if (addType) {
writer.print("/* in */ ");
writer.print(C.getReturnString(returnType, context, objPtr, false));
}
writer.print(" " + FUNCTION_RESULT);
}
}
