public static string GetValueInitializer(ParameterDesc parameter)
{
string result;
if (parameter.Value == null || parameter.Value.ToString() == "0")
{
result = "null";
}
else
{
result = parameter.Value.ToString();
}
if (result == "null")
{
if (((parameter.Type.Kind == TypeKind.Interface) && (parameter.IndirectionLevel == 1)) || (parameter.IndirectionLevel == 0))
{
result = "default(" + parameter.TypeDeclaration + ")";
}
}
else
{
result = "(" + parameter.TypeDeclaration + ")" + result;
}
return(result);
}
private void ParseAntennaReplyParam(XmlTextReader replyReader, ref CommandReply result)
{
// do until end XML tag </returnValue> is found
while (replyReader.Read() &&
!(replyReader.Name == "returnValue" && replyReader.NodeType == XmlNodeType.EndElement))
{
// start XML tag <antenna>: we get an paramblock for antennas
if (replyReader.Name == "antenna" && replyReader.NodeType == XmlNodeType.Element)
{
ParameterDesc container = new ParameterDesc("antenna", true, true);
result.Parameters.Add(container);
// do until end XML tag </antenna> is found
while (replyReader.Read() &&
!(replyReader.Name == "antenna" && replyReader.NodeType == XmlNodeType.EndElement))
{
if (replyReader.NodeType == XmlNodeType.Element)
{
string paramName = replyReader.Name;
if (replyReader.Read() && (XmlNodeType.Text == replyReader.NodeType))
{
ParameterDesc param = new ParameterDesc(paramName, replyReader.Value);
result.Parameters.Add(param);
}
}
}
}
}
}
public FieldDeclaration(ParameterDesc parameter, BaseTypeDeclaration container, AccessModifierType accessModifier)
: base(container, 0)
{
if (parameter.Hidden)
{
accessModifier = AccessModifierType.Private;
}
string fieldType;
if (parameter.ArraySizes.Any())
{
fieldType = new ArrayWrapperDeclararation(parameter, container, accessModifier).TypeName;
}
else
{
fieldType = parameter.TypeDeclaration;
}
WriteLine(() => accessModifier + " " + fieldType + " " + parameter.Name + ";");
}
private void ParseReplyParam(XmlTextReader replyReader, ref CommandReply result, Collection <string> Name)
{
while (replyReader.Read() &&
!(replyReader.Name == "returnValue" && replyReader.NodeType == XmlNodeType.EndElement))
{
if (replyReader.NodeType == XmlNodeType.Element)
{
foreach (string paramName in Name)
{
if (replyReader.Name == paramName)
{
if (replyReader.Read() &&
(XmlNodeType.Text == replyReader.NodeType || XmlNodeType.CDATA == replyReader.NodeType))
{
ParameterDesc param = new ParameterDesc(paramName, replyReader.Value);
result.Parameters.Add(param);
}
}
}
}
}
}
internal CommandReply ParseReply(string replyMsg)
{
Collection <string> paramName = new Collection <string>();
CommandReply result = new CommandReply();
StringReader strReader = new StringReader(replyMsg);
XmlTextReader replyReader = new XmlTextReader(strReader);
while ("" != replyMsg && replyReader.Read())
{
switch (replyReader.NodeType)
{
case XmlNodeType.Element:
if (replyReader.Name == "returnValue")
{
switch (result.CommandName)
{
case "readTagIDs":
case "readTagMemory":
case "writeTagMemory":
case "readTagField":
case "writeTagField":
case "killTag":
case "lockTagBank":
case "nXP_SetReadProtect":
case "nXP_ResetReadProtect":
case "nXP_Calibrate":
ParseForTagData(replyReader, ref result);
break;
case "hostGreetings":
paramName.Add("version");
paramName.Add("configType");
paramName.Add("configID");
ParseReplyParam(replyReader, ref result, paramName);
break;
case "setConfiguration":
paramName.Add("configID");
ParseReplyParam(replyReader, ref result, paramName);
break;
case "getConfigVersion":
paramName.Add("configID");
paramName.Add("configType");
ParseReplyParam(replyReader, ref result, paramName);
break;
case "getConfiguration":
paramName.Add("configID");
paramName.Add("configData");
ParseReplyParam(replyReader, ref result, paramName);
break;
case "getAllSources":
paramName.Add("sourceName");
ParseReplyParam(replyReader, ref result, paramName);
break;
case "getTime":
paramName.Add("utcTime");
ParseReplyParam(replyReader, ref result, paramName);
break;
case "getIO":
paramName.Add("inValue");
paramName.Add("outValue");
ParseReplyParam(replyReader, ref result, paramName);
break;
case "getReaderStatus":
paramName.Add("readerType");
paramName.Add("mLFB");
paramName.Add("hWVersion");
paramName.Add("fWVersion");
paramName.Add("readerMode");
paramName.Add("version");
ParseReplyParam(replyReader, ref result, paramName);
break;
case "getProtocolConfig":
paramName.Add("initialQ");
paramName.Add("profile");
paramName.Add("channels");
paramName.Add("session");
paramName.Add("rSSIThreshold");
paramName.Add("retry");
paramName.Add("idLength");
paramName.Add("writeMode");
paramName.Add("writeBoost");
ParseReplyParam(replyReader, ref result, paramName);
break;
case "getAntennaConfig":
ParseAntennaReplyParam(replyReader, ref result);
break;
case "sendCommand":
paramName.Add("byteReply");
ParseReplyParam(replyReader, ref result, paramName);
break;
// This is an unknown result so we just ignore it
default:
break;
}
// Here we are: Now the interesting part begins which is the real
// return value.
while (replyReader.Read() &&
!(replyReader.Name == "returnValue" && replyReader.NodeType == XmlNodeType.EndElement))
{
if (replyReader.Name == "value")
{
if (replyReader.Read())
{
if (XmlNodeType.Text == replyReader.NodeType)
{
ParameterDesc param = new ParameterDesc("value", replyReader.Value);
result.Parameters.Add(param);
}
}
}
}
}
else if (replyReader.Name == "error")
{
// Read in extended error information
while (replyReader.Read() &&
!(replyReader.Name == "error" && replyReader.NodeType == XmlNodeType.EndElement))
{
if (replyReader.Name == "name" && replyReader.NodeType == XmlNodeType.Element)
{
if (replyReader.Read() && XmlNodeType.Text == replyReader.NodeType)
{
result.Error = replyReader.Value.ToString();
}
}
else if (replyReader.Name == "cause" && replyReader.NodeType == XmlNodeType.Element)
{
if (replyReader.Read() && XmlNodeType.Text == replyReader.NodeType)
{
result.Cause = replyReader.Value.ToString();
}
}
}
}
else if (this.m_IsHeaderRead)
{
result.CommandName = replyReader.Name;
}
else if (this.m_IsValidReply)
{
switch (replyReader.Name)
{
case "id":
if (replyReader.Read())
{
if (XmlNodeType.Text == replyReader.NodeType)
{
result.CommandID = replyReader.Value.ToString();
}
}
break;
case "resultCode":
if (replyReader.Read())
{
if (XmlNodeType.Text == replyReader.NodeType)
{
result.ResultCode = Int32.Parse(replyReader.Value);
}
}
break;
default:
break;
}
}
else if (replyReader.Name == "reply")
{
this.m_IsValidReply = true;
}
break;
case XmlNodeType.EndElement:
switch (replyReader.Name)
{
case "resultCode":
this.m_IsHeaderRead = true;
break;
default:
break;
}
break;
default:
break;
}
}
return(result);
}
private static string GetParameterTypeDeclaration(ParameterDesc parameter)
{
return(parameter.TypeDeclaration + (parameter.ArraySizes.Any() ? "*" : ""));
}
public ConstDeclaration(ParameterDesc parameter, BaseTypeDeclaration container, AccessModifierType accessModifier)
: base(container, 0)
{
WriteLine(() => accessModifier + " const " + ((parameter.Value is string) ? "string" : parameter.TypeDeclaration) + " " + parameter.Name + " = " + GetValueInitializer(parameter.Value) + ";");
}
private StructDeclaration(TypeDesc type, TextBlock container, AccessModifierType accessModifier, bool root)
: base(type, container, accessModifier)
{
if (type.BaseTypes.Any())
{
throw new Exception("Base types are not expected for struct");
}
if (type.Methods.Any())
{
throw new Exception("Methods are not expected for struct");
}
TypeDesc bitField = CheckBitField(Type);
var fields = type.Fields.ToArray();
WriteBaseLine(() => "{");
if (bitField == null)
{
if (root)
{
Action <TypeDesc, List <TypeDesc>, List <ParameterDesc> > getNestedTypes = null;
getNestedTypes = (currentType, types, parameters) =>
{
if (!types.Any(x => x.Name == currentType.Name))
{
types.Add(currentType);
parameters.AddRange(currentType.Fields);
if (CheckBitField(currentType) == null)
{
currentType.Fields.ToList().ForEach(x => getNestedTypes(x.Type, types, parameters));
}
}
};
List <TypeDesc> nestedTypeDescList = new List <TypeDesc>();
List <ParameterDesc> parameterDescList = new List <ParameterDesc>();
getNestedTypes(type, nestedTypeDescList, parameterDescList);
List <BaseTypeDeclaration> nestedTypes = new List <BaseTypeDeclaration>();
nestedTypes.AddRange(nestedTypeDescList.Where(x => x.AutoGeneratedName).Select(x => (BaseTypeDeclaration) new StructDeclaration(x, this, accessModifier, false)));
nestedTypes.AddRange(parameterDescList.Where(x => x.ArraySizes.Any()).Select(x => (BaseTypeDeclaration) new ArrayWrapperDeclararation(x, this, accessModifier)).Where(x => !nestedTypes.Any(y => y.TypeName == x.TypeName)));
nestedTypes.ForEach(x =>
{
AddTextBlock(x);
WriteLine();
});
}
Action <List <ParameterDesc> > processNamelessField = null;
processNamelessField = list =>
{
ParameterDesc currentParameter = list[list.Count - 1];
if (currentParameter.AutoGeneratedName)
{
foreach (var item in currentParameter.Type.Fields.ToArray())
{
processNamelessField(list.Union(new ParameterDesc[] { item }).ToList());
}
}
else
{
if (!currentParameter.Hidden)
{
string propertyType = currentParameter.TypeDeclaration;
if (currentParameter.ArraySizes.Any() && !currentParameter.SpecialFlag)
{
propertyType = new ArrayWrapperDeclararation(currentParameter, this, accessModifier).TypeName;
}
WriteLine();
WriteLine(() => AccessModifier + " " + propertyType + " " + currentParameter.Name);
WriteLine(() => "{");
WriteLine(() => " get");
WriteLine(() => " {");
WriteLine(() => " return " + string.Join(".", list.Select(x => x.Name)) + ";");
WriteLine(() => " }");
WriteLine(() => " set");
WriteLine(() => " {");
WriteLine(() => " " + string.Join(".", list.Select(x => x.Name)) + " = value;");
WriteLine(() => " }");
WriteLine(() => "}");
}
}
};
for (int i = 0; i < fields.Length; i++)
{
ParameterDesc field = fields[i];
if (type.Kind == TypeKind.Union)
{
WriteLine(() => "[FieldOffset(0)]");
}
AddTextBlock(new FieldDeclaration(field, this, AccessModifier));
}
foreach (var field in type.Fields.Where(x => x.AutoGeneratedName))
{
processNamelessField(new ParameterDesc[] { field }.ToList());
}
}
else
{
AddTextBlock(new FieldDeclaration(bitField, "__bit_field_value", this, AccessModifierType.Private));
int bitFieldOffset = 0;
for (int i = 0; i < fields.Length; i++)
{
ParameterDesc field = fields[i];
int bitFieldSize = field.ArraySizes.Single();
int bitFieldMask = 0;
for (int j = 0; j < bitFieldSize; j++)
{
bitFieldMask |= (1 << j);
}
WriteLine();
WriteLine(() => AccessModifier + " " + bitField.Name + " " + field.Name);
WriteLine(() => "{");
WriteLine(() => " get");
WriteLine(() => " {");
WriteLine(() => " return (" + bitField.Name + ")((__bit_field_value >> " + bitFieldOffset.ToString() + ") & " + bitFieldMask.ToString() + ");");
WriteLine(() => " }");
WriteLine(() => " set");
WriteLine(() => " {");
WriteLine(() => " __bit_field_value = (" + bitField.Name + ")((value & " + bitFieldMask.ToString() + ") << " + bitFieldOffset.ToString() + ");");
WriteLine(() => " }");
WriteLine(() => "}");
bitFieldOffset += bitFieldSize;
}
}
WriteLine();
WriteLine(() => AccessModifier + " unsafe static int GetSize()");
WriteLine(() => "{");
WriteLine(() => " return Marshal.SizeOf(typeof(" + TypeName + "));");
WriteLine(() => "}");
if ((TypeName == "BOOL") || (TypeName == "BOOLEAN"))
{
WriteLine();
WriteLine(() => "public static unsafe implicit operator bool(" + TypeName + " value)");
WriteLine(() => "{");
WriteLine(() => " return (value.Value != 0);");
WriteLine(() => "}");
WriteLine();
WriteLine(() => "public static unsafe implicit operator " + TypeName + "(bool value)");
WriteLine(() => "{");
WriteLine(() => " return new " + TypeName + " { Value = (byte)(value ? 1 : 0) };");
WriteLine(() => "}");
}
WriteLine();
WriteLine(() => "public unsafe override bool Equals(object obj)");
WriteLine(() => "{");
WriteLine(() => " if (!(obj is " + TypeName + "))");
WriteLine(() => " return false;");
WriteLine(() => " fixed (" + TypeName + "* address = &this)");
WriteLine(() => " {");
WriteLine(() => " " + TypeName + " other = (" + TypeName + ")obj;");
WriteLine(() => " IntPtr size = new IntPtr(GetSize());");
WriteLine(() => " IntPtr equalBytes = NativeMethods.RtlCompareMemory(address, &other, size);");
WriteLine(() => " return size == equalBytes;");
WriteLine(() => " }");
WriteLine(() => "}");
WriteLine();
WriteLine(() => "public unsafe override int GetHashCode()");
WriteLine(() => "{");
WriteLine(() => " int result = 0;");
WriteLine(() => " int size = GetSize();");
WriteLine(() => " fixed (" + TypeName + "* address = &this)");
WriteLine(() => " {");
WriteLine(() => " byte* byteAddress = (byte*)address;");
WriteLine(() => " for (int i = 0; i < size; i++)");
WriteLine(() => " result ^= byteAddress[i] << i;");
WriteLine(() => " }");
WriteLine(() => " return result;");
WriteLine(() => "}");
WriteLine();
WriteLine(() => "public unsafe static bool operator ==(" + TypeName + " left, " + TypeName + " right)");
WriteLine(() => "{");
WriteLine(() => " IntPtr size = new IntPtr(GetSize());");
WriteLine(() => " IntPtr equalBytes = NativeMethods.RtlCompareMemory(&left, &right, size);");
WriteLine(() => " return size == equalBytes;");
WriteLine(() => "}");
WriteLine();
WriteLine(() => "public unsafe static bool operator !=(" + TypeName + " left, " + TypeName + " right)");
WriteLine(() => "{");
WriteLine(() => " IntPtr size = new IntPtr(GetSize());");
WriteLine(() => " IntPtr equalBytes = NativeMethods.RtlCompareMemory(&left, &right, size);");
WriteLine(() => " return size != equalBytes;");
WriteLine(() => "}");
WriteBaseLine(() => "}");
}
public ArrayWrapperDeclararation(ParameterDesc parameter, BaseTypeDeclaration container, AccessModifierType accessModifier)
: base(parameter.Type, container, accessModifier)
{
this.arraySizes = parameter.ArraySizes;
int totalLength = 1;
int[] sizes = arraySizes.ToArray();
List <string> lengthConstants = new List <string>();
List <string> indexerParameters = new List <string>();
for (int i = 0; i < sizes.Length; i++)
{
totalLength *= sizes[i];
lengthConstants.Add("length" + i.ToString());
indexerParameters.Add("index" + i.ToString());
}
List <string> parts = new List <string>();
for (int i = 0; i < sizes.Length; i++)
{
List <string> multipliers = new List <string>();
multipliers.Add(indexerParameters[i]);
for (int j = i; j < (sizes.Length - 1); j++)
{
multipliers.Add(lengthConstants[j]);
}
parts.Add(string.Join(" * ", multipliers));
}
string index = string.Join(" + ", parts);
bool canBeFixedArray = IsPrimitiveType(parameter.Type.Name) && (parameter.IndirectionLevel == 0);
WriteBaseLine(() => "{");
for (int i = 0; i < sizes.Length; i++)
{
AddTextBlock(new ConstDeclaration(new TypeDesc("int"), lengthConstants[i], this, AccessModifierType.Private, sizes[i]));
}
WriteLine();
if (!canBeFixedArray)
{
for (int i = 0; i < totalLength; i++)
{
AddTextBlock(new FieldDeclaration(parameter.Type, "data" + i.ToString(), this, AccessModifierType.Private));
}
}
else
{
AddTextBlock(new FieldDeclaration(parameter.Type, "data", this, AccessModifierType.Private, totalLength));
}
WriteLine();
WriteLine(() => AccessModifier + " unsafe " + parameter.Type.Name + " this[" + string.Join(", ", indexerParameters.Select(x => "int " + x)) + "]");
WriteLine(() => "{");
WriteLine(() => " get");
WriteLine(() => " {");
WriteLine(() => " fixed (" + parameter.Type.Name + "* pointer = " + (canBeFixedArray ? "data" : "&data0") + ")");
WriteLine(() => " {");
WriteLine(() => " return pointer[" + index + "];");
WriteLine(() => " }");
WriteLine(() => " }");
WriteLine(() => " set");
WriteLine(() => " {");
WriteLine(() => " fixed (" + parameter.Type.Name + "* pointer = " + (canBeFixedArray ? "data" : "&data0") + ")");
WriteLine(() => " {");
WriteLine(() => " pointer[" + index + "] = value;");
WriteLine(() => " }");
WriteLine(() => " }");
WriteLine(() => "}");
WriteLine();
WriteLine(() => "public static unsafe implicit operator " + parameter.Type.Name + "[](" + TypeName + " value)");
WriteLine(() => "{");
WriteLine(() => " " + parameter.Type.Name + "[] result = new " + parameter.Type.Name + "[" + totalLength + "];");
WriteLine(() => " " + parameter.Type.Name + "* pointer = " + (canBeFixedArray ? "value.data" : "&value.data0") + ";");
WriteLine(() => " {");
WriteLine(() => " for (int i = 0; i < " + totalLength + "; i++)");
WriteLine(() => " result[i] = pointer[i];");
WriteLine(() => " }");
WriteLine(() => " return result;");
WriteLine(() => "}");
WriteLine();
WriteLine(() => "public static unsafe implicit operator " + TypeName + "(" + parameter.Type.Name + "[] value)");
WriteLine(() => "{");
WriteLine(() => " if (value == null)");
WriteLine(() => " throw new ArgumentNullException(\"value\");");
WriteLine(() => " " + TypeName + " result = new " + TypeName + "();");
WriteLine(() => " " + parameter.Type.Name + "* pointer = " + (canBeFixedArray ? "result.data" : "&result.data0") + ";");
WriteLine(() => " for (int i = 0; i < ((value.Length < " + totalLength + ") ? value.Length : " + totalLength + "); i++)");
WriteLine(() => " pointer[i] = value[i];");
WriteLine(() => " return result;");
WriteLine(() => "}");
WriteBaseLine(() => "}");
}
