public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
// "base" "[" expression-list "]"
CsBaseIndexerAccess indexerAccess = (CsBaseIndexerAccess)pStatement;
return(ElementAccessHelper.getIndexerExpression(indexerAccess, indexerAccess.expression_list.list, null, false, false, pCreator));
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsPostIncrementDecrementExpression ex = (CsPostIncrementDecrementExpression)pStatement;
Expression exp = pCreator.Parse(ex.expression);
if (exp.InternalType) {
if (ex.expression is CsElementAccess) {
string setter = ElementAccessHelper.parseElementAccess(ex.expression, true, true, pCreator).Value;
switch (ex.oper) {
case CsTokenType.tkINC:
return new Expression(string.Format(setter, exp.Value + "++"), exp.Type);
case CsTokenType.tkDEC:
return new Expression(string.Format(setter, exp.Value + "--"), exp.Type);
default:
throw new Exception();
}
}
}
switch (ex.oper) {
case CsTokenType.tkINC:
return new Expression(exp.Value + "++", exp.Type);
case CsTokenType.tkDEC:
return new Expression(exp.Value + "--", exp.Type);
default:
throw new NotImplementedException();
}
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
//embedded-type "." identifier
CsPredefinedTypeMemberAccess ex = pStatement as CsPredefinedTypeMemberAccess;
string name;
bool renamed = Helpers.GetRealName(ex, ex.identifier.identifier, out name);
if (renamed)
{
return(new Expression(name, pStatement.entity_typeref));
}
CsEntityProperty p = ex.entity as CsEntityProperty;
if (p != null)
{
//getter, rename
name = "get_" + name + "()";
}
else if (ex.ec == expression_classification.ec_event_access) //remove eventhandler name
{
name = string.Empty;
}
//FactoryExpressionCreator.Parse(ex.expression).Value
return(new Expression(
"nose" + "." + name,
pStatement.entity_typeref
));
}
public static void Parse(TheConstructor pConstructor, CodeBuilder pBuilder, FactoryExpressionCreator pCreator)
{
if (pConstructor.IsStaticConstructor)
{
pBuilder.Append("{");
}
else
{
pBuilder.AppendFormat("{4}{0}function {1}({2}){3} {{",
ClassParser.IsMainClass ? "private " : As3Helpers.ConvertModifiers(pConstructor.Modifiers, _notValidConstructorMod),
ClassParser.IsMainClass ? @"$ctor" : pConstructor.Name,
As3Helpers.GetParameters(pConstructor.Arguments),
ClassParser.IsMainClass ? ":void" : string.Empty, // pConstructor.MyClass.Name,
pConstructor.OverridesBaseConstructor ? "override " : string.Empty
);
}
pBuilder.AppendLine();
if (pConstructor.HasBaseCall)
{
pBuilder.AppendFormat("\tsuper({0});", As3Helpers.GetCallingArguments(pConstructor.BaseArguments));
pBuilder.AppendLine();
}
BlockParser.Parse(pConstructor.CodeBlock, pBuilder, pCreator);
pBuilder.AppendLine("}");
pBuilder.AppendLine();
}
public LambdaMethodExpression(CsLambdaExpression pStatement, FactoryExpressionCreator pCreator)
{
Arguments = BaseMethod.getArguments(pStatement.signature.parameters, pCreator);
ReturnType = Helpers.GetType(pStatement.best_common_type);
//ReturnType = Helpers.GetType(((CsEntityMethod)((CsEntityAnonymousMethod)pStatement.entity).parent.parent).specifier.return_type);
CodeBlock = pStatement.body;
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
// "default" ( type )
return new Expression(
null,
pStatement.entity_typeref
);
}
public static void Parse(TheConstructor pConstructor, CodeBuilder pBuilder, FactoryExpressionCreator pCreator) {
if (pConstructor.IsStaticConstructor) {
pBuilder.Append("{");
} else {
pBuilder.AppendFormat("{4}{0}function {1}({2}){3} {{",
ClassParser.IsMainClass ? "private " : As3Helpers.ConvertModifiers(pConstructor.Modifiers, _notValidConstructorMod),
ClassParser.IsMainClass ? @"$ctor" : pConstructor.Name,
As3Helpers.GetParameters(pConstructor.Arguments),
ClassParser.IsMainClass ? ":void" : string.Empty,// pConstructor.MyClass.Name,
pConstructor.OverridesBaseConstructor ? "override " : string.Empty
);
}
pBuilder.AppendLine();
if (pConstructor.HasBaseCall) {
pBuilder.AppendFormat("\tsuper({0});", As3Helpers.GetCallingArguments(pConstructor.BaseArguments));
pBuilder.AppendLine();
}
BlockParser.Parse(pConstructor.CodeBlock, pBuilder, pCreator);
pBuilder.AppendLine("}");
pBuilder.AppendLine();
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
//"(" expression ")"
CsParenthesizedExpression ex = (CsParenthesizedExpression)pStatement;
return(new Expression("(" + pCreator.Parse(ex.expression).Value + ")", pStatement.entity_typeref));
}
internal TheConstructor(CsConstructor pConstructor, TheClass pMyClass, FactoryExpressionCreator pCreator)
{
_constructor = pConstructor;
_creator = pCreator;
MyClass = pMyClass;
Modifiers.AddRange(Helpers.GetModifiers(pConstructor.modifiers));
Arguments = getArguments(pConstructor.parameters.parameters, pCreator);
BaseArguments = Helpers.GetCallingArguments(pConstructor.argument_list, pCreator);
Signature = getSignature(Arguments);
CodeBlock = pConstructor.definition;
HasBaseCall = pConstructor.basethis == CsTokenType.tkBASE;
LinkedList <CsFormalParameter> csFormalParameters = pConstructor.parameters.parameters;
_noFormalParams = csFormalParameters == null;
_name = pConstructor.identifier.identifier;
IsStaticConstructor = (pConstructor.modifiers.flags & (uint)CsModifierEnum.mSTATIC) != 0;
if (pConstructor.basethis == CsTokenType.tkBASE || pConstructor.basethis == CsTokenType.tkTHIS)
{
_baseConstructor = pConstructor.basethis == CsTokenType.tkBASE
? (CsEntityClass)((CsEntityClass)pConstructor.entity.parent).base_type.u
: ((CsEntityClass)pConstructor.entity.parent);
}
}
public TheMethod GetMethod(CsEntityMethod pMethod, FactoryExpressionCreator pCreator)
{
if (pMethod.decl != null)
{
return(GetMethod((CsMethod)pMethod.decl));
}
TheMethod c;
if (_entityMethods.TryGetValue(pMethod, out c))
{
return(c);
}
c = new TheMethod(pMethod, this, pCreator);
Dictionary <string, bool> methodNames = new Dictionary <string, bool>();
foreach (KeyValuePair <CsEntityMethod, TheMethod> entityMethod in
_entityMethods.Where(pEntityMethod => methodNames.ContainsKey(pEntityMethod.Value.Name)))
{
entityMethod.Value._isUnique = false;
c._isUnique = false;
}
_entityMethods.Add(pMethod, c);
return(c);
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
CsLambdaExpression ex = (CsLambdaExpression)pStatement;
LambdaMethodExpression lambda = new LambdaMethodExpression((CsLambdaExpression)pStatement, pCreator);
CodeBuilder b = new CodeBuilder();
b.AppendFormat("function ({0}):{1} {{",
As3Helpers.GetParameters(lambda.Arguments),
(lambda.ReturnType == null) ? "void" : As3Helpers.Convert(lambda.ReturnType)
);
b.Indent();
b.Indent();
b.Indent();
b.AppendLine();
if (!(lambda.CodeBlock is CsBlock))
{
b.Append("return ");
}
BlockParser.ParseNode(lambda.CodeBlock, b, pCreator);
b.AppendLine("}");
b.AppendLine();
b.Unindent();
b.Unindent();
b.Unindent();
return(new Expression(b.ToString(), ex.entity_typeref));
}
public static void ParseNode(CsNode pNode, CodeBuilder pSb, FactoryExpressionCreator pCreator)
{
CsBlock block = pNode as CsBlock;
if (block != null)
{
Parse(block, pSb, pCreator);
return;
}
CsStatement statement = pNode as CsStatement;
if (statement != null)
{
pSb.Indent();
parseStatement(statement, pSb, pCreator);
pSb.Unindent();
return;
}
CsExpression expression = pNode as CsExpression;
if (expression != null)
{
Expression ex = pCreator.Parse(pNode as CsExpression);
pSb.Append(ex.Value + ";");
pSb.AppendLine();
return;
}
throw new Exception();
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
CsBaseMemberAccess baseMemberAccess = (CsBaseMemberAccess)pStatement;
// "base" "." identifier (type-argument-list)?
return(new Expression("super." + baseMemberAccess.identifier.identifier, pStatement.entity_typeref));
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsLambdaExpression ex = (CsLambdaExpression)pStatement;
LambdaMethodExpression lambda = new LambdaMethodExpression((CsLambdaExpression)pStatement, pCreator);
CodeBuilder b = new CodeBuilder();
b.AppendFormat("function ({0}):{1} {{",
As3Helpers.GetParameters(lambda.Arguments),
(lambda.ReturnType == null) ? "void" : As3Helpers.Convert(lambda.ReturnType)
);
b.Indent();
b.Indent();
b.Indent();
b.AppendLine();
if (!(lambda.CodeBlock is CsBlock)) {
b.Append("return ");
}
BlockParser.ParseNode(lambda.CodeBlock, b, pCreator);
b.AppendLine("}");
b.AppendLine();
b.Unindent();
b.Unindent();
b.Unindent();
return new Expression(b.ToString(), ex.entity_typeref);
}
public static void Parse(TheMethod pMethod, CodeBuilder pBuilder, FactoryExpressionCreator pCreator) {
if (pMethod == null) return;
bool isInterface = pMethod.MyClass.IsInterface;
Dictionary<string,string> nonValidMethod = new Dictionary<string, string>(_notValidMethodMod);
if (ClassParser.IsExtension) {
nonValidMethod.Add("static",string.Empty);
}
pBuilder.AppendFormat("{0}function {1}({2}):{3}{4}",
As3Helpers.ConvertModifiers(pMethod.Modifiers, nonValidMethod),
pMethod.Name,
As3Helpers.GetParameters(pMethod.Arguments),
As3Helpers.Convert(pMethod.ReturnType),
isInterface ? ";":" {"
);
pBuilder.AppendLine();
if (isInterface)
return;
pBuilder.AppendLine();
BlockParser.Parse(pMethod.CodeBlock, pBuilder, pCreator);
pBuilder.AppendLine();
pBuilder.AppendLine("}");
pBuilder.AppendLine();
}
internal TheIndexer(CsIndexer pIndexer, TheClass pMyClass, FactoryExpressionCreator pCreator)
{
MyClass = pMyClass;
_creator = pCreator;
Arguments = getArguments(pIndexer.parameters.parameters, pCreator);
Signature = getSignature(Arguments);
ReturnType = Helpers.GetType(pIndexer.entity.specifier.return_type);
Modifiers.AddRange(Helpers.GetModifiers(pIndexer.modifiers));
//Name = Helpers.GetRealName(pIndexer, pIndexer.entity.name);
Name = pIndexer.entity.name;
FullName = MyClass.FullName + "." + Name;
//FullRealName = MyClass.FullRealName + "." + RealName;
string sig = Signature.Replace(',', '_').Replace("<", "").Replace(">", "");
if (pIndexer.getter != null)
{
Getter = processIndexer(pIndexer.getter, false, sig);
}
if (pIndexer.setter != null)
{
Setter = processIndexer(pIndexer.setter, true, sig);
}
}
private static void parseUsingStatement(CsStatement pArg1, CodeBuilder pSb, FactoryExpressionCreator pCreator)
{
CsUsingStatement statement = (CsUsingStatement)pArg1;
CsLocalVariableDeclaration declaration = statement.resource as CsLocalVariableDeclaration;
string varname;
if (declaration == null)
{
varname = "$$using$$";
Expression e = pCreator.Parse(statement.resource);
pSb.AppendFormat("var {0}:{1} = {2};",
varname,
As3Helpers.Convert(Helpers.GetType(e.Type)),
e.Value
);
pSb.AppendLine();
}
else
{
CsLocalVariableDeclarator declarator = declaration.declarators.First.Value;
StringBuilder sb = new StringBuilder();
sb.AppendFormat("var {0}:{1}",
declarator.identifier.identifier,
As3Helpers.Convert(Helpers.GetType(declaration.type))
);
varname = declarator.identifier.identifier;
if (declarator.initializer == null)
{
sb.Append(";");
}
else
{
sb.AppendFormat(" = {0};", parseNode(declarator.initializer, pCreator));
}
pSb.Append(sb.ToString());
pSb.AppendLine();
}
pSb.Append("try {");
pSb.AppendLine();
ParseNode(statement.statement, pSb, pCreator);
pSb.Append("} finally {");
pSb.AppendLine();
pSb.AppendFormat(" if ({0} != null) {0}.Dispose();", varname);
pSb.AppendLine();
pSb.Append("}");
pSb.AppendLine();
pSb.AppendLine();
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsBinaryExpression li = (CsBinaryExpression)pStatement;
Expression left = pCreator.Parse(li.lhs);
Expression right = pCreator.Parse(li.rhs);
return new Expression(left.Value + " " + JsHelpers.ConvertTokens(Helpers.GetTokenType(li.oper)) + " " + right.Value, pStatement.entity_typeref);
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsOperatorUnaryExpression ex = (CsOperatorUnaryExpression)pStatement;
return new Expression(
JsHelpers.ConvertTokens(Helpers.GetTokenType(ex.oper)) + pCreator.Parse(ex.unary_expression).Value,
pStatement.entity_typeref
);
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
// "default" ( type )
return(new Expression(
null,
pStatement.entity_typeref
));
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
//expression "." identifier (type-argument-list?)
CsPrimaryExpressionMemberAccess ex = (CsPrimaryExpressionMemberAccess)pStatement;
string name;
bool renamed = Helpers.GetRealName(ex, ex.identifier.identifier, out name);
if (renamed)
{
return(new Expression(name, pStatement.entity_typeref));
}
CsEntityProperty p = ex.entity as CsEntityProperty;
bool isInternal = false;
if (p != null && p.decl != null)
{
TheClass theClass = TheClassFactory.Get(p, pCreator);
TheClass parent = theClass;
//Am I extending a standard flash class? Do not rename then...
bool isStandardGetSet = false;
while (parent.Base != null)
{
isStandardGetSet |= parent.FullName.StartsWith("flash.");
parent = parent.Base;
}
if (!isStandardGetSet)
{
TheProperty theProperty = theClass.GetProperty((CsProperty)p.decl);
if (theProperty != null)
{
if (ex.parent is CsAssignmentExpression)
{
//setter
isInternal = true;
name = "set_" + name + "({0})";
}
else
{
//getter, rename
name = "get_" + name + "()";
}
}
}
}
else if (ex.ec == expression_classification.ec_event_access) //remove eventhandler name
{
name = string.Empty;
}
return(new Expression(
pCreator.Parse(ex.expression).Value + "." + name,
pStatement.entity_typeref,
isInternal
));
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
//object-creation-expression:
//"new" type "(" ( argument_list )? ")" object-or-collection-initializer?
//"new" type object-or-collection-initializer
//delegate-creation-expression:
//"new" delegate-type "(" expression ")"
CsNewObjectExpression node = (CsNewObjectExpression)pStatement;
StringBuilder sb = new StringBuilder();
string name = As3Helpers.Convert(Helpers.GetType(node.type));
bool isVector = name.StartsWith("Vector.<", StringComparison.Ordinal) && node.initializer != null;
bool isArray = name.Equals("Array", StringComparison.Ordinal) && node.initializer != null;
if (!isArray)
sb.Append("(new ");
if (isVector || isArray) {
if (isVector) {
int lb = name.IndexOf("<") + 1;
sb.AppendFormat("<{0}>", name.Substring(lb, name.IndexOf(">") - lb));
}
sb.Append("[");
CsCollectionInitializer initializer = (CsCollectionInitializer)node.initializer;
if (initializer.element_initializer_list != null) {
List<string> args = new List<string>();
foreach (var csNode in initializer.element_initializer_list) {
args.Add(pCreator.Parse(csNode).Value);
}
sb.Append(String.Join(", ", args.ToArray()));
}
} else {
sb.AppendFormat("{0}(", name);
if (node.argument_list != null) {
List<string> args = new List<string>();
foreach (CsArgument argument in node.argument_list.list) {
args.Add(pCreator.Parse(argument.expression).Value);
}
sb.Append(String.Join(", ", args.ToArray()));
}
}
sb.Append(isVector || isArray ? "]" : ")");
if (!isArray)
sb.Append(")");
return new Expression(
sb.ToString(),
pStatement.entity_typeref
);
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
CsBinaryExpression li = (CsBinaryExpression)pStatement;
Expression left = pCreator.Parse(li.lhs);
Expression right = pCreator.Parse(li.rhs);
return(new Expression(left.Value + " " + As3Helpers.ConvertTokens(Helpers.GetTokenType(li.oper)) + " " + right.Value, pStatement.entity_typeref));
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
CsOperatorUnaryExpression ex = (CsOperatorUnaryExpression)pStatement;
return(new Expression(
As3Helpers.ConvertTokens(Helpers.GetTokenType(ex.oper)) + pCreator.Parse(ex.unary_expression).Value,
pStatement.entity_typeref
));
}
public static TheClass Get(CsNode pNode, FactoryExpressionCreator pCreator)
{
if (pNode == null)
{
return(null);
}
CsExpression csExpression = pNode as CsExpression;
if (csExpression != null && csExpression.ec != expression_classification.ec_nothing)
{
return(Get((CsEntity)csExpression.entity, pCreator));
}
while (pNode != null)
{
if (pNode is CsTypeRef || pNode is CsClass || pNode is CsInterface)
{
break;
}
pNode = pNode.parent;
}
CsClass klass = pNode as CsClass;
if (klass != null)
{
if (!_classes.ContainsKey(klass))
{
_classes[klass] = new TheClass(klass, pCreator);
}
return(_classes[klass]);
}
CsTypeRef csTypeRef = pNode as CsTypeRef;
if (csTypeRef != null)
{
return(csTypeRef.entity_typeref == null ? null : Get((CsEntityClass)(csTypeRef.entity_typeref.u), pCreator));
}
CsInterface csInterface = pNode as CsInterface;
if (csInterface != null)
{
if (!_interfaces.ContainsKey(csInterface))
{
_interfaces[csInterface] = new TheClass(csInterface, pCreator);
}
return(_interfaces[csInterface]);
}
throw new Exception();
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsAsIsExpression ex = (CsAsIsExpression)pStatement;
return new Expression(
pCreator.Parse(ex.expression).Value
+ " "
+ As3Helpers.ConvertTokens(Helpers.GetTokenType(ex.oper)) + " " + As3Helpers.Convert(Helpers.GetType(ex.type)),
ex.entity_typeref
);
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsPreIncrementDecrementExpression ex = (CsPreIncrementDecrementExpression)pStatement;
Expression exp = pCreator.Parse(ex.unary_expression);
return new Expression(
As3Helpers.ConvertTokens(Helpers.GetTokenType(ex.oper)) + exp.Value,
pStatement.entity_typeref
);
}
private static void parseUsingStatement(CsStatement pArg1, CodeBuilder pSb, FactoryExpressionCreator pCreator) {
CsUsingStatement statement = (CsUsingStatement)pArg1;
CsLocalVariableDeclaration declaration = statement.resource as CsLocalVariableDeclaration;
string varname;
if (declaration == null) {
varname = "$$using$$";
Expression e = pCreator.Parse(statement.resource);
pSb.AppendFormat("var {0}:{1} = {2};",
varname,
As3Helpers.Convert(Helpers.GetType(e.Type)),
e.Value
);
pSb.AppendLine();
} else {
CsLocalVariableDeclarator declarator = declaration.declarators.First.Value;
StringBuilder sb = new StringBuilder();
sb.AppendFormat("var {0}:{1}",
declarator.identifier.identifier,
As3Helpers.Convert(Helpers.GetType(declaration.type))
);
varname = declarator.identifier.identifier;
if (declarator.initializer == null) {
sb.Append(";");
} else {
sb.AppendFormat(" = {0};", parseNode(declarator.initializer, pCreator));
}
pSb.Append(sb.ToString());
pSb.AppendLine();
}
pSb.Append("try {");
pSb.AppendLine();
ParseNode(statement.statement, pSb, pCreator);
pSb.Append("} finally {");
pSb.AppendLine();
pSb.AppendFormat(" if ({0} != null) {0}.Dispose();", varname);
pSb.AppendLine();
pSb.Append("}");
pSb.AppendLine();
pSb.AppendLine();
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsConditionalExpression ex = (CsConditionalExpression)pStatement;
return new Expression(
pCreator.Parse(ex.condition).Value + " ? " +
pCreator.Parse(ex.true_expression).Value + " : " +
pCreator.Parse(ex.false_expression).Value,
pStatement.entity_typeref
);
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsTypeofExpression ex = (CsTypeofExpression)pStatement;
//"typeof" "(" type ")"
CsNamespaceOrTypeName isClass = ex.type.type_name as CsNamespaceOrTypeName;
if (isClass != null) {
return new Expression(isClass.identifier.identifier, ex.type.entity_typeref);
}
throw new NotImplementedException();
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsCastUnaryExpression ex = (CsCastUnaryExpression)pStatement;
//Do not cast anything. This is here just to support the automatic casting done by the flash player.
return new Expression(
//As3Helpers.Convert(Helpers.GetType(ex.type)) + "(" +
pCreator.Parse(ex.unary_expression).Value
//+ ")"
, ex.type.entity_typeref
);
}
internal static Expression parseElementAccess(CsExpression pStatement, bool pForce, bool pGetSetter, FactoryExpressionCreator pCreator) {
//expression "[" expression-list "]"
CsElementAccess stat = (CsElementAccess)pStatement;
List<CsExpression> l = new List<CsExpression>();
foreach (CsArgument csArgument in stat.argument_list.list) {
l.Add(csArgument.expression);
}
return getIndexerExpression(stat, l, pCreator.Parse(stat.expression), pForce, pGetSetter, pCreator);
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
CsAsIsExpression ex = (CsAsIsExpression)pStatement;
return(new Expression(
pCreator.Parse(ex.expression).Value
+ " "
+ As3Helpers.ConvertTokens(Helpers.GetTokenType(ex.oper)) + " " + As3Helpers.Convert(Helpers.GetType(ex.type)),
ex.entity_typeref
));
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
CsCastUnaryExpression ex = (CsCastUnaryExpression)pStatement;
//Do not cast anything. This is here just to support the automatic casting done by the flash player.
return(new Expression(
//JsHelpers.Convert(Helpers.GetType(ex.type)) + "(" +
pCreator.Parse(ex.unary_expression).Value
//+ ")"
, ex.type.entity_typeref
));
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
CsConditionalExpression ex = (CsConditionalExpression)pStatement;
return(new Expression(
pCreator.Parse(ex.condition).Value + " ? " +
pCreator.Parse(ex.true_expression).Value + " : " +
pCreator.Parse(ex.false_expression).Value,
pStatement.entity_typeref
));
}
public static string GetEventFromAttr(CsAttributes pList, FactoryExpressionCreator pCreator)
{
addImports(pList, pCreator);
List <AttributeItem> vals = GetAttributeValue(pList, EVENT_ATTRIBUTE, pCreator);
if (vals.Count == 0)
{
return(null);
}
return(vals[0].Parameters.Count == 0 ? null : (string)vals[0].Parameters[0]);
}
private static void parseStatement(CsStatement pStatement, CodeBuilder pSb, FactoryExpressionCreator pCreator)
{
Type type = pStatement.GetType();
if (_statementWritters.ContainsKey(type))
{
_statementWritters[type](pStatement, pSb, pCreator);
}
else
{
throw new NotImplementedException("Statement of type: " + pStatement + " not implemented");
}
}
public TheProperty(CsProperty pCsProperty, TheClass pTheClass, FactoryExpressionCreator pCreator) {
MyClass = pTheClass;
Modifiers.AddRange(Helpers.GetModifiers(pCsProperty.modifiers));
Name = pCsProperty.identifier.identifier;
FullName = MyClass.FullName + "." + Name;
ReturnType = Helpers.GetType(pCsProperty.type);
if (pCsProperty.getter != null)
Getter = new Property(pCsProperty.getter, this);
if (pCsProperty.setter != null)
Setter = new Property(pCsProperty.setter, this);
}
public static TheClass Get(CsEntity pCsEntity, FactoryExpressionCreator pCreator)
{
if (pCsEntity == null)
{
return(null);
}
while (pCsEntity != null)
{
if (pCsEntity is CsEntityClass || pCsEntity is CsEntityStruct || pCsEntity is CsEntityInterface)
{
break;
}
pCsEntity = pCsEntity.parent;
}
CsEntityClass entityKlass = pCsEntity as CsEntityClass;
if (entityKlass != null && entityKlass.nodes.Count != 0 && entityKlass.nodes.First.Value != null)
{
return(Get(entityKlass.nodes.First.Value, pCreator));
}
CsEntityStruct entityStruct = pCsEntity as CsEntityStruct;
if (entityStruct != null && entityStruct.nodes.Count != 0 && entityStruct.nodes.First.Value != null)
{
return(Get(entityStruct.nodes.First.Value, pCreator));
}
CsEntityInterface entityInterface = pCsEntity as CsEntityInterface;
if (entityInterface != null && entityInterface.nodes.Count != 0 && entityInterface.nodes.First.Value != null)
{
return(Get(entityInterface.nodes.First.Value, pCreator));
}
if (pCsEntity != null)
{
if (!_entities.ContainsKey(pCsEntity))
{
_entities[pCsEntity] = new TheClass(pCsEntity, pCreator);
}
return(_entities[pCsEntity]);
}
throw new Exception();
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
CsTypeofExpression ex = (CsTypeofExpression)pStatement;
//"typeof" "(" type ")"
CsNamespaceOrTypeName isClass = ex.type.type_name as CsNamespaceOrTypeName;
if (isClass != null)
{
return(new Expression(isClass.identifier.identifier, ex.type.entity_typeref));
}
throw new NotImplementedException();
}
public static void Parse(TheIndexer pGetIndexer, CodeBuilder pBuilder, FactoryExpressionCreator pCreator)
{
bool isInterface = pGetIndexer.MyClass.IsInterface;
if (pGetIndexer.Getter != null)
{
pBuilder.AppendFormat("{0}function {1}({2}):{3}{4}",
As3Helpers.ConvertModifiers(pGetIndexer.Getter.Modifiers, _notValidMod),
pGetIndexer.Getter.Name,
As3Helpers.GetParameters(pGetIndexer.Getter.Arguments),
As3Helpers.Convert(pGetIndexer.ReturnType),
isInterface ? ";":" {"
);
pBuilder.AppendLine();
if (!isInterface)
{
BlockParser.Parse(pGetIndexer.Getter.CodeBlock, pBuilder, pCreator);
pBuilder.AppendLine();
pBuilder.AppendLine("}");
pBuilder.AppendLine();
}
}
if (pGetIndexer.Setter == null)
{
return;
}
pBuilder.AppendFormat(
"{0}function {1}({2}):void{3}",
As3Helpers.ConvertModifiers(pGetIndexer.Setter.Modifiers, _notValidMod),
pGetIndexer.Setter.Name,
As3Helpers.GetParameters(pGetIndexer.Setter.Arguments),
isInterface ? ";" : " {"
);
pBuilder.AppendLine();
if (isInterface)
{
return;
}
//BlockParser.InsideSetter = true;
BlockParser.Parse(pGetIndexer.Setter.CodeBlock, pBuilder, pCreator);
//BlockParser.InsideSetter = false;
pBuilder.AppendLine();
pBuilder.AppendLine("}");
pBuilder.AppendLine();
}
internal static List<TheMethodArgument> getArguments(IEnumerable<CsFormalParameter> pLinkedList, FactoryExpressionCreator pCreator) {
List<TheMethodArgument> arguments = new List<TheMethodArgument>();
if (pLinkedList != null) {
arguments.AddRange(from param in pLinkedList
let e = param.default_argument == null ? null : pCreator.Parse(param.default_argument.expression)
select new TheMethodArgument {
Name = param.identifier.identifier,
Type = param.type == null ? Helpers.GetType(param.entity.type) : Helpers.GetType(param.type),
DefaultValue = e
});
}
return arguments;
}
internal TheMethod(CsMethod pCsMethod, TheClass pMyClass, FactoryExpressionCreator pCreator) {
MyClass = pMyClass;
Modifiers.AddRange(Helpers.GetModifiers(pCsMethod.modifiers));
Arguments = getArguments(pCsMethod.parameters.parameters, pCreator);
Signature = getSignature(Arguments);
CodeBlock = pCsMethod.definition;
//_sig = Signature.Replace(',', '_').Replace("<", "").Replace(">", "");
//_name = Helpers.GetRealName(pCsMethod, pCsMethod.identifier.identifier);
_realName = _name = pCsMethod.identifier.identifier;
//FullRealName = MyClass.FullRealName + "." + RealName;
ReturnType = Helpers.GetType(pCsMethod.return_type);
IsExtensionMethod = pCsMethod.entity.isExtensionMethod();
}
private static void addImports(CsAttributes pList, FactoryExpressionCreator pCreator)
{
if (pList == null)
{
return;
}
List <AttributeItem> vals = GetAttributeValue(pList, NAMESPACE_ATTRIBUTE, pCreator);
if (vals.Count == 0 || vals[0].Parameters.Count == 0)
{
return;
}
ImportStatementList.AddImport((string)vals[0].Parameters[0]);
}
public TheConstant(CsConstantDeclaration pCsConstantDeclaration, TheClass pTheClass, FactoryExpressionCreator pCreator) {
Modifiers.AddRange(Helpers.GetModifiers(pCsConstantDeclaration.modifiers));
foreach (CsConstantDeclarator declarator in pCsConstantDeclaration.declarators) {
Constant v = new Constant {
//RealName = declarator.identifier.identifier,
//Name = Helpers.GetRealName(declarator, declarator.identifier.identifier),
Name = declarator.identifier.identifier,
Initializer = pCreator.Parse(declarator.expression),
ReturnType = Helpers.GetType(declarator.entity.type)
};
v.Modifiers.AddRange(Modifiers);
Constants.Add(v);
}
}
internal TheMethod(CsMethod pCsMethod, TheClass pMyClass, FactoryExpressionCreator pCreator)
{
MyClass = pMyClass;
Modifiers.AddRange(Helpers.GetModifiers(pCsMethod.modifiers));
Arguments = getArguments(pCsMethod.parameters.parameters, pCreator);
Signature = getSignature(Arguments);
CodeBlock = pCsMethod.definition;
//_sig = Signature.Replace(',', '_').Replace("<", "").Replace(">", "");
//_name = Helpers.GetRealName(pCsMethod, pCsMethod.identifier.identifier);
_realName = _name = pCsMethod.identifier.identifier;
//FullRealName = MyClass.FullRealName + "." + RealName;
ReturnType = Helpers.GetType(pCsMethod.return_type);
IsExtensionMethod = pCsMethod.entity.isExtensionMethod();
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
//expression "." identifier (type-argument-list?)
CsPrimaryExpressionMemberAccess ex = (CsPrimaryExpressionMemberAccess)pStatement;
string name;
bool renamed = Helpers.GetRealName(ex, ex.identifier.identifier, out name);
if (renamed) {
return new Expression(name, pStatement.entity_typeref);
}
CsEntityProperty p = ex.entity as CsEntityProperty;
bool isInternal = false;
if (p != null && p.decl != null) {
TheClass theClass = TheClassFactory.Get(p, pCreator);
TheClass parent = theClass;
//Am I extending a standard flash class? Do not rename then...
bool isStandardGetSet = false;
while (parent.Base != null) {
isStandardGetSet |= parent.FullName.StartsWith("flash.");
parent = parent.Base;
}
if (!isStandardGetSet) {
TheProperty theProperty = theClass.GetProperty((CsProperty)p.decl);
if (theProperty != null) {
if (ex.parent is CsAssignmentExpression) {
//setter
isInternal = true;
name = "set_" + name + "({0})";
} else {
//getter, rename
name = "get_" + name + "()";
}
}
}
} else if (ex.ec == expression_classification.ec_event_access) {//remove eventhandler name
name = string.Empty;
}
return new Expression(
pCreator.Parse(ex.expression).Value + "." + name,
pStatement.entity_typeref,
isInternal
);
}
internal static List<TheMethodArgument> getArguments(CsEntityFormalParameter[] pCsEntityFormalParameter, FactoryExpressionCreator pCreator) {
List<TheMethodArgument> arguments = new List<TheMethodArgument>();
if (pCsEntityFormalParameter != null) {
foreach (CsEntityFormalParameter formalParameter in pCsEntityFormalParameter) {
CsFormalParameter p = formalParameter.param;
arguments.Add(new TheMethodArgument {
Name = p == null ? formalParameter.name : p.identifier.identifier,
Type = Helpers.GetType(formalParameter.type),
DefaultValue = p == null ? null : p.default_argument == null ? null : pCreator.Parse(p.default_argument.expression)
});
}
}
return arguments;
}
internal TheVariable(CsVariableDeclaration pCsVariableDeclaration, TheClass pTheClass, FactoryExpressionCreator pCreator) {
Modifiers.AddRange(Helpers.GetModifiers(pCsVariableDeclaration.modifiers));
foreach (CsVariableDeclarator declarator in pCsVariableDeclaration.declarators) {
Variable v = new Variable {
//RealName = declarator.identifier.identifier,
//Name = Helpers.GetRealName(declarator, declarator.identifier.identifier),
Name = declarator.identifier.identifier,
Initializer =
declarator.initializer == null ? null : pCreator.Parse(declarator.initializer as CsExpression),
ReturnType = Helpers.GetType(declarator.entity.type)
};
v.Modifiers.AddRange(Modifiers);
Variables.Add(v);
}
}
internal TheMethod(CsEntityMethod pCsMethod, TheClass pMyClass, FactoryExpressionCreator pCreator, bool pIsEvent = false, bool pIsAddEvent = false) {
MyClass = pMyClass;
//Modifiers.AddRange(Helpers.GetModifiers(pCsMethod.access));
Arguments = getArguments(pCsMethod.parameters, pCreator);
Signature = getSignature(Arguments);
//_name = Helpers.GetRealName(pCsMethod, pIsEvent ?
// pIsAddEvent ? "add" : "remove" :
// pCsMethod.name);
_name = pIsEvent ? pIsAddEvent ? "add" : "remove" : pCsMethod.name;
_realName = pCsMethod.name;
//FullRealName = MyClass.FullRealName + "." + RealName;
ReturnType = Helpers.GetType(pCsMethod.specifier.return_type);
IsExtensionMethod = pCsMethod.isExtensionMethod();
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
CsAnonymousObjectCreationExpression ex = (CsAnonymousObjectCreationExpression)pStatement;
StringBuilder builder = new StringBuilder("{");
if (ex.member_declarator_list != null) {
foreach (var declarator in ex.member_declarator_list) {
builder.AppendFormat(@"""{0}"": {1}, ",
declarator.identifier.identifier,
pCreator.Parse(declarator.expression).Value
);
}
builder.Remove(builder.Length - 2, 2);
}
builder.Append("}");
return new Expression(builder.ToString(), ex.entity_typeref);
}
internal static Expression getIndexerExpression(CsExpression pStatement, IEnumerable<CsExpression> pList,
Expression pIndexer, bool pForce, bool pGetSetter, FactoryExpressionCreator pCreator) {
TheClass k = TheClassFactory.Get(pStatement, pCreator);
List<string> indexes = new List<string>();
List<CsEntityTypeRef> param = new List<CsEntityTypeRef>();
foreach (CsExpression ex in pList) {
Expression te = pCreator.Parse(ex);
indexes.Add(te.Value);
param.Add(te.Type);
}
string exp = pIndexer == null ? "super" : pIndexer.Value;
bool isInternal = false;
TheIndexer i = null;
if (k != null)
i = k.GetIndexer(pStatement);
//TODO: Check array access...
if (i == null || pIndexer == null || (pIndexer.Type != null && pIndexer.Type.type == cs_entity_type.et_array)) {
//Array access or unknown accessor
exp += "[" + indexes[0] + "]";
} else {
//TheIndexers i = k.GetIndexerBySignature(param);
isInternal = true;
CsAssignmentExpression parent = pStatement.parent as CsAssignmentExpression;
if (!pForce) {
pGetSetter = parent != null && parent.lhs.Equals(pStatement);
}
if (pGetSetter) {
exp += "." + i.Setter.Name + "(" + string.Join(", ", indexes.ToArray()) + ", {0})";
} else {
exp += "." + i.Getter.Name + "(" + string.Join(", ", indexes.ToArray()) + ")";
}
}
return new Expression(exp, pStatement.entity_typeref, isInternal);
}
internal TheMethod(CsEntityMethod pCsMethod, TheClass pMyClass, FactoryExpressionCreator pCreator, bool pIsEvent = false, bool pIsAddEvent = false)
{
MyClass = pMyClass;
//Modifiers.AddRange(Helpers.GetModifiers(pCsMethod.access));
Arguments = getArguments(pCsMethod.parameters, pCreator);
Signature = getSignature(Arguments);
//_name = Helpers.GetRealName(pCsMethod, pIsEvent ?
// pIsAddEvent ? "add" : "remove" :
// pCsMethod.name);
_name = pIsEvent ? pIsAddEvent ? "add" : "remove" : pCsMethod.name;
_realName = pCsMethod.name;
//FullRealName = MyClass.FullRealName + "." + RealName;
ReturnType = Helpers.GetType(pCsMethod.specifier.return_type);
IsExtensionMethod = pCsMethod.isExtensionMethod();
}
public static void Parse(CsBlock pCsBlock, CodeBuilder pSb, FactoryExpressionCreator pCreator)
{
if (pCsBlock == null)
{
return;
}
pSb.Indent();
if (pCsBlock.statements != null)
{
foreach (CsStatement statement in pCsBlock.statements)
{
parseStatement(statement, pSb, pCreator);
}
}
pSb.Unindent();
}
public TheEvent(CsEvent pCsEvent, TheClass pTheClass, FactoryExpressionCreator pCreator) {
MyClass = pTheClass;
if (pCsEvent.declarators.Count > 1) throw new Exception("No more than one event declaration per handler is supported");
_declarator = pCsEvent.declarators.First.Value;
Name = _declarator.identifier.identifier;//RealName =
//FullRealName = MyClass.FullRealName + "." + RealName;
FullName = MyClass.FullName + "." + Name;
Modifiers.AddRange(Helpers.GetModifiers(pCsEvent.modifiers));
string eventName = Helpers.GetEventFromAttr(pCsEvent.attributes, pCreator);
IsFlashEvent = !string.IsNullOrEmpty(eventName);
Add = new TheMethod(_declarator.entity.add, pTheClass, pCreator, true, true);
Remove = new TheMethod(_declarator.entity.remove, pTheClass, pCreator, true);
EventName = Helpers.GetEventFromAttr(pCsEvent.attributes, pCreator);
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
{
//"new" non-array-type "[" expression-list "]" ( rank-specifiers )? ( array-initializer )?
//"new" non-array-type? rank-specifiers array-initializer
CsNewArrayExpression ex = (CsNewArrayExpression)pStatement;
StringBuilder builder = new StringBuilder();
if (ex.initializer != null)
{
builder.Append("[");
//builder.AppendFormat("new <{0}>[", As3Helpers.Convert(Helpers.GetType(((CsEntityArraySpecifier)ex.entity_typeref.u).type)));
if (ex.initializer.initializers != null)
{
List <string> initializers = new List <string>();
foreach (CsNode node in ex.initializer.initializers)
{
Expression expression = pCreator.Parse(node as CsExpression);
initializers.Add(expression.Value);
}
if (initializers.Count != 0)
{
builder.Append(string.Join(", ", initializers.ToArray()));
}
}
builder.Append("]");
//builder.Append("]");
}
else if (ex.expressions != null && ex.expressions.list != null && ex.expressions.list.Count == 1)
{
builder.Append("new Array(");
Expression expression = pCreator.Parse(ex.expressions.list.First.Value);
builder.Append(expression.Value);
builder.Append(")");
}
return(new Expression(builder.ToString(), pStatement.entity_typeref));
}
public static void Parse(TheIndexer pGetIndexer, CodeBuilder pBuilder, FactoryExpressionCreator pCreator) {
bool isInterface = pGetIndexer.MyClass.IsInterface;
if (pGetIndexer.Getter != null) {
pBuilder.AppendFormat("{0}function {1}({2}):{3}{4}",
JsHelpers.ConvertModifiers(pGetIndexer.Getter.Modifiers, _notValidMod),
pGetIndexer.Getter.Name,
JsHelpers.GetParameters(pGetIndexer.Getter.Arguments),
JsHelpers.Convert(pGetIndexer.ReturnType),
isInterface ? ";":" {"
);
pBuilder.AppendLine();
if (!isInterface) {
BlockParser.Parse(pGetIndexer.Getter.CodeBlock, pBuilder, pCreator);
pBuilder.AppendLine();
pBuilder.AppendLine("}");
pBuilder.AppendLine();
}
}
if (pGetIndexer.Setter == null) {
return;
}
pBuilder.AppendFormat(
"{0}function {1}({2}):void{3}",
JsHelpers.ConvertModifiers(pGetIndexer.Setter.Modifiers, _notValidMod),
pGetIndexer.Setter.Name,
JsHelpers.GetParameters(pGetIndexer.Setter.Arguments),
isInterface ? ";" : " {"
);
pBuilder.AppendLine();
if (isInterface)
return;
//BlockParser.InsideSetter = true;
BlockParser.Parse(pGetIndexer.Setter.CodeBlock, pBuilder, pCreator);
//BlockParser.InsideSetter = false;
pBuilder.AppendLine();
pBuilder.AppendLine("}");
pBuilder.AppendLine();
}
public static TheClass Get(CsNode pNode, FactoryExpressionCreator pCreator) {
if (pNode == null)
return null;
CsExpression csExpression = pNode as CsExpression;
if (csExpression != null && csExpression.ec != expression_classification.ec_nothing) {
return Get((CsEntity)csExpression.entity, pCreator);
}
while (pNode != null) {
if (pNode is CsTypeRef || pNode is CsClass || pNode is CsInterface) {
break;
}
pNode = pNode.parent;
}
CsClass klass = pNode as CsClass;
if (klass != null) {
if (!_classes.ContainsKey(klass))
_classes[klass] = new TheClass(klass, pCreator);
return _classes[klass];
}
CsTypeRef csTypeRef = pNode as CsTypeRef;
if (csTypeRef != null) {
return csTypeRef.entity_typeref == null ? null : Get((CsEntityClass)(csTypeRef.entity_typeref.u), pCreator);
}
CsInterface csInterface = pNode as CsInterface;
if (csInterface != null) {
if (!_interfaces.ContainsKey(csInterface))
_interfaces[csInterface] = new TheClass(csInterface, pCreator);
return _interfaces[csInterface];
}
throw new Exception();
}
internal TheConstructor(CsConstructor pConstructor, TheClass pMyClass, FactoryExpressionCreator pCreator) {
_constructor = pConstructor;
_creator = pCreator;
MyClass = pMyClass;
Modifiers.AddRange(Helpers.GetModifiers(pConstructor.modifiers));
Arguments = getArguments(pConstructor.parameters.parameters, pCreator);
BaseArguments = Helpers.GetCallingArguments(pConstructor.argument_list, pCreator);
Signature = getSignature(Arguments);
CodeBlock = pConstructor.definition;
HasBaseCall = pConstructor.basethis == CsTokenType.tkBASE;
LinkedList<CsFormalParameter> csFormalParameters = pConstructor.parameters.parameters;
_noFormalParams = csFormalParameters == null;
_name = pConstructor.identifier.identifier;
IsStaticConstructor = (pConstructor.modifiers.flags & (uint)CsModifierEnum.mSTATIC) != 0;
if (pConstructor.basethis == CsTokenType.tkBASE || pConstructor.basethis == CsTokenType.tkTHIS) {
_baseConstructor = pConstructor.basethis == CsTokenType.tkBASE
? (CsEntityClass)((CsEntityClass)pConstructor.entity.parent).base_type.u
: ((CsEntityClass)pConstructor.entity.parent);
}
}
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) {
//"new" non-array-type "[" expression-list "]" ( rank-specifiers )? ( array-initializer )?
//"new" non-array-type? rank-specifiers array-initializer
CsNewArrayExpression ex = (CsNewArrayExpression) pStatement;
StringBuilder builder = new StringBuilder();
if (ex.initializer != null) {
builder.Append("[");
//builder.AppendFormat("new <{0}>[", JsHelpers.Convert(Helpers.GetType(((CsEntityArraySpecifier)ex.entity_typeref.u).type)));
if (ex.initializer.initializers != null) {
List<string> initializers = new List<string>();
foreach (CsNode node in ex.initializer.initializers) {
Expression expression = pCreator.Parse(node as CsExpression);
initializers.Add(expression.Value);
}
if (initializers.Count != 0) {
builder.Append(string.Join(", ", initializers.ToArray()));
}
}
builder.Append("]");
//builder.Append("]");
} else if (ex.expressions != null && ex.expressions.list != null && ex.expressions.list.Count == 1) {
builder.Append("new Array(");
Expression expression = pCreator.Parse(ex.expressions.list.First.Value);
builder.Append(expression.Value);
builder.Append(")");
}
return new Expression(builder.ToString(), pStatement.entity_typeref);
}
