public virtual void AddContractNameAttribute(ManifestBuilder mfb,
XmlNode node,
MetaDataCustomAttribute data,
string contractName)
{
mfb.AddAttribute(node, "contractName", contractName);
}
public static void Main(String[] args)
{
Console.WriteLine("MkMsil:");
ArrayList streams = new ArrayList();
foreach (string arg in args)
{
streams.Add(new MetaDataResolver.LoadedStream(arg,
Path.GetFullPath(arg),
new FileStream(arg,
FileMode.Open,
FileAccess.Read,
FileShare.Read)));
}
Console.WriteLine("-----------------------------------------------------------------");
MetaDataResolver resolver = new MetaDataResolver(streams, false, false, false);
Console.WriteLine("-----------------------------------------------------------------");
MetaDataResolver.ResolveCustomAttributes(new MetaDataResolver[] { resolver });
Console.WriteLine("-----------------------------------------------------------------");
MetaDataTypeDefinition shellCommandAttribute
= resolver.ResolveName("Microsoft.Singularity.Shell.ShellCommandAttribute");
Console.WriteLine("{0}", shellCommandAttribute);
Console.WriteLine("-----------------------------------------------------------------");
#if DONT
foreach (MetaData metadata in resolver.MetaDataList)
{
DumpMetaData(metadata);
}
#endif
foreach (MetaData metadata in resolver.MetaDataList)
{
foreach (MetaDataTypeDefinition type in metadata.TypeDefs)
{
foreach (MetaDataMethod method in type.Methods)
{
MetaDataCustomAttribute attribute
= MethodFindAttribute(method, shellCommandAttribute);
if (attribute != null)
{
Console.WriteLine("new ShellCommand(\"{0}\", \"{1}\", new Command({2})),",
attribute.FixedArgs[0],
attribute.FixedArgs[1],
method.Name);
}
}
}
}
}
public XmlNode CreateNodeIndexed(MetaDataCustomAttribute data,
TokenDefinition rule,
int index
)
{
XmlNode node = CreateNode(data, rule);
AddAttribute(node, "id", index.ToString());
return(node);
}
// This is the only way we create XML tags (except for Endpoints)
public XmlNode CreateNode(MetaDataCustomAttribute data,
TokenDefinition rule)
{
XmlNode node = AddElement(null, rule.xmlTagName);
// make an attribute for each constructor argument
if (data.FixedArgs.Length != 0)
{
for (int i = 0; i < data.FixedArgs.Length; i++)
{
string name = rule.constructorFields[i];
if (data.FixedArgs[i] == null)
{
AddAttribute(node, name, "");
}
else
{
string value = data.FixedArgs[i].ToString();
AddAttribute(node, name, value);
}
}
}
// make an attribute for each constructor-time property
for (int i = 0; i < data.NamedArgs.Length; i++)
{
string name = rule.FindPropertyReplacement(data.NamedArgs[i].Name);
object arg = data.NamedArgs[i].Value;
string value;
if (arg == null)
{
// REVIEW: do we want "" or null here?
value = null;
}
else
{
value = data.NamedArgs[i].Value.ToString();
if (arg is System.UInt32)
{
// We output unsigned types as 0x because they are generally
// hardware-related numbers which are documented in hexadecimal.
value = String.Format("0x{0:x}", arg);
}
}
AddAttribute(node, name, value);
}
// make an attribute for each default field
for (int i = 0; i < rule.defaultFields.Length; i += 2)
{
string name = rule.defaultFields[i];
AddAttribute(node, name, rule.defaultFields[i + 1]);
}
return(node);
}
public override void AddContractNameAttribute(ManifestBuilder mfb,
XmlNode node,
MetaDataCustomAttribute data,
string contractName)
{
// takes endpoint type as argument
if (data.FixedArgs == null || data.FixedArgs.Length != 1)
{
mfb.Error("ServiceEndpoint attribute must have 1 type argument");
return;
}
// now make it easy to split into name=value pairs by doing some
// string replacing
string ctorArgument = "contractName=" + data.FixedArgs[0];
ctorArgument = ctorArgument.Replace("+", " endpointEnd=");
ctorArgument = ctorArgument.Replace(", V", " v");
ctorArgument = ctorArgument.Replace(", C", " c");
ctorArgument = ctorArgument.Replace(", P", " p");
ctorArgument = ctorArgument.Replace(",", " assembly=");
// now we can split on ' ' and '=' to get name/value pairs
string [] endpointConfig = ctorArgument.Split(' ');
// grab only the contractName, ignore the rest
#if false
foreach (string attrib in endpointConfig)
{
string [] pair = attrib.Split('=');
if (pair.Length == 2)
{
string name = pair[0];
string value = pair[1];
AddAttribute(node, name, value);
}
}
#else
string [] pair = endpointConfig[0].Split('=');
Debug.Assert(pair.Length == 2);
string name = pair[0];
Debug.Assert(name == "contractName");
string value = pair[1];
base.AddContractNameAttribute(mfb, node, data, value);
#endif
}
// Endpoints are special in a lot of ways, and require a special method
public XmlNode CreateEndpointNode(MetaDataCustomAttribute data,
EndpointDefinition rule,
int index)
{
// assume that the constructor to an endpoint always takes one argument,
// and that the argument looks like this:
// "<discard*> contractname+Exp*,AssemblyName, Version=foo,
// Culture=bar, PublicKeyToken=fbar"
// we'll parse this to get all the attributes of the top-level tag, and
// then parse field that is being decorated to get the rest of the
// information we need.
// get the type of the field that is decorated:
MetaDataObject t = (MetaDataObject)
((MetaDataField)data.Parent).Signature.FieldType.ClassObject;
// split the field to get the parts we need
string typeName = t.FullName;
typeName = typeName.Replace("<", ",");
typeName = typeName.Replace(">", "");
typeName = typeName.Replace("+", ",");
string [] nameParts = typeName.Split(',');
string contractName = nameParts[1];
string impName = contractName + ".Imp";
string expName = contractName + ".Exp";
string stateName = contractName + "." + nameParts[4];
XmlNode impNode = GetEndpointHierarchy("imp", impName);
XmlNode expNode = GetEndpointHierarchy("exp", expName);
MetaDataTypeDefinition r1 = resolver.ResolveName(impName);
MetaDataTypeDefinition r2 = resolver.ResolveName(expName);
MetaDataTypeDefinition r3 = resolver.ResolveName(stateName);
string startState = "";
for (int i = 0; i < r3.Fields.Length; i++)
{
if (r3.Fields[i].Name == "Value")
{
startState = r3.Fields[0].DefaultValue.ToString();
break;
}
}
XmlNode node = manifest.CreateNode(XmlNodeType.Element,
rule.xmlTagName, "");
node.AppendChild(impNode);
node.AppendChild(expNode);
AddAttribute(node, "id", index.ToString());
if (startState != "")
{
AddAttribute(node, "startStateId", startState);
}
// Contract name comes from either the attribute argument
// or the TRef type depending on the endpoint kind
rule.AddContractNameAttribute(this, node, data, contractName);
// add an attribute for each constructor argument if there is one
// This should only be true for input/ouput pipes
if (rule.constructorFields != null && rule.constructorFields.Length != 0)
{
if (data.FixedArgs.Length != 0)
{
for (int i = 0; i < data.FixedArgs.Length; i++)
{
if (rule.constructorFields[i] != null)
{
string name = rule.constructorFields[i];
if (data.FixedArgs[i] == null)
{
AddAttribute(node, name, "");
}
else
{
string value = data.FixedArgs[i].ToString();
AddAttribute(node, name, value);
}
}
else
{
Console.WriteLine(" fixed=({0}), no matching constructor?",
data.FixedArgs[i] == null? null : data.FixedArgs[i].ToString());
}
}
}
}
return(node);
}
