public void ParseSingleTest()
{
try
{
IndexerParser.ParseSingle("qwe");
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseSingle("");
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseSingle(null);
Assert.Fail();
}
catch { }
Assert.AreEqual(5, IndexerParser.ParseSingle("5"));
Assert.AreEqual(5, IndexerParser.ParseSingle("0x5"));
Assert.AreEqual(5, IndexerParser.ParseSingle("x5"));
Assert.AreEqual(5, IndexerParser.ParseSingle("05"));
Assert.AreEqual(10, IndexerParser.ParseSingle("10"));
Assert.AreEqual(10, IndexerParser.ParseSingle("010"));
Assert.AreEqual(10, IndexerParser.ParseSingle("0x0a"));
Assert.AreEqual(10, IndexerParser.ParseSingle("0x0A"));
Assert.AreEqual(16, IndexerParser.ParseSingle("x10"));
Assert.AreEqual(16, IndexerParser.ParseSingle("0x10"));
Assert.AreEqual(100, IndexerParser.ParseSingle("100"));
Assert.AreEqual(255, IndexerParser.ParseSingle("0xFF"));
Assert.AreEqual(255, IndexerParser.ParseSingle("xFF"));
}
public IVariable GetVariable(string argument)
{
string cmd;
var locations = IndexerParser.ParseComplexOperation(argument, out cmd);
var values = locations.Select(GetByte);
var ret = new SimpleVariable();
switch (cmd)
{
case "sum":
ulong sum = 0;
foreach (var item in values)
{
sum += item;
}
ret.Set(sum);
break;
case "avg": ret.Set(values.Average(x => x)); break;
case "min": ret.Set(values.Min()); break;
case "max": ret.Set(values.Max()); break;
case "xor":
byte xor = 0;
foreach (var item in values)
{
xor ^= item;
}
ret.Set(xor);
break;
default: break;
}
return(ret);
}
public void ParseArrayTest()
{
IEnumerable <long> ret;
try
{
IndexerParser.ParseArray("qwe");
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseArray("");
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseArray(null);
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseArray("1");
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseArray("1..");
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseArray("2..1");
Assert.Fail();
}
catch { }
ret = IndexerParser.ParseArray("1..3");
Assert.AreEqual(3, ret.Count());
Assert.AreEqual(1, ret.ElementAt(0));
Assert.AreEqual(2, ret.ElementAt(1));
Assert.AreEqual(3, ret.ElementAt(2));
ret = IndexerParser.ParseArray("0..0");
Assert.AreEqual(1, ret.Count());
Assert.AreEqual(0, ret.ElementAt(0));
ret = IndexerParser.ParseArray("-5..-5");
Assert.AreEqual(1, ret.Count());
Assert.AreEqual(-5, ret.ElementAt(0));
ret = IndexerParser.ParseArray("-5..0");
Assert.AreEqual(6, ret.Count());
Assert.AreEqual(-5, ret.ElementAt(0));
Assert.AreEqual(-4, ret.ElementAt(1));
Assert.AreEqual(-3, ret.ElementAt(2));
Assert.AreEqual(-2, ret.ElementAt(3));
Assert.AreEqual(-1, ret.ElementAt(4));
Assert.AreEqual(0, ret.ElementAt(5));
ret = IndexerParser.ParseArray("0x0f..x11");
Assert.AreEqual(3, ret.Count());
Assert.AreEqual(15, ret.ElementAt(0));
Assert.AreEqual(16, ret.ElementAt(1));
Assert.AreEqual(17, ret.ElementAt(2));
}
public void ParseComplexTest()
{
IEnumerable <long> ret;
try
{
IndexerParser.ParseComplex("qwe");
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseComplex("");
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseComplex(null);
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseComplex("1..");
Assert.Fail();
}
catch { }
try
{
IndexerParser.ParseComplex("2..1");
Assert.Fail();
}
catch { }
ret = IndexerParser.ParseComplex("5");
Assert.AreEqual(1, ret.Count());
Assert.AreEqual(5, ret.ElementAt(0));
ret = IndexerParser.ParseComplex("0x5");
Assert.AreEqual(1, ret.Count());
Assert.AreEqual(5, ret.ElementAt(0));
ret = IndexerParser.ParseComplex("0x10");
Assert.AreEqual(1, ret.Count());
Assert.AreEqual(16, ret.ElementAt(0));
ret = IndexerParser.ParseComplex("1..3");
Assert.AreEqual(3, ret.Count());
Assert.AreEqual(1, ret.ElementAt(0));
Assert.AreEqual(2, ret.ElementAt(1));
Assert.AreEqual(3, ret.ElementAt(2));
ret = IndexerParser.ParseComplex("1..3, 0, 5");
Assert.AreEqual(5, ret.Count());
Assert.AreEqual(1, ret.ElementAt(0));
Assert.AreEqual(2, ret.ElementAt(1));
Assert.AreEqual(3, ret.ElementAt(2));
Assert.AreEqual(0, ret.ElementAt(3));
Assert.AreEqual(5, ret.ElementAt(4));
}
public static void Parse(CsClass pCsClass, CodeBuilder pBuilder, FactoryExpressionCreator pCreator)
{
ExtensionName = null;
StringBuilder sb = new StringBuilder();
CodeBuilder privateClasses = new CodeBuilder();
TheClass myClass = TheClassFactory.Get(pCsClass, pCreator);
IsMainClass = Helpers.HasAttribute(pCsClass.attributes, "JsMainClassAttribute");
bool isResource = Helpers.HasAttribute(pCsClass.attributes, "JsEmbedAttribute");
IsExtension = Helpers.HasAttribute(pCsClass.attributes, "JsExtensionAttribute");
if (IsMainClass)
{
JsNamespaceParser.MainClassName = myClass.FullName;
AttributeItem vals = Helpers.GetAttributeValue(pCsClass.attributes, "JsMainClassAttribute", pCreator)[0];
sb.AppendFormat(@"[SWF(width=""{0}"", height=""{1}"", frameRate=""{2}"", backgroundColor=""{3}"")]",
vals.Parameters[0],
vals.Parameters[1],
vals.Parameters[2],
vals.Parameters[3]
);
sb.AppendLine();
sb.Append("\t");
}
if (isResource)
{
AttributeItem vals = Helpers.GetAttributeValue(pCsClass.attributes, "JsEmbedAttribute", pCreator)[0];
string path = vals.Parameters[0] as String;
if (!string.IsNullOrEmpty(path))
{
path = Path.Combine(Project.Root, path);
string ex = Path.GetExtension(path).Substring(1);
string mimeType;
if (vals.NamedArguments.ContainsKey("mimeType"))
{
mimeType = vals.NamedArguments["mimeType"].Value;
}
else
{
switch (ex)
{
case @"gif":
case @"png":
case @"jpg":
case @"jpeg":
case @"svg":
mimeType = "image/" + ex;
break;
case @"mp3":
mimeType = @"audio/mpeg";
break;
case @"swf":
mimeType = @"application/x-shockwave-flash";
break;
case @"ttf":
case @"otf":
mimeType = @"application/x-font";
break;
default:
mimeType = @"application/octet-stream";
break;
}
}
StringBuilder addParams = new StringBuilder();
foreach (var item in vals.NamedArguments.Where(pItem => !pItem.Key.Equals("mimeType")))
{
addParams.AppendFormat(@", {0}=""{1}""", item.Key, item.Value.Value);
}
sb.AppendFormat(@"[Embed(source=""{0}"", mimeType=""{1}""{2})]",
path.Replace("\\", "\\\\"),
mimeType,
addParams
);
sb.AppendLine();
sb.Append("\t");
}
}
if (!IsExtension)
{
sb.AppendFormat("{1}class {0}",
myClass.Name,
JsHelpers.ConvertModifiers(myClass.Modifiers, _notValidClassMod));
if (myClass.Extends.Count != 0)
{
sb.AppendFormat(" extends {0}", JsHelpers.Convert(myClass.Extends[0]));
}
if (myClass.Implements.Count != 0)
{
sb.Append(" implements ");
foreach (string s in myClass.Implements)
{
sb.Append(JsHelpers.Convert(s));
sb.Append(", ");
}
sb.Remove(sb.Length - 2, 2);
}
sb.Append(" {");
sb.AppendLine();
pBuilder.Append(sb.ToString());
pBuilder.AppendLineAndIndent();
}
if (IsMainClass)
{
ImportStatementList.List.Add("flash.events.Event");
pBuilder.AppendFormat(
@"public function {0}() {{
if (stage) $ctor();
else addEventListener(Event.ADDED_TO_STAGE, __loaded);
}}
private function __loaded(e:Event = null):void {{
removeEventListener(Event.ADDED_TO_STAGE, __loaded);
$ctor();
}}
",
myClass.Name);
pBuilder.AppendLine();
}
if (pCsClass.member_declarations != null)
{
if (!myClass.IsPrivate)
{
ImportStatementList.List.Add(myClass.NameSpace + ".*");
}
foreach (CsNode memberDeclaration in pCsClass.member_declarations)
{
if (memberDeclaration is CsConstructor)
{
MethodParser.Parse(myClass.GetConstructor((CsConstructor)memberDeclaration), pBuilder, pCreator);
}
else if (memberDeclaration is CsMethod)
{
MethodParser.Parse(myClass.GetMethod((CsMethod)memberDeclaration), pBuilder, pCreator);
if (IsExtension && string.IsNullOrEmpty(ExtensionName))
{
ExtensionName = ((CsMethod)memberDeclaration).identifier.identifier;
}
}
else if (memberDeclaration is CsIndexer)
{
IndexerParser.Parse(myClass.GetIndexer((CsIndexer)memberDeclaration), pBuilder, pCreator);
}
else if (memberDeclaration is CsVariableDeclaration)
{
VariableParser.Parse(myClass.GetVariable((CsVariableDeclaration)memberDeclaration), pBuilder);
}
else if (memberDeclaration is CsConstantDeclaration)
{
ConstantParser.Parse(myClass.GetConstant((CsConstantDeclaration)memberDeclaration), pBuilder);
}
else if (memberDeclaration is CsDelegate)
{
DelegateParser.Parse(myClass.GetDelegate((CsDelegate)memberDeclaration), pBuilder);
}
else if (memberDeclaration is CsEvent)
{
EventParser.Parse(myClass.GetEvent(((CsEvent)memberDeclaration).declarators.First.Value.identifier.identifier), pBuilder);
}
else if (memberDeclaration is CsProperty)
{
PropertyParser.Parse(myClass.GetProperty((CsProperty)memberDeclaration), pBuilder, pCreator);
}
else if (memberDeclaration is CsClass)
{
Parse((CsClass)memberDeclaration, privateClasses, pCreator);
}
else
{
throw new NotSupportedException();
}
}
}
string imports = getImports();
pBuilder.Replace(IMPORT_MARKER, imports);
pBuilder.AppendLineAndUnindent("}");
if (IsExtension)
{
return;
}
if (!myClass.IsPrivate)
{
pBuilder.AppendLineAndUnindent("}");
}
if (privateClasses.Length == 0)
{
return;
}
pBuilder.AppendLine();
pBuilder.Append(JsNamespaceParser.Using);
pBuilder.AppendLine(imports);
pBuilder.Append(privateClasses);
}
