/// <summary>
/// Determines whether the feature is unsupported by this language.
/// </summary>
/// <param name="reflection"></param>
/// <param name="writer"></param>
/// <returns></returns>
private bool IsUnsupported(XPathNavigator reflection, SyntaxWriter writer)
{
if (IsUnsupportedGeneric(reflection, writer))
{
return(true);
}
if (IsUnsupportedExplicit(reflection, writer))
{
return(true);
}
if (IsUnsupportedUnsafe(reflection, writer))
{
return(true);
}
if (HasAttribute(reflection, "System.NonScriptableAttribute"))
{
writer.WriteMessage("UnsupportedType_ScriptSharp");
return(true);
}
return(false);
}
public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (IsUnsupported(reflection, writer))
{
return;
}
if (reflection.Select(apiParametersExpression).Count > 0)
{
writer.WriteMessage("UnsupportedIndex_" + Language);
return;
}
string memberName = ReadMemberName(reflection);
writer.WriteKeyword("function");
writer.WriteString(" add_");
writer.WriteIdentifier(memberName);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
writer.WriteLine();
writer.WriteKeyword("function");
writer.WriteString(" remove_");
writer.WriteIdentifier(memberName);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
}
/// <summary>
/// Structure syntax is unsupported
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteStructureSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (!this.IsUnsupported(reflection, writer))
{
writer.WriteMessage("UnsupportedStructure_" + this.Language);
}
}
/// <summary>
/// Write out event syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteEventSyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
if (!this.IsUnsupported(reflection, writer))
{
if (reflection.Select(
SyntaxGeneratorTemplate.apiParametersExpression).Count > 0)
{
writer.WriteMessage("UnsupportedIndex_" + this.Language);
}
else
{
string identifier = ReadMemberName(reflection);
writer.WriteKeyword("function");
writer.WriteString(" add_");
writer.WriteIdentifier(identifier);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
writer.WriteLine();
writer.WriteKeyword("function");
writer.WriteString(" remove_");
writer.WriteIdentifier(identifier);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
}
}
}
/// <inheritdoc />
public override void WriteDelegateSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (IsUnsupportedGeneric(reflection, writer))
{
return;
}
writer.WriteMessage("UnsupportedDelegate_" + Language);
}
protected virtual bool IsUnsupportedExplicit(XPathNavigator reflection, SyntaxWriter writer)
{
bool isExplicit = (bool)reflection.Evaluate(apiIsExplicitImplementationExpression);
if (isExplicit)
{
writer.WriteMessage("UnsupportedExplicit_" + Language);
}
return(isExplicit);
}
protected virtual bool IsUnsupportedGeneric(XPathNavigator reflection, SyntaxWriter writer)
{
bool isGeneric = (bool)reflection.Evaluate(apiIsGenericExpression);
if (isGeneric)
{
writer.WriteMessage("UnsupportedGeneric_" + Language);
}
return(isGeneric);
}
protected virtual bool IsUnsupportedUnsafe(XPathNavigator reflection, SyntaxWriter writer)
{
bool isUnsafe = (bool)reflection.Evaluate(apiIsUnsafeExpression);
if (isUnsafe)
{
writer.WriteMessage("UnsupportedUnsafe_" + Language);
}
return(isUnsafe);
}
protected virtual bool IsUnsupportedVarargs(XPathNavigator reflection, SyntaxWriter writer)
{
bool isVarargs = (bool)reflection.Evaluate(apiIsVarargsExpression);
if (isVarargs)
{
writer.WriteMessage("UnsupportedVarargs_" + Language);
}
return(isVarargs);
}
public override void WriteMethodSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
bool isSpecialName = (bool)reflection.Evaluate(apiIsSpecialExpression);
if (isSpecialName)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
}
else
{
WriteNormalMethodSyntax(reflection, writer);
}
}
/// <inheritdoc />
public override void WriteClassSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractTypeExpression);
bool isSealed = (bool)reflection.Evaluate(apiIsSealedTypeExpression);
if (isAbstract && isSealed)
{
writer.WriteMessage("UnsupportedStaticClass_" + Language);
}
else
{
TypeDeclaration(reflection, writer);
}
}
public override void WriteConstructorSyntax (XPathNavigator reflection, SyntaxWriter writer) {
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
if (isStatic) {
writer.WriteMessage("UnsupportedStaticConstructor_" + Language);
} else {
if (IsUnsupportedUnsafe(reflection, writer)) return;
XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression);
WriteAttributeList(reflection, writer);
WriteAccessModifier(reflection, writer);
writer.WriteKeyword("function");
writer.WriteString(" ");
WriteTypeReference(declaringType, writer);
WriteParameterList(reflection, writer);
}
}
/// <summary>
/// Determines whether the feature is unsupported by this language.
/// </summary>
/// <param name="reflection"></param>
/// <param name="writer"></param>
/// <returns></returns>
private bool IsUnsupported(XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupportedGeneric(reflection, writer)) {
return true;
}
if (IsUnsupportedExplicit(reflection, writer)) {
return true;
}
if (IsUnsupportedUnsafe(reflection, writer)) {
return true;
}
if (HasAttribute(reflection, "System.NonScriptableAttribute")) {
writer.WriteMessage("UnsupportedType_ScriptSharp");
return true;
}
return false;
}
/// <inheritdoc />
public override void WriteConstructorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
if (isStatic)
{
writer.WriteMessage("UnsupportedStaticConstructor_" + Language);
}
else
{
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
XPathNavigator declaringType = reflection.SelectSingleNode(apiContainingTypeExpression);
WriteAccessModifier(reflection, writer);
writer.WriteKeyword("function");
writer.WriteString(" ");
WriteTypeReference(declaringType, writer);
WriteParameterList(reflection, writer);
}
}
public override void WriteConstructorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
string name = (string)reflection.Evaluate(apiContainingTypeNameExpression);
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
if (isStatic)
{
// no static constructors in Java
writer.WriteMessage("UnsupportedStaticConstructor_" + Language);
return;
}
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteMethodParameters(reflection, writer);
}
/// <summary>
/// Operator syntax is unsupported
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteOperatorSyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
writer.WriteMessage("UnsupportedOperator_" + this.Language);
}
public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
string identifier;
switch (name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
break;
case "UnaryNegation":
identifier = "-";
break;
case "Increment":
identifier = "++";
break;
case "Decrement":
identifier = "--";
break;
// unary logical operators
case "LogicalNot":
identifier = "Not";
break;
case "True":
identifier = "IsTrue";
break;
case "False":
identifier = "IsFalse";
break;
// binary comparison operators
case "Equality":
identifier = "=";
break;
case "Inequality":
identifier = "<>";
break;
case "LessThan":
identifier = "<";
break;
case "GreaterThan":
identifier = ">";
break;
case "LessThanOrEqual":
identifier = "<=";
break;
case "GreaterThanOrEqual":
identifier = ">=";
break;
// binary math operators
case "Addition":
identifier = "+";
break;
case "Subtraction":
identifier = "-";
break;
case "Multiply":
identifier = "*";
break;
case "Division":
identifier = "/";
break;
case "Exponent":
identifier = "^";
break;
case "Modulus":
identifier = "Mod";
break;
case "IntegerDivision":
identifier = @"\";
break;
// binary logical operators
case "BitwiseAnd":
identifier = "And";
break;
case "BitwiseOr":
identifier = "Or";
break;
case "ExclusiveOr":
identifier = "Xor";
break;
// bit-array operators
case "OnesComplement":
identifier = "~";
break;
case "LeftShift":
identifier = "<<";
break;
case "RightShift":
identifier = ">>";
break;
// concatenation
case "Concatenate":
identifier = "&";
break;
// casting operators
case "Implicit":
case "Explicit":
identifier = "CType";
break;
// didn't recognize an operator
default:
identifier = null;
break;
}
if (identifier == null)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
return;
}
WriteProcedureModifiers(reflection, writer);
if (name == "Implicit")
{
writer.WriteKeyword("Widening");
writer.WriteString(" ");
}
else if (name == "Explicit")
{
writer.WriteKeyword("Narrowing");
writer.WriteString(" ");
}
writer.WriteKeyword("Operator");
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
WriteParameters(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
WriteTypeReference(type, writer);
}
public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupported(reflection, writer)) return;
if (reflection.Select(apiParametersExpression).Count > 0) {
writer.WriteMessage("UnsupportedIndex_" + Language);
return;
}
string memberName = ReadMemberName(reflection);
writer.WriteKeyword("function");
writer.WriteString(" add_");
writer.WriteIdentifier(memberName);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
writer.WriteLine();
writer.WriteKeyword("function");
writer.WriteString(" remove_");
writer.WriteIdentifier(memberName);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
}
public override void WriteDelegateSyntax (XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupportedGeneric(reflection, writer)) return;
writer.WriteMessage("UnsupportedDelegate_" + Language);
}
// operator: done
public override void WriteOperatorSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string name = (string) reflection.Evaluate(apiNameExpression);
string identifier = null;
bool evalulate = (bool)reflection.Evaluate(apiIsUdtReturnExpression);
if (!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
{
switch (name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
break;
case "UnaryNegation":
identifier = "-";
break;
case "Increment":
identifier = "++";
break;
case "Decrement":
identifier = "--";
break;
// unary logical operators
case "LogicalNot":
identifier = "!";
break;
case "True":
identifier = "true";
break;
case "False":
identifier = "false";
break;
// binary comparison operators
case "Equality":
identifier = "==";
break;
case "Inequality":
identifier = "!=";
break;
case "LessThan":
identifier = "<";
break;
case "GreaterThan":
identifier = ">";
break;
case "LessThanOrEqual":
identifier = "<=";
break;
case "GreaterThanOrEqual":
identifier = ">=";
break;
// binary math operators
case "Addition":
identifier = "+";
break;
case "Subtraction":
identifier = "-";
break;
case "Multiply":
identifier = "*";
break;
case "Division":
identifier = "/";
break;
case "Modulus":
identifier = "%";
break;
// binary logical operators
case "BitwiseAnd":
identifier = "&";
break;
case "BitwiseOr":
identifier = "|";
break;
case "ExclusiveOr":
identifier = "^";
break;
// bit-array operators
case "OnesComplement":
identifier = "~";
break;
case "LeftShift":
identifier = "<<";
break;
case "RightShift":
identifier = ">>";
break;
case "Assign":
identifier = "=";
break;
// unrecognized operator
default:
identifier = null;
break;
}
}
if (identifier == null) {
writer.WriteMessage("UnsupportedOperator_" + Language);
} else {
WriteProcedureModifiers(reflection, writer);
WriteReturnValue(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("operator");
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
WriteMethodParameters(reflection, writer);
}
}
/// <summary>
/// Write out event syntax
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteEventSyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
if(!this.IsUnsupported(reflection, writer))
{
if(reflection.Select(
SyntaxGeneratorTemplate.apiParametersExpression).Count > 0)
writer.WriteMessage("UnsupportedIndex_" + this.Language);
else
{
string identifier = ReadMemberName(reflection);
writer.WriteKeyword("function");
writer.WriteString(" add_");
writer.WriteIdentifier(identifier);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
writer.WriteLine();
writer.WriteKeyword("function");
writer.WriteString(" remove_");
writer.WriteIdentifier(identifier);
writer.WriteString("(");
writer.WriteParameter("value");
writer.WriteString(");");
}
}
}
/// <inheritdoc />
public override void WriteEventSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
writer.WriteMessage("UnsupportedEvent_" + Language);
}
/// <summary>
/// Cast syntax is unsupported
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteCastSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
writer.WriteMessage("UnsupportedCast_" + this.Language);
}
protected virtual bool IsUnsupportedExplicit (XPathNavigator reflection, SyntaxWriter writer) {
bool isExplicit = (bool) reflection.Evaluate(apiIsExplicitImplementationExpression);
if (isExplicit) {
writer.WriteMessage("UnsupportedExplicit_" + Language);
}
return(isExplicit);
}
protected virtual bool IsUnsupportedUnsafe(XPathNavigator reflection, SyntaxWriter writer)
{
bool isUnsafe = (bool) reflection.Evaluate(apiIsUnsafeExpression);
if (isUnsafe) {
writer.WriteMessage("UnsupportedUnsafe_" + Language);
}
return(isUnsafe);
}
/// <inheritdoc />
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
if (IsUnsupportedExplicit(reflection, writer))
{
return;
}
if (reflection.Select(apiParametersExpression).Count > 0)
{
writer.WriteMessage("UnsupportedIndex_" + Language);
return;
}
string name = (string)reflection.Evaluate(apiNameExpression);
bool isGettable = (bool)reflection.Evaluate(apiIsReadPropertyExpression);
bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
if (isGettable)
{
string getVisibility = (string)reflection.Evaluate(apiGetVisibilityExpression);
if (!String.IsNullOrEmpty(getVisibility))
{
WriteVisibility(getVisibility, writer);
writer.WriteString(" ");
}
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("function get");
writer.WriteString(" ");
writer.WriteIdentifier(name);
writer.WriteString(" () : ");
WriteTypeReference(type, writer);
writer.WriteLine();
}
if (isSettable)
{
string setVisibility = (string)reflection.Evaluate(apiSetVisibilityExpression);
if (!String.IsNullOrEmpty(setVisibility))
{
WriteVisibility(setVisibility, writer);
writer.WriteString(" ");
}
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("function set");
writer.WriteString(" ");
writer.WriteIdentifier(name);
writer.WriteString(" (");
writer.WriteParameter("value");
writer.WriteString(" : ");
WriteTypeReference(type, writer);
writer.WriteString(")");
}
}
/// <summary>
/// Structure syntax is unsupported
/// </summary>
/// <param name="reflection">The reflection information</param>
/// <param name="writer">The syntax writer to which it is written</param>
public override void WriteStructureSyntax(XPathNavigator reflection,
SyntaxWriter writer)
{
if(!this.IsUnsupported(reflection, writer))
writer.WriteMessage("UnsupportedStructure_" + this.Language);
}
protected virtual bool IsUnsupportedVarargs(XPathNavigator reflection, SyntaxWriter writer)
{
bool isVarargs = (bool) reflection.Evaluate(apiIsVarargsExpression);
if(isVarargs)
writer.WriteMessage("UnsupportedVarargs_" + Language);
return (isVarargs);
}
public override void WriteOperatorSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string name = (string) reflection.Evaluate(apiNameExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
string identifier = null;
if (!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
{
switch (name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
break;
case "UnaryNegation":
identifier = "-";
break;
case "Increment":
identifier = "++";
break;
case "Decrement":
identifier = "--";
break;
// unary logical operators
case "LogicalNot":
identifier = "Not";
break;
case "True":
identifier = "IsTrue";
break;
case "False":
identifier = "IsFalse";
break;
// binary comparison operators
case "Equality":
identifier = "=";
break;
case "Inequality":
identifier = "<>";
break;
case "LessThan":
identifier = "<";
break;
case "GreaterThan":
identifier = ">";
break;
case "LessThanOrEqual":
identifier = "<=";
break;
case "GreaterThanOrEqual":
identifier = ">=";
break;
// binary math operators
case "Addition":
identifier = "+";
break;
case "Subtraction":
identifier = "-";
break;
case "Multiply":
identifier = "*";
break;
case "Division":
identifier = "/";
break;
case "Exponent":
identifier = "^";
break;
case "Modulus":
identifier = "Mod";
break;
case "IntegerDivision":
identifier = @"\";
break;
// binary logical operators
case "BitwiseAnd":
identifier = "And";
break;
case "BitwiseOr":
identifier = "Or";
break;
case "ExclusiveOr":
identifier = "Xor";
break;
// bit-array operators
case "OnesComplement":
identifier = "~";
break;
case "LeftShift":
identifier = "<<";
break;
case "RightShift":
identifier = ">>";
break;
// concatenation
case "Concatenate":
identifier = "&";
break;
// casting operators
case "Implicit":
case "Explicit":
identifier = "CType";
break;
case "Assign":
identifier = "=";
break;
// didn't recognize an operator
default:
identifier = null;
break;
}
}
if (identifier == null) {
writer.WriteMessage("UnsupportedOperator_" + Language);
return;
}
WriteProcedureModifiers(reflection, writer);
if (name == "Implicit") {
writer.WriteKeyword("Widening");
writer.WriteString(" ");
} else if (name == "Explicit") {
writer.WriteKeyword("Narrowing");
writer.WriteString(" ");
}
writer.WriteKeyword("Operator");
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
WriteParameters(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("As");
writer.WriteString(" ");
WriteTypeReference(type, writer);
}
protected virtual bool IsUnsupportedGeneric (XPathNavigator reflection, SyntaxWriter writer) {
bool isGeneric = (bool) reflection.Evaluate(apiIsGenericExpression);
if (isGeneric) {
writer.WriteMessage("UnsupportedGeneric_" + Language);
}
return(isGeneric);
}
/// <inheritdoc />
public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer)
{
if (IsUnsupportedUnsafe(reflection, writer))
{
return;
}
if (IsUnsupportedExplicit(reflection, writer))
{
return;
}
if (reflection.Select(apiParametersExpression).Count > 0)
{
writer.WriteMessage("UnsupportedIndex_" + Language);
return;
}
string name = (string)reflection.Evaluate(apiNameExpression);
bool isGettable = (bool)reflection.Evaluate(apiIsReadPropertyExpression);
bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
if (isGettable)
{
string getVisibility = (string)reflection.Evaluate(apiGetVisibilityExpression);
if (!String.IsNullOrEmpty(getVisibility))
{
WriteVisibility(getVisibility, writer);
writer.WriteString(" ");
}
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("function get");
writer.WriteString(" ");
writer.WriteIdentifier(name);
// Some F# properties don't generate return type info for some reason. It's probably unsupported
// but just ignore them for now and write out what we do have.
if (type != null)
{
writer.WriteString(" () : ");
WriteTypeReference(type, writer);
}
else
{
writer.WriteString(" ()");
}
writer.WriteLine();
}
if (isSettable)
{
string setVisibility = (string)reflection.Evaluate(apiSetVisibilityExpression);
if (!String.IsNullOrEmpty(setVisibility))
{
WriteVisibility(setVisibility, writer);
writer.WriteString(" ");
}
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("function set");
writer.WriteString(" ");
writer.WriteIdentifier(name);
writer.WriteString(" (");
writer.WriteParameter("value");
// Some F# properties don't generate return type info for some reason. It's probably unsupported
// but just ignore them for now and write out what we do have.
if (type != null)
{
writer.WriteString(" : ");
WriteTypeReference(type, writer);
}
writer.WriteString(")");
}
}
public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
string identifier;
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
switch (name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
break;
case "UnaryNegation":
identifier = "-";
break;
case "Increment":
identifier = "++";
break;
case "Decrement":
identifier = "--";
break;
// unary logical operators
case "LogicalNot":
identifier = "not";
break;
case "True":
identifier = "true";
break;
case "False":
identifier = "false";
break;
// binary comparison operators
case "Equality":
identifier = "=";
break;
case "Inequality":
identifier = "<>";
break;
case "LessThan":
identifier = "<";
break;
case "GreaterThan":
identifier = ">";
break;
case "LessThanOrEqual":
identifier = "<=";
break;
case "GreaterThanOrEqual":
identifier = ">=";
break;
// binary math operators
case "Addition":
identifier = "+";
break;
case "Subtraction":
identifier = "-";
break;
case "Multiply":
identifier = "*";
break;
case "Division":
identifier = "/";
break;
case "Modulus":
identifier = "%";
break;
// binary logical operators
case "BitwiseAnd":
identifier = "&&&";
break;
case "BitwiseOr":
identifier = "|||";
break;
case "ExclusiveOr":
identifier = "^^^";
break;
// bit-array operators
case "OnesComplement":
identifier = null; // No F# equiv.
break;
case "LeftShift":
identifier = "<<<";
break;
case "RightShift":
identifier = ">>>";
break;
// unrecognized operator
default:
identifier = null;
break;
}
if (identifier == null)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
}
else
{
if (isStatic)
{
writer.WriteKeyword("static");
writer.WriteString(" ");
}
writer.WriteKeyword("let");
writer.WriteString(" ");
writer.WriteKeyword("inline");
writer.WriteKeyword(" ");
writer.WriteString("(");
writer.WriteIdentifier(identifier);
writer.WriteString(")");
WriteParameters(reflection, writer);
writer.WriteString(" : ");
WriteReturnValue(reflection, writer);
}
}
public override void WriteConstructorSyntax (XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupportedUnsafe(reflection, writer)) return;
string name = (string) reflection.Evaluate(apiContainingTypeNameExpression);
bool isStatic = (bool) reflection.Evaluate(apiIsStaticExpression);
if (isStatic) {
// no static constructors in Java
writer.WriteMessage("UnsupportedStaticConstructor_" + Language);
return;
}
WriteAttributes(reflection, writer);
WriteVisibility(reflection, writer);
writer.WriteString(" ");
writer.WriteIdentifier(name);
WriteMethodParameters(reflection, writer);
}
public override void WriteMethodSyntax (XPathNavigator reflection, SyntaxWriter writer) {
bool isSpecialName = (bool) reflection.Evaluate(apiIsSpecialExpression);
if (isSpecialName) {
writer.WriteMessage("UnsupportedOperator_" + Language);
} else {
WriteNormalMethodSyntax(reflection, writer);
}
}
public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
string identifier;
bool isStatic = (bool)reflection.Evaluate(apiIsStaticExpression);
switch (name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
break;
case "UnaryNegation":
identifier = "-";
break;
case "Increment":
identifier = "++";
break;
case "Decrement":
identifier = "--";
break;
// unary logical operators
case "LogicalNot":
identifier = "not";
break;
case "True":
identifier = "true";
break;
case "False":
identifier = "false";
break;
// binary comparison operators
case "Equality":
identifier = "=";
break;
case "Inequality":
identifier = "<>";
break;
case "LessThan":
identifier = "<";
break;
case "GreaterThan":
identifier = ">";
break;
case "LessThanOrEqual":
identifier = "<=";
break;
case "GreaterThanOrEqual":
identifier = ">=";
break;
// binary math operators
case "Addition":
identifier = "+";
break;
case "Subtraction":
identifier = "-";
break;
case "Multiply":
identifier = "*";
break;
case "Division":
identifier = "/";
break;
case "Modulus":
identifier = "%";
break;
// binary logical operators
case "BitwiseAnd":
identifier = "&&&";
break;
case "BitwiseOr":
identifier = "|||";
break;
case "ExclusiveOr":
identifier = "^^^";
break;
// bit-array operators
case "OnesComplement":
identifier = null; // No F# equiv.
break;
case "LeftShift":
identifier = "<<<";
break;
case "RightShift":
identifier = ">>>";
break;
// unrecognized operator
default:
identifier = null;
break;
}
if (identifier == null)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
}
else
{
if (isStatic)
{
writer.WriteKeyword("static");
writer.WriteString(" ");
}
writer.WriteKeyword("let");
writer.WriteString(" ");
writer.WriteKeyword("inline");
writer.WriteKeyword(" ");
writer.WriteString("(");
writer.WriteIdentifier(identifier);
writer.WriteString(")");
WriteParameters(reflection, writer);
writer.WriteString(" : ");
WriteReturnValue(reflection, writer);
}
}
public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
string identifier;
switch (name)
{
case "UnaryPlus":
identifier = "+";
break;
case "UnaryNegation":
identifier = "-";
break;
case "Increment":
identifier = "++";
break;
case "Decrement":
identifier = "--";
break;
// unary logical operators
case "LogicalNot":
identifier = "!";
break;
// binary comparison operators
case "Equality":
identifier = "==";
break;
case "Inequality":
identifier = "!=";
break;
case "LessThan":
identifier = "<";
break;
case "GreaterThan":
identifier = ">";
break;
case "LessThanOrEqual":
identifier = "<=";
break;
case "GreaterThanOrEqual":
identifier = ">=";
break;
// binary math operators
case "Addition":
identifier = "+";
break;
case "Subtraction":
identifier = "-";
break;
case "Multiply":
identifier = "*";
break;
case "Division":
identifier = "/";
break;
case "Modulus":
identifier = "%";
break;
// binary logical operators
case "BitwiseAnd":
identifier = "&";
break;
case "BitwiseOr":
identifier = "|";
break;
case "ExclusiveOr":
identifier = "^";
break;
// bit-array operators
case "OnesComplement":
identifier = "~";
break;
case "LeftShift":
identifier = "<<";
break;
case "RightShift":
identifier = ">>";
break;
// others
case "Comma":
identifier = ",";
break;
case "MemberSelection":
identifier = "->";
break;
case "AddressOf":
identifier = "&";
break;
case "PointerDereference":
identifier = "*";
break;
case "Assign":
identifier = "=";
break;
// unrecognized operator
default:
identifier = null;
break;
}
if (identifier == null)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
}
else
{
WriteProcedureVisibility(reflection, writer);
WritePrefixProcedureModifiers(reflection, writer);
WriteReturnValue(reflection, writer);
writer.WriteString(" ");
writer.WriteKeyword("operator");
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
WriteMethodParameters(reflection, writer);
}
}
public override void WriteOperatorSyntax (XPathNavigator reflection, SyntaxWriter writer) {
string name = (string) reflection.Evaluate(apiNameExpression);
XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression);
// Determine operator identifier and type
string identifier = null;
int type = 0;
if (!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
{
switch (name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
type = -1;
break;
case "UnaryNegation":
identifier = "-";
type = -1;
break;
case "Increment":
identifier = "++";
type = +1;
break;
case "Decrement":
identifier = "--";
type = +1;
break;
// unary logical operators
case "LogicalNot":
identifier = "Not";
type = -1;
break;
case "True":
identifier = "IsTrue";
type = -1;
break;
case "False":
identifier = "IsFalse";
type = -1;
break;
// binary comparison operators
case "Equality":
identifier = "=";
type = 2;
break;
case "Inequality":
identifier = "<>";
type = 2;
break;
case "LessThan":
identifier = "<";
type = 2;
break;
case "GreaterThan":
identifier = ">";
type = 2;
break;
case "LessThanOrEqual":
identifier = "<=";
type = 2;
break;
case "GreaterThanOrEqual":
identifier = ">=";
type = 2;
break;
// binary math operators
case "Addition":
identifier = "+";
type = 2;
break;
case "Subtraction":
identifier = "-";
type = 2;
break;
case "Multiply":
identifier = "*";
type = 2;
break;
case "Division":
identifier = "/";
type = 2;
break;
case "Exponent":
identifier = "^";
type = 2;
break;
case "Modulus":
identifier = "Mod";
type = 2;
break;
case "IntegerDivision":
identifier = @"\";
type = 2;
break;
// binary logical operators
case "BitwiseAnd":
identifier = "And";
type = 2;
break;
case "BitwiseOr":
identifier = "Or";
type = 2;
break;
case "ExclusiveOr":
identifier = "Xor";
type = 2;
break;
// bit-array operators
case "OnesComplement":
identifier = "~";
type = -1;
break;
case "LeftShift":
identifier = "<<";
type = 2;
break;
case "RightShift":
identifier = ">>";
type = 2;
break;
// concatenation
case "Concatenate":
identifier = "&";
type = 2;
break;
case "Assign":
identifier = "=";
type = 2;
break;
// didn't recognize an operator
default:
identifier = null;
type = 0;
break;
}
}
if (identifier == null) {
writer.WriteMessage("UnsupportedOperator_" + Language);
} else {
XPathNodeIterator parameters = reflection.Select(apiParametersExpression);
if (parameters.Count != Math.Abs(type)) {
writer.WriteMessage("UnsupportedOperator_" + Language);
return;
} //throw new InvalidOperationException("An operator has the wrong number of parameters.");
WriteParameterDeclarations(reflection, writer);
ParameterDeclaration("returnValue", returnType, writer);
writer.WriteLine();
writer.WriteParameter("returnValue");
writer.WriteString(" = ");
switch (type) {
case -1:
writer.WriteIdentifier(identifier);
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
break;
case +1:
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
writer.WriteIdentifier(identifier);
break;
case 2:
writer.WriteString("(");
// parameter 1
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
writer.WriteString(" ");
// parameter 2
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
writer.WriteString(")");
break;
}
}
}
/// <inheritdoc />
public override void WriteOperatorSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
string name = (string)reflection.Evaluate(apiNameExpression);
XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression);
// Determine operator identifier and type
string identifier = null;
int type = 0;
if (!(bool)reflection.Evaluate(apiIsUdtReturnExpression))
{
switch (name)
{
// unary math operators
case "UnaryPlus":
identifier = "+";
type = -1;
break;
case "UnaryNegation":
identifier = "-";
type = -1;
break;
case "Increment":
identifier = "++";
type = +1;
break;
case "Decrement":
identifier = "--";
type = +1;
break;
// unary logical operators
case "LogicalNot":
identifier = "Not";
type = -1;
break;
case "True":
identifier = "IsTrue";
type = -1;
break;
case "False":
identifier = "IsFalse";
type = -1;
break;
// binary comparison operators
case "Equality":
identifier = "=";
type = 2;
break;
case "Inequality":
identifier = "<>";
type = 2;
break;
case "LessThan":
identifier = "<";
type = 2;
break;
case "GreaterThan":
identifier = ">";
type = 2;
break;
case "LessThanOrEqual":
identifier = "<=";
type = 2;
break;
case "GreaterThanOrEqual":
identifier = ">=";
type = 2;
break;
// binary math operators
case "Addition":
identifier = "+";
type = 2;
break;
case "Subtraction":
identifier = "-";
type = 2;
break;
case "Multiply":
identifier = "*";
type = 2;
break;
case "Division":
identifier = "/";
type = 2;
break;
case "Exponent":
identifier = "^";
type = 2;
break;
case "Modulus":
identifier = "Mod";
type = 2;
break;
case "IntegerDivision":
identifier = @"\";
type = 2;
break;
// binary logical operators
case "BitwiseAnd":
identifier = "And";
type = 2;
break;
case "BitwiseOr":
identifier = "Or";
type = 2;
break;
case "ExclusiveOr":
identifier = "Xor";
type = 2;
break;
// bit-array operators
case "OnesComplement":
identifier = "~";
type = -1;
break;
case "LeftShift":
identifier = "<<";
type = 2;
break;
case "RightShift":
identifier = ">>";
type = 2;
break;
// concatenation
case "Concatenate":
identifier = "&";
type = 2;
break;
case "Assign":
identifier = "=";
type = 2;
break;
// didn't recognize an operator
default:
identifier = null;
type = 0;
break;
}
}
if (identifier == null)
{
writer.WriteMessage("UnsupportedOperator_" + Language);
}
else
{
XPathNodeIterator parameters = reflection.Select(apiParametersExpression);
if (parameters.Count != Math.Abs(type))
{
writer.WriteMessage("UnsupportedOperator_" + Language);
return;
} //throw new InvalidOperationException("An operator has the wrong number of parameters.");
WriteParameterDeclarations(reflection, writer);
ParameterDeclaration("returnValue", returnType, writer);
writer.WriteLine();
writer.WriteParameter("returnValue");
writer.WriteString(" = ");
switch (type)
{
case -1:
writer.WriteIdentifier(identifier);
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
break;
case +1:
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
writer.WriteIdentifier(identifier);
break;
case 2:
writer.WriteString("(");
// parameter 1
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
writer.WriteString(" ");
writer.WriteIdentifier(identifier);
writer.WriteString(" ");
// parameter 2
parameters.MoveNext();
writer.WriteParameter((string)parameters.Current.Evaluate(parameterNameExpression));
writer.WriteString(")");
break;
}
}
}
public override void WritePropertySyntax (XPathNavigator reflection, SyntaxWriter writer) {
if (IsUnsupportedUnsafe(reflection, writer)) return;
if (IsUnsupportedExplicit(reflection, writer)) return;
if (reflection.Select(apiParametersExpression).Count > 0) {
writer.WriteMessage("UnsupportedIndex_" + Language);
return;
}
string name = (string)reflection.Evaluate(apiNameExpression);
bool isGettable = (bool)reflection.Evaluate(apiIsReadPropertyExpression);
bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression);
XPathNavigator type = reflection.SelectSingleNode(apiReturnTypeExpression);
if (isGettable) {
WriteAttributeList(reflection, writer);
string getVisibility = (string)reflection.Evaluate(apiGetVisibilityExpression);
if (!String.IsNullOrEmpty(getVisibility))
{
WriteVisibility(getVisibility, writer);
writer.WriteString(" ");
}
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("function get");
writer.WriteString(" ");
writer.WriteIdentifier(name);
writer.WriteString(" () : ");
WriteTypeReference(type, writer);
writer.WriteLine();
}
if (isSettable) {
WriteAttributeList(reflection, writer);
string setVisibility = (string)reflection.Evaluate(apiSetVisibilityExpression);
if (!String.IsNullOrEmpty(setVisibility))
{
WriteVisibility(setVisibility, writer);
writer.WriteString(" ");
}
WriteProcedureModifiers(reflection, writer);
writer.WriteKeyword("function set");
writer.WriteString(" ");
writer.WriteIdentifier(name);
writer.WriteString(" (");
writer.WriteParameter("value");
writer.WriteString(" : ");
WriteTypeReference(type, writer);
writer.WriteString(")");
}
}
public override void WriteCastSyntax(XPathNavigator reflection, SyntaxWriter writer)
{
writer.WriteMessage("UnsupportedCast_" + Language);
}
public override void WriteClassSyntax (XPathNavigator reflection, SyntaxWriter writer) {
bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractTypeExpression);
bool isSealed = (bool)reflection.Evaluate(apiIsSealedTypeExpression);
if (isAbstract && isSealed) {
writer.WriteMessage("UnsupportedStaticClass_" + Language);
} else {
TypeDeclaration(reflection, writer);
}
}
