public static string ConvertToMof(QualifierDeclarationAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
if (!string.IsNullOrEmpty(node.Name.Name))
{
source.Append(node.Name.Name);
}
if (node.Initializer != null)
{
if (node.Initializer is LiteralValueAst)
{
source.AppendFormat("({0})", MofGenerator.ConvertToMof(node.Initializer, quirks));
}
else if (node.Initializer is LiteralValueArrayAst)
{
source.Append(MofGenerator.ConvertToMof(node.Initializer, quirks));
}
else
{
throw new InvalidOperationException();
}
}
if (node.Flavors.Count > 0)
{
source.AppendFormat(": {0}", string.Join(" ", node.Flavors.ToArray()));
}
return(source.ToString());
}
public static string ConvertToMof(PropertyDeclarationAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
if ((node.Qualifiers != null) && node.Qualifiers.Qualifiers.Count > 0)
{
source.AppendFormat("{0} ", MofGenerator.ConvertToMof(node.Qualifiers, quirks));
}
source.AppendFormat("{0} ", node.Type.Name);
if (node.IsRef)
{
source.AppendFormat("{0} ", Keywords.REF);
}
source.Append(node.Name.Name);
if (node.IsArray)
{
source.Append("[]");
}
if (node.Initializer != null)
{
source.AppendFormat(" = {0}", MofGenerator.ConvertToMof(node.Initializer, quirks));
}
source.Append(";");
return(source.ToString());
}
public static string ConvertToMof(QualifierListAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
var lastQualifierName = default(string);
source.Append("[");
for (var i = 0; i < node.Qualifiers.Count; i++)
{
var thisQualifier = node.Qualifiers[i];
var thisQualifierName = node.Qualifiers[i].Name.GetNormalizedName();
if (i > 0)
{
source.Append(",");
var quirkEnabled = (quirks & MofQuirks.OmitSpaceBetweenInOutQualifiersForParameterDeclarations) == MofQuirks.OmitSpaceBetweenInOutQualifiersForParameterDeclarations;
if (!quirkEnabled || (lastQualifierName != "in") || (thisQualifierName != "out"))
{
source.Append(" ");
}
}
source.Append(MofGenerator.ConvertToMof(thisQualifier, quirks));
lastQualifierName = thisQualifierName;
}
source.Append("]");
return(source.ToString());
}
public static string ConvertClassDeclarationAst(ClassDeclarationAst node, MofQuirks quirks = MofQuirks.None, string indent = "")
{
var source = new StringBuilder();
if (node.QualifierList.QualifierValues.Any())
{
source.AppendLine(AstMofGenerator.ConvertQualifierListAst(node.QualifierList, quirks));
source.Append(indent);
}
source.Append($"{Constants.CLASS} {node.ClassName.Name}");
if (node.SuperClass != null)
{
source.Append($" : {node.SuperClass.Name}");
}
source.AppendLine();
source.Append(indent);
source.AppendLine("{");
foreach (var classFeature in node.ClassFeatures)
{
source.Append(indent);
source.Append("\t");
source.Append(AstMofGenerator.ConvertClassFeatureAst(classFeature, quirks, indent + '\t'));
source.AppendLine();
}
source.Append(indent);
source.Append("};");
return(source.ToString());
}
public static string ConvertToMof(MethodDeclarationAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
if ((node.Qualifiers != null) && node.Qualifiers.Qualifiers.Count > 0)
{
source.AppendFormat("{0}", MofGenerator.ConvertToMof(node.Qualifiers, quirks));
}
var quirkEnabled = (quirks & MofQuirks.PrefixSpaceBeforeQualifierlessMethodDeclarations) == MofQuirks.PrefixSpaceBeforeQualifierlessMethodDeclarations;
if (quirkEnabled || ((node.Qualifiers != null) && node.Qualifiers.Qualifiers.Count > 0))
{
source.AppendFormat(" ");
}
source.AppendFormat("{0} {1}", node.ReturnType.Name, node.Name.Name);
if (node.Parameters.Count == 0)
{
source.Append("();");
}
else
{
var values = node.Parameters.Select(p => MofGenerator.ConvertToMof(p, quirks)).ToArray();
source.AppendFormat("({0});", string.Join(", ", values));
}
return(source.ToString());
}
public static string ConvertQualifierValueAst(QualifierValueAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
source.Append(node.QualifierName.Extent.Text);
if (node.Initializer != null)
{
source.Append(AstMofGenerator.ConvertIQualifierInitializerAst(node.Initializer));
}
///
/// 7.4 Qualifiers
///
/// NOTE A MOF v2 qualifier declaration has to be converted to MOF v3 qualifierTypeDeclaration because the
/// MOF v2 qualifier flavor has been replaced by the MOF v3 qualifierPolicy.
///
/// These aren't part of the MOF 3.0.1 spec, but we'll include them anyway for backward compatibility.
///
if (node.Flavors.Any())
{
source.Append(": ");
source.Append(
string.Join(
" ",
node.Flavors.Select(f => f.Name)
)
);
}
return(source.ToString());
}
public static string ConvertComplexValueAst(ComplexValueAst node, MofQuirks quirks = MofQuirks.None, string indent = "")
{
if (node.IsAlias)
{
return($"${node.Alias.Name}");
}
else
{
var source = new StringBuilder();
// value of GOLF_PhoneNumber
source.Append(node.Value.Extent.Text);
source.Append(" ");
source.Append(node.Of.Extent.Text);
source.Append(" ");
source.Append(node.TypeName.Name);
source.AppendLine();
// {
// AreaCode = { "9", "0", "7" };
// Number = { "7", "4", "7", "4", "8", "8", "4" };
// }
source.Append(indent);
source.Append(AstMofGenerator.ConvertPropertyValueListAst(node.PropertyValues, quirks, indent));
return(source.ToString());
}
}
public static string ConvertMofProductionAst(MofProductionAst node, MofQuirks quirks = MofQuirks.None)
{
switch (node)
{
case CompilerDirectiveAst ast:
return(AstMofGenerator.ConvertCompilerDirectiveAst(ast, quirks));
case StructureDeclarationAst ast:
return(AstMofGenerator.ConvertStructureDeclarationAst(ast, quirks));
case ClassDeclarationAst ast:
return(AstMofGenerator.ConvertClassDeclarationAst(ast, quirks));
case AssociationDeclarationAst ast:
return(AstMofGenerator.ConvertAssociationDeclarationAst(ast, quirks));
case EnumerationDeclarationAst ast:
return(AstMofGenerator.ConvertEnumerationDeclarationAst(ast, quirks));
case InstanceValueDeclarationAst ast:
return(AstMofGenerator.ConvertInstanceValueDeclarationAst(ast, quirks));
case StructureValueDeclarationAst ast:
return(AstMofGenerator.ConvertStructureValueDeclarationAst(ast, quirks));
case QualifierTypeDeclarationAst ast:
return(AstMofGenerator.ConvertQualifierTypeDeclarationAst(ast, quirks));
default:
throw new NotImplementedException();
}
}
public static string ConvertStringValueAst(StringValueAst node, MofQuirks quirks = MofQuirks.None)
{
return(string.Join(
" ",
node.StringLiteralValues
.Select(n => $"\"{AstMofGenerator.EscapeString(n.Value)}\"")
));
}
public static string ConvertEnumValueAst(EnumValueAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
if (node.EnumName != null)
{
source.Append(node.EnumName.Name);
source.Append(".");
}
source.Append(node.EnumLiteral.Name);
return(source.ToString());
}
public static string ConvertCompilerDirectiveAst(CompilerDirectiveAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
source.Append(node.PragmaKeyword.Extent.Text);
source.Append(" ");
source.Append(node.PragmaName);
source.Append(" ");
source.Append("(");
source.Append(AstMofGenerator.ConvertStringValueAst(node.PragmaParameter));
source.Append(")");
return(source.ToString());
}
public static string ConvertToMof(IEnumerable <Token> tokens, MofQuirks quirks = MofQuirks.None)
{
if (tokens == null)
{
return(null);
}
var source = new StringBuilder();
foreach (var token in tokens)
{
source.Append(token.Extent.Text);
}
return(source.ToString());
}
public static string ConvertComplexTypeValueAst(ComplexTypeValueAst node, MofQuirks quirks = MofQuirks.None, string indent = "")
{
switch (node)
{
case ComplexValueArrayAst ast:
return(AstMofGenerator.ConvertComplexValueArrayAst(ast, quirks, indent));
case ComplexValueAst ast:
return(AstMofGenerator.ConvertComplexValueAst(ast, quirks, indent));
default:
throw new NotImplementedException();
}
}
public static string ConvertClassFeatureAst(IClassFeatureAst node, MofQuirks quirks = MofQuirks.None, string indent = "")
{
switch (node)
{
case IStructureFeatureAst ast:
return(AstMofGenerator.ConvertStructureFeatureAst(ast, quirks, indent));
case MethodDeclarationAst ast:
return(AstMofGenerator.ConvertMethodDeclarationAst(ast, quirks));
default:
throw new NotImplementedException();
}
}
public static string ConvertIEnumElementValueAst(IEnumElementValueAst node, MofQuirks quirks = MofQuirks.None)
{
switch (node)
{
case IntegerValueAst ast:
return(AstMofGenerator.ConvertIntegerValueAst(ast, quirks));
case StringValueAst ast:
return(AstMofGenerator.ConvertStringValueAst(ast, quirks));
default:
throw new NotImplementedException();
}
}
public static string ConvertToMof(MofSpecificationAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
for (var i = 0; i < node.Productions.Count; i++)
{
if (i > 0)
{
source.AppendLine();
}
source.Append(MofGenerator.ConvertToMof(node.Productions[i], quirks));
}
return(source.ToString());
}
public static string ConvertEnumValueArrayAst(EnumValueArrayAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
source.Append("{");
source.Append(
string.Join(
", ",
node.Values.Select(v => AstMofGenerator.ConvertEnumValueAst(v, quirks))
)
);
source.Append("}");
return(source.ToString());
}
public static string ConvertEnumTypeValueAst(EnumTypeValueAst node, MofQuirks quirks = MofQuirks.None)
{
switch (node)
{
case EnumValueAst ast:
return(AstMofGenerator.ConvertEnumValueAst(ast, quirks));
case EnumValueArrayAst ast:
return(AstMofGenerator.ConvertEnumValueArrayAst(ast, quirks));
default:
throw new NotImplementedException();
}
}
public static string ConvertComplexValueArrayAst(ComplexValueArrayAst node, MofQuirks quirks = MofQuirks.None, string indent = "")
{
var source = new StringBuilder();
source.Append("{");
source.Append(
string.Join(
", ",
node.Values
.Select(n => AstMofGenerator.ConvertComplexValueAst(n, quirks, indent))
)
);
source.Append("}");
return(source.ToString());
}
public static string ConvertStructureFeatureAst(IStructureFeatureAst node, MofQuirks quirks = MofQuirks.None, string indent = "")
{
switch (node)
{
case StructureDeclarationAst ast:
return(AstMofGenerator.ConvertStructureDeclarationAst(ast, quirks, indent));
case EnumerationDeclarationAst ast:
return(AstMofGenerator.ConvertEnumerationDeclarationAst(ast, quirks, indent));
case PropertyDeclarationAst ast:
return(AstMofGenerator.ConvertPropertyDeclarationAst(ast, quirks));
default:
throw new NotImplementedException();
}
}
public static string ConvertEnumElementAst(EnumElementAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
if (node.QualifierList.QualifierValues.Any())
{
source.Append(AstMofGenerator.ConvertQualifierListAst(node.QualifierList, quirks));
source.Append(" ");
}
source.Append(node.EnumElementName.Name);
if (node.EnumElementValue != null)
{
source.Append(" = ");
source.Append(AstMofGenerator.ConvertIEnumElementValueAst(node.EnumElementValue, quirks));
}
return(source.ToString());
}
public static string ConvertPropertyValueAst(PropertyValueAst node, MofQuirks quirks = MofQuirks.None, string indent = "")
{
switch (node)
{
case PrimitiveTypeValueAst ast:
return(AstMofGenerator.ConvertPrimitiveTypeValueAst(ast, quirks, indent));
case ComplexTypeValueAst ast:
return(AstMofGenerator.ConvertComplexTypeValueAst(ast, quirks, indent));
//case ReferenceTypeValueAst ast:
case EnumTypeValueAst ast:
return(AstMofGenerator.ConvertEnumTypeValueAst(ast, quirks));
default:
throw new NotImplementedException();
}
}
public static string ConvertMethodDeclarationAst(MethodDeclarationAst node, MofQuirks quirks = MofQuirks.None)
{
var prefixQuirkEnabled = (quirks & MofQuirks.PrefixSpaceBeforeQualifierlessMethodDeclarations) == MofQuirks.PrefixSpaceBeforeQualifierlessMethodDeclarations;
var source = new StringBuilder();
if (node.QualifierList.QualifierValues.Any())
{
source.Append(AstMofGenerator.ConvertQualifierListAst(node.QualifierList, quirks));
}
if (prefixQuirkEnabled || node.QualifierList.QualifierValues.Any())
{
source.Append(" ");
}
source.Append(node.ReturnType.Name);
if (node.ReturnTypeIsArray)
{
source.Append("[]");
}
source.Append(" ");
source.Append(node.Name.Name);
if (node.Parameters.Count == 0)
{
source.Append("();");
}
else
{
var values = node.Parameters.Select(p => AstMofGenerator.ConvertParameterDeclarationAst(p, quirks)).ToArray();
source.Append("(");
source.Append(string.Join(", ", values));
source.Append(");");
}
return(source.ToString());
}
public static string ConvertLiteralValueAst(LiteralValueAst node, MofQuirks quirks = MofQuirks.None)
{
switch (node)
{
case IntegerValueAst ast:
return(AstMofGenerator.ConvertIntegerValueAst(ast, quirks));
case RealValueAst ast:
return(AstMofGenerator.ConvertRealValueAst(ast, quirks));
case BooleanValueAst ast:
return(AstMofGenerator.ConvertBooleanValueAst(ast, quirks));
case NullValueAst ast:
return(AstMofGenerator.ConvertNullValueAst(ast, quirks));
case StringValueAst ast:
return(AstMofGenerator.ConvertStringValueAst(ast, quirks));
default:
throw new NotImplementedException();
}
}
public static string ConvertPropertyValueListAst(PropertyValueListAst node, MofQuirks quirks = MofQuirks.None, string indent = "")
{
// {
var source = new StringBuilder();
source.Append("{");
source.AppendLine();
// Reference = TRUE;
foreach (var propertyValue in node.PropertyValues)
{
source.Append(indent);
source.Append("\t");
source.Append(propertyValue.Key);
source.Append(" = ");
source.Append(AstMofGenerator.ConvertPropertyValueAst(propertyValue.Value, quirks, indent + "\t"));
source.Append(";");
source.AppendLine();
}
// }
source.Append(indent);
source.Append("}");
return(source.ToString());
}
public static string ConvertToMof(ParameterDeclarationAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
if (node.Qualifiers.Qualifiers.Count > 0)
{
source.AppendFormat("{0} ", MofGenerator.ConvertToMof(node.Qualifiers, quirks));
}
source.AppendFormat("{0} ", node.Type.Name);
if (node.IsRef)
{
source.AppendFormat("{0} ", Keywords.REF);
}
source.Append(node.Name.Name);
if (node.IsArray)
{
source.Append("[]");
}
if (node.DefaultValue != null)
{
source.AppendFormat(" = {0}", MofGenerator.ConvertToMof(node.DefaultValue, quirks));
}
return(source.ToString());
}
public static string ConvertToMof(ClassDeclarationAst node, MofQuirks quirks = MofQuirks.None)
{
var source = new StringBuilder();
if ((node.Qualifiers != null) && node.Qualifiers.Qualifiers.Count > 0)
{
source.AppendLine(MofGenerator.ConvertToMof(node.Qualifiers, quirks));
}
if (node.Superclass == null)
{
source.AppendFormat("class {0}\r\n", node.ClassName.Name);
}
else
{
source.AppendFormat("class {0} : {1}\r\n", node.ClassName.Name, node.Superclass.Name);
}
source.AppendLine("{");
foreach (var feature in node.Features)
{
source.AppendFormat("\t{0}\r\n", MofGenerator.ConvertToMof(feature, quirks));
}
source.AppendLine("};");
return(source.ToString());
}
public static string ConvertToMof(NullValueAst node, MofQuirks quirks = MofQuirks.None)
{
return(node.Token.Extent.Text);
}
public static string ConvertToMof(ReferenceTypeValueAst node, MofQuirks quirks = MofQuirks.None)
{
return(string.Format("!!!!!{0}!!!!!", node.GetType().Name));
}
public static string ConvertToMof(StringValueAst node, MofQuirks quirks = MofQuirks.None)
{
return(string.Format("\"{0}\"", MofGenerator.EscapeString(node.Value)));
}
