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(); }
private static void parseForeachStatement(CsStatement pStatement, CodeBuilder pSb, FactoryExpressionCreator pCreator) { CsForeachStatement fes = (CsForeachStatement)pStatement; Expression ex = pCreator.Parse(fes.expression); string type = JsHelpers.Convert(Helpers.GetType(fes.type)); pSb.AppendLine(); _enumCount++; string enumName = String.Format(@"__ie{0}", _enumCount); pSb.AppendFormat("var {0}:IEnumerator = {1}.GetEnumerator();", enumName, ex.Value); pSb.AppendLine(); pSb.AppendFormat("while ({0}.MoveNext()){{", enumName); pSb.AppendLine(); pSb.AppendFormat("\tvar {1}:{2} = {0}.get_Current() as {2};", enumName, fes.identifier.identifier, type ); pSb.AppendLine(); ParseNode(fes.statement, pSb, pCreator); pSb.AppendLine("}"); pSb.AppendLine(); }
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(); }
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 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(); }
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); }
private static void parseThrowStatement(CsStatement pStatement, CodeBuilder pSb, FactoryExpressionCreator pCreator) { CsThrowStatement throwStatement = (CsThrowStatement)pStatement; pSb.AppendFormat("throw {0};", parseNode(throwStatement.expression, pCreator)); pSb.AppendLine(); }
public override void VisitElseClause(ElseClauseSyntax node) { IfStatementSyntax ifNode = node.Statement as IfStatementSyntax; if (null != ifNode) { CodeBuilder.AppendFormat("{0}elseif ", GetIndentString()); VisitExpressionSyntax(ifNode.Condition); CodeBuilder.AppendLine(" then"); ++m_Indent; ifNode.Statement.Accept(this); --m_Indent; if (null != ifNode.Else) { VisitElseClause(ifNode.Else); } else { CodeBuilder.AppendFormat("{0}end;", GetIndentString()); CodeBuilder.AppendLine(); } } else { CodeBuilder.AppendFormat("{0}else", GetIndentString()); CodeBuilder.AppendLine(); ++m_Indent; node.Statement.Accept(this); --m_Indent; CodeBuilder.AppendFormat("{0}end;", GetIndentString()); CodeBuilder.AppendLine(); } }
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 override void VisitIfStatement(IfStatementSyntax node) { string postfix = GetSourcePosForVar(node); CodeBuilder.AppendFormat("{0}if( ", GetIndentString()); var oper = m_Model.GetOperationEx(node) as IConditionalOperation; IConversionOperation opd = null; if (null != oper) { opd = oper.Condition as IConversionOperation; } OutputExpressionSyntax(node.Condition, opd); CodeBuilder.Append(", "); CodeBuilder.Append(postfix); CodeBuilder.AppendLine(" ){"); ++m_Indent; node.Statement.Accept(this); --m_Indent; if (null != node.Else) { VisitElseClause(node.Else); } else { CodeBuilder.AppendFormat("{0}}};", GetIndentString()); CodeBuilder.AppendLine(); } }
public override void VisitJoinClause(JoinClauseSyntax node) { var paramInfo = m_LinqParamInfoStack.Peek(); var paramNames = paramInfo.ParamNames; CodeBuilder.AppendFormat("join((function({0}){{ return(", string.Join(", ", paramNames.ToArray())); var opd = m_Model.GetOperation(node.InExpression) as IConversionExpression; OutputExpressionSyntax(node.InExpression, opd); CodeBuilder.Append("); }), "); paramInfo.JoinParamName = node.Identifier.Text; paramNames.Add(paramInfo.JoinParamName); CodeBuilder.AppendFormat("(function({0}){{ return(", string.Join(", ", paramNames.ToArray())); var opdl = m_Model.GetOperation(node.LeftExpression) as IConversionExpression; OutputExpressionSyntax(node.LeftExpression, opdl); CodeBuilder.Append("); }), "); CodeBuilder.AppendFormat("(function({0}){{ return(", string.Join(", ", paramNames.ToArray())); var opdr = m_Model.GetOperation(node.RightExpression) as IConversionExpression; OutputExpressionSyntax(node.RightExpression, opdr); CodeBuilder.Append("); }))"); if (null != node.Into) { VisitJoinIntoClause(node.Into); } }
public override void VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node) { SymbolInfo symInfo = m_Model.GetSymbolInfo(node); var sym = symInfo.Symbol as IMethodSymbol; if (null != sym && sym.Parameters.Length == 1) { var param = sym.Parameters[0]; CodeBuilder.AppendFormat("(function({0}) return ", param.Name); IConversionExpression opd = null; var oper = m_Model.GetOperation(node) as ILambdaExpression; if (null != oper && oper.Body.Statements.Length == 1) { var iret = oper.Body.Statements[0] as IReturnStatement; if (null != iret) { opd = iret.ReturnedValue as IConversionExpression; } } var exp = node.Body as ExpressionSyntax; OutputExpressionSyntax(exp, opd); CodeBuilder.Append("; end)"); } else { ReportIllegalSymbol(node, symInfo); } }
public override void VisitContinueStatement(ContinueStatementSyntax node) { if (m_ContinueInfoStack.Count > 0) { var ci = m_ContinueInfoStack.Peek(); if (ci.IsIgnoreBreak) { return; } if (ci.HaveBreak) { CodeBuilder.AppendFormat("{0}{1} = false;", GetIndentString(), ci.BreakFlagVarName); CodeBuilder.AppendLine(); } bool isLastNode = IsLastNodeOfFor(node); if (isLastNode) { CodeBuilder.AppendFormat("{0}do", GetIndentString()); CodeBuilder.AppendLine(); } CodeBuilder.AppendFormat("{0}break;", GetIndentString()); CodeBuilder.AppendLine(); if (isLastNode) { CodeBuilder.AppendFormat("{0}end;", GetIndentString()); CodeBuilder.AppendLine(); } } }
public override void VisitVariableDeclarator(VariableDeclaratorSyntax node) { var ci = m_ClassInfoStack.Peek(); var localSym = m_Model.GetDeclaredSymbol(node) as ILocalSymbol; if (null != node.Initializer) { CodeBuilder.AppendFormat("{0}local {1}; {2}", GetIndentString(), node.Identifier.Text, node.Identifier.Text); } else { CodeBuilder.AppendFormat("{0}local {1}", GetIndentString(), node.Identifier.Text); } if (null != localSym && localSym.HasConstantValue) { CodeBuilder.Append(" = "); OutputConstValue(localSym.ConstantValue, localSym); CodeBuilder.AppendLine(";"); return; } VisitLocalVariableDeclarator(ci, node); if (null != node.Initializer) { var oper = m_Model.GetOperation(node.Initializer.Value); if (null != oper && null != oper.Type && oper.Type.TypeKind == TypeKind.Struct && oper.Type.ContainingAssembly == m_SymbolTable.AssemblySymbol) { CodeBuilder.AppendFormat("{0}{1} = wrapvaluetype({2});", GetIndentString(), node.Identifier.Text, node.Identifier.Text); CodeBuilder.AppendLine(); } } }
private void OutputDelegationCompareWithNull(ISymbol leftSym, ExpressionSyntax left, bool isCs2LuaAssembly, bool isEvent, bool isEqual, IConversionExpression opd) { var ci = m_ClassInfoStack.Peek(); CodeBuilder.AppendFormat("{0}delegationcomparewithnil({1}, ", isCs2LuaAssembly ? string.Empty : "extern", isEvent ? "true" : "false"); if (null != leftSym && (leftSym.Kind == SymbolKind.Field || leftSym.Kind == SymbolKind.Property || leftSym.Kind == SymbolKind.Event)) { var memberAccess = left as MemberAccessExpressionSyntax; if (null != memberAccess) { OutputExpressionSyntax(memberAccess.Expression, opd); CodeBuilder.Append(", "); string intf = "nil"; string mname = string.Format("\"{0}\"", memberAccess.Name.Identifier.Text); CheckExplicitInterfaceAccess(leftSym, ref intf, ref mname); CodeBuilder.AppendFormat("{0}, {1}", intf, mname); } else if (leftSym.ContainingType == ci.SemanticInfo || ci.IsInherit(leftSym.ContainingType)) { CodeBuilder.Append("this, nil, "); CodeBuilder.AppendFormat("\"{0}\"", leftSym.Name); } else { OutputExpressionSyntax(left, opd); CodeBuilder.Append(", nil, nil"); } } else { OutputExpressionSyntax(left, opd); CodeBuilder.Append(", nil, nil"); } CodeBuilder.AppendFormat(", {0})", isEqual ? "true" : "false"); }
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(); }
public override void VisitForStatement(ForStatementSyntax node) { ContinueInfo ci = new ContinueInfo(); ci.Init(node.Statement); m_ContinueInfoStack.Push(ci); if (null != node.Declaration) { VisitVariableDeclaration(node.Declaration); } CodeBuilder.AppendFormat("{0}while ", GetIndentString()); if (null != node.Condition) { var oper = m_Model.GetOperation(node) as IForLoopStatement; IConversionExpression opd = null; if (null != oper) { opd = oper.Condition as IConversionExpression; } OutputExpressionSyntax(node.Condition, opd); } else { CodeBuilder.AppendLine("true"); } CodeBuilder.AppendLine(" do"); if (ci.HaveContinue) { if (ci.HaveBreak) { CodeBuilder.AppendFormat("{0}local {1} = false", GetIndentString(), ci.BreakFlagVarName); CodeBuilder.AppendLine(); } CodeBuilder.AppendFormat("{0}repeat", GetIndentString()); CodeBuilder.AppendLine(); } ++m_Indent; node.Statement.Accept(this); --m_Indent; if (ci.HaveContinue) { CodeBuilder.AppendFormat("{0}until true;", GetIndentString()); CodeBuilder.AppendLine(); if (ci.HaveBreak) { CodeBuilder.AppendFormat("{0}if {1} then break; end;", GetIndentString(), ci.BreakFlagVarName); CodeBuilder.AppendLine(); } } foreach (var exp in node.Incrementors) { CodeBuilder.AppendFormat("{0}", GetIndentString()); VisitToplevelExpression(exp, ";"); } CodeBuilder.AppendFormat("{0}end;", GetIndentString()); CodeBuilder.AppendLine(); m_ContinueInfoStack.Pop(); }
public override void VisitIfStatement(IfStatementSyntax node) { CodeBuilder.AppendFormat("{0}if ", GetIndentString()); var oper = m_Model.GetOperation(node) as IIfStatement; IConversionExpression opd = null; if (null != oper) { opd = oper.Condition as IConversionExpression; } OutputExpressionSyntax(node.Condition, opd); CodeBuilder.AppendLine(" then"); ++m_Indent; node.Statement.Accept(this); --m_Indent; if (null != node.Else) { VisitElseClause(node.Else); } else { CodeBuilder.AppendFormat("{0}end;", GetIndentString()); CodeBuilder.AppendLine(); } }
public override void VisitCatchClause(CatchClauseSyntax node) { MethodInfo mi = m_MethodInfoStack.Peek(); mi.TryCatchUsingOrLoopSwitchStack.Push(true); ReturnContinueBreakAnalysis returnAnalysis = mi.TempReturnAnalysisStack.Peek(); string handledVar = string.Format("__catch_handled_{0}", GetSourcePosForVar(node)); string bodyVar = string.Format("__catch_body_{0}", GetSourcePosForVar(node)); CodeBuilder.AppendFormat("{0}(function({1}", GetIndentString(), handledVar); if (null != node.Declaration) { CodeBuilder.Append(", "); CodeBuilder.Append(node.Declaration.Identifier.Text); } CodeBuilder.Append("){"); CodeBuilder.AppendLine(); ++m_Indent; if (null != node.Filter) { CodeBuilder.Append("if("); IConversionExpression opd = m_Model.GetOperation(node.Filter.FilterExpression) as IConversionExpression; OutputExpressionSyntax(node.Filter.FilterExpression, opd); CodeBuilder.Append("){"); CodeBuilder.AppendLine(); ++m_Indent; } CodeBuilder.AppendFormat("{0}{1} = true;", GetIndentString(), handledVar); CodeBuilder.AppendLine(); if (null != node.Filter) { --m_Indent; CodeBuilder.AppendFormat("{0}}};", GetIndentString()); CodeBuilder.AppendLine(); } if (returnAnalysis.Exist) { CodeBuilder.AppendFormat("{0}local({1}); {1} = function(){{", GetIndentString(), bodyVar); CodeBuilder.AppendLine(); ++m_Indent; VisitBlock(node.Block); --m_Indent; CodeBuilder.AppendFormat("{0}}};", GetIndentString()); CodeBuilder.AppendLine(); CodeBuilder.AppendFormat("{0}return({1}, {2}());", GetIndentString(), handledVar, bodyVar); CodeBuilder.AppendLine(); } else { VisitBlock(node.Block); CodeBuilder.AppendFormat("{0}return({1}, null);", GetIndentString(), handledVar); CodeBuilder.AppendLine(); } --m_Indent; CodeBuilder.AppendFormat("{0}}})", GetIndentString()); CodeBuilder.AppendLine(); mi.TryCatchUsingOrLoopSwitchStack.Pop(); }
public override void VisitVariableDeclarator(VariableDeclaratorSyntax node) { var ci = m_ClassInfoStack.Peek(); var localSym = m_Model.GetDeclaredSymbol(node) as ILocalSymbol; if (null != localSym && localSym.HasConstantValue) { if (null != node.Initializer) { CodeBuilder.AppendFormat("{0}local({1}); {2}", GetIndentString(), node.Identifier.Text, node.Identifier.Text); } else { CodeBuilder.AppendFormat("{0}local({1})", GetIndentString(), node.Identifier.Text); } CodeBuilder.Append(" = "); OutputConstValue(localSym.ConstantValue, localSym); CodeBuilder.AppendLine(";"); return; } bool dslToObject = false; IOperation oper = null; if (null != node.Initializer) { oper = m_Model.GetOperationEx(node.Initializer.Value); if (null != localSym && null != localSym.Type && null != oper && null != oper.Type) { dslToObject = InvocationInfo.IsDslToObject(localSym.Type, oper.Type); } } VisitLocalVariableDeclarator(ci, node, dslToObject); if (null != node.Initializer) { var rightSymbolInfo = m_Model.GetSymbolInfoEx(node.Initializer.Value); var rightSym = rightSymbolInfo.Symbol; if (null != oper && null != oper.Type && oper.Type.IsValueType && !dslToObject && !SymbolTable.IsBasicType(oper.Type) && !CsDslTranslater.IsImplementationOfSys(oper.Type, "IEnumerator")) { if (null != rightSym && (rightSym.Kind == SymbolKind.Method || rightSym.Kind == SymbolKind.Property || rightSym.Kind == SymbolKind.Field || rightSym.Kind == SymbolKind.Local) && SymbolTable.Instance.IsCs2DslSymbol(rightSym)) { MarkNeedFuncInfo(); if (SymbolTable.Instance.IsCs2DslSymbol(oper.Type)) { CodeBuilder.AppendFormat("{0}{1} = wrapstruct({2}, {3});", GetIndentString(), node.Identifier.Text, node.Identifier.Text, ClassInfo.GetFullName(oper.Type)); CodeBuilder.AppendLine(); } else { string ns = ClassInfo.GetNamespaces(oper.Type); if (ns != "System") { CodeBuilder.AppendFormat("{0}{1} = wrapexternstruct({2}, {3});", GetIndentString(), node.Identifier.Text, node.Identifier.Text, ClassInfo.GetFullName(oper.Type)); CodeBuilder.AppendLine(); } } } } } }
public override void VisitThrowStatement(ThrowStatementSyntax node) { CodeBuilder.AppendFormat("{0}luathrow(", GetIndentString()); IConversionExpression opd = m_Model.GetOperation(node.Expression) as IConversionExpression; OutputExpressionSyntax(node.Expression, opd); CodeBuilder.AppendLine(");"); }
public override void VisitAssignmentExpression(AssignmentExpressionSyntax node) { var ci = m_ClassInfoStack.Peek(); string op = node.OperatorToken.Text; string baseOp = op.Substring(0, op.Length - 1); bool needWrapFunction = true; var leftOper = m_Model.GetOperation(node.Left); var leftSymbolInfo = m_Model.GetSymbolInfo(node.Left); var leftSym = leftSymbolInfo.Symbol; var leftPsym = leftSym as IPropertySymbol; var leftMemberAccess = node.Left as MemberAccessExpressionSyntax; var leftElementAccess = node.Left as ElementAccessExpressionSyntax; var leftCondAccess = node.Left as ConditionalAccessExpressionSyntax; SpecialAssignmentType specialType = SpecialAssignmentType.None; if (null != leftMemberAccess && null != leftPsym) { if (!leftPsym.IsStatic) { if (CheckExplicitInterfaceAccess(leftPsym)) { specialType = SpecialAssignmentType.PropExplicitImplementInterface; } else if (SymbolTable.IsBasicValueProperty(leftPsym)) { specialType = SpecialAssignmentType.PropForBasicValueType; } } } if (specialType == SpecialAssignmentType.PropExplicitImplementInterface || specialType == SpecialAssignmentType.PropForBasicValueType || null != leftElementAccess || null != leftCondAccess || leftOper.Type.TypeKind == TypeKind.Delegate && (leftSym.Kind != SymbolKind.Local || op != "=")) { needWrapFunction = false; } if (needWrapFunction) { //顶层的赋值语句已经处理,这里的赋值都需要包装成lambda函数的样式 CodeBuilder.Append("(function() "); } VisitAssignment(ci, op, baseOp, node, string.Empty, false, leftOper, leftSym, leftPsym, leftMemberAccess, leftElementAccess, leftCondAccess, specialType); var oper = m_Model.GetOperation(node.Right); if (null != leftSym && leftSym.Kind == SymbolKind.Local && null != oper && null != oper.Type && oper.Type.TypeKind == TypeKind.Struct && oper.Type.ContainingAssembly == m_SymbolTable.AssemblySymbol) { CodeBuilder.AppendFormat("; {0} = wrapvaluetype({1})", leftSym.Name, leftSym.Name); } if (needWrapFunction) { CodeBuilder.Append("; return "); VisitExpressionSyntax(node.Left); CodeBuilder.Append("; end)()"); } }
public override void VisitReturnStatement(ReturnStatementSyntax node) { MethodInfo mi = m_MethodInfoStack.Peek(); mi.ExistTopLevelReturn = IsLastNodeOfMethod(node); bool isLastNode = IsLastNodeOfParent(node); if (!isLastNode) { CodeBuilder.AppendFormat("{0}do", GetIndentString()); CodeBuilder.AppendLine(); } string prestr; if (mi.SemanticInfo.MethodKind == MethodKind.Constructor) { CodeBuilder.AppendFormat("{0}return this", GetIndentString()); prestr = ", "; } else { CodeBuilder.AppendFormat("{0}return ", GetIndentString()); prestr = string.Empty; } if (null != node.Expression) { CodeBuilder.Append(prestr); IConversionExpression opd = null; var iret = m_Model.GetOperation(node) as IReturnStatement; if (null != iret) { opd = iret.ReturnedValue as IConversionExpression; } OutputExpressionSyntax(node.Expression, opd); prestr = ", "; } var names = mi.ReturnParamNames; if (names.Count > 0) { for (int i = 0; i < names.Count; ++i) { CodeBuilder.Append(prestr); CodeBuilder.Append(names[i]); prestr = ", "; } } CodeBuilder.AppendLine(";"); if (!isLastNode) { CodeBuilder.AppendFormat("{0}end;", GetIndentString()); CodeBuilder.AppendLine(); } }
public override void VisitYieldStatement(YieldStatementSyntax node) { MethodInfo mi = m_MethodInfoStack.Peek(); mi.ExistYield = true; if (node.ReturnOrBreakKeyword.Text == "return") { CodeBuilder.AppendFormat("{0}wrapyield(", GetIndentString()); if (null != node.Expression) { var oper = m_Model.GetOperation(node.Expression); var type = oper.Type; OutputExpressionSyntax(node.Expression); if (null != type && (IsImplementationOfSys(type, "IEnumerable") || IsImplementationOfSys(type, "IEnumerator"))) { CodeBuilder.Append(", true"); } else { CodeBuilder.Append(", false"); } if (null != type && IsSubclassOf(type, "UnityEngine.YieldInstruction")) { CodeBuilder.Append(", true"); } else { CodeBuilder.Append(", false"); } } else { CodeBuilder.Append("nil, false, false"); } CodeBuilder.Append(");"); CodeBuilder.AppendLine(); } else { bool isLastNode = IsLastNodeOfParent(node); if (!isLastNode) { CodeBuilder.AppendFormat("{0}do", GetIndentString()); CodeBuilder.AppendLine(); } CodeBuilder.AppendFormat("{0}return nil;", GetIndentString()); CodeBuilder.AppendLine(); if (!isLastNode) { CodeBuilder.AppendFormat("{0}end;", GetIndentString()); CodeBuilder.AppendLine(); } } }
public override void VisitFinallyClause(FinallyClauseSyntax node) { CodeBuilder.AppendFormat("{0}block{{", GetIndentString()); CodeBuilder.AppendLine(); ++m_Indent; VisitBlock(node.Block); --m_Indent; CodeBuilder.AppendFormat("{0}}};", GetIndentString()); CodeBuilder.AppendLine(); }
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 override void VisitContinueStatement(ContinueStatementSyntax node) { MethodInfo mi = m_MethodInfoStack.Peek(); if (m_ContinueInfoStack.Count > 0) { var ci = m_ContinueInfoStack.Peek(); if (ci.IsIgnoreBreak) { return; } if (ci.HaveBreak) { CodeBuilder.AppendFormat("{0}{1} = false;", GetIndentString(), ci.BreakFlagVarName); CodeBuilder.AppendLine(); } bool isLastNode = IsLastNodeOfFor(node); if (!isLastNode) { CodeBuilder.AppendFormat("{0}block{{", GetIndentString()); CodeBuilder.AppendLine(); } if (mi.TryUsingLayer > 0 && mi.TryCatchUsingOrLoopSwitchStack.Peek()) { var returnAnalysis = mi.TempReturnAnalysisStack.Peek(); if (returnAnalysis.ExistReturnInLoopOrSwitch || null == returnAnalysis.RetValVar) { //return(2)代表是tryusing块里的continue语句 CodeBuilder.AppendFormat("{0}return(2);", GetIndentString()); CodeBuilder.AppendLine(); } else { //可以不使用函数对象实现的try块,不能使用return语句,换成变量赋值与break CodeBuilder.AppendFormat("{0}{1} = 2;", GetIndentString(), returnAnalysis.RetValVar); CodeBuilder.AppendLine(); CodeBuilder.AppendFormat("{0}break;", GetIndentString()); CodeBuilder.AppendLine(); } } else { CodeBuilder.AppendFormat("{0}break;", GetIndentString()); CodeBuilder.AppendLine(); } if (!isLastNode) { CodeBuilder.AppendFormat("{0}}};", GetIndentString()); CodeBuilder.AppendLine(); } } }
private static void parseWhileStatement(CsStatement pStatement, CodeBuilder pSb, FactoryExpressionCreator pCreator) { CsWhileStatement whileStatement = (CsWhileStatement)pStatement; pSb.AppendFormat("while ({0}){{", pCreator.Parse(whileStatement.condition)); pSb.AppendLine(); ParseNode(whileStatement.statement, pSb, pCreator); pSb.Append("}"); pSb.AppendLine(); pSb.AppendLine(); }
public override void VisitUsingStatement(UsingStatementSyntax node) { VisitVariableDeclaration(node.Declaration); node.Statement.Accept(this); foreach (var decl in node.Declaration.Variables) { CodeBuilder.AppendFormat("{0}{1}:Dispose();", GetIndentString(), decl.Identifier.Text); CodeBuilder.AppendLine(); } }
public override void VisitOrdering(OrderingSyntax node) { var paramInfo = m_LinqParamInfoStack.Peek(); var paramNames = paramInfo.ParamNames; CodeBuilder.AppendFormat("orderby((function({0}){{ return(", string.Join(", ", paramNames.ToArray())); var opd = m_Model.GetOperation(node.Expression) as IConversionExpression; OutputExpressionSyntax(node.Expression, opd); CodeBuilder.AppendFormat("); }}), {0})", node.AscendingOrDescendingKeyword.Text != "descending" ? "true" : "false"); }
public override void VisitSelectClause(SelectClauseSyntax node) { var paramInfo = m_LinqParamInfoStack.Peek(); var paramNames = paramInfo.ParamNames; CodeBuilder.AppendFormat("select(function({0}){{ return(", string.Join(", ", paramNames.ToArray())); var opd = m_Model.GetOperation(node.Expression) as IConversionExpression; OutputExpressionSyntax(node.Expression, opd); CodeBuilder.Append("); })"); }
public override void VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node) { SymbolInfo symInfo = m_Model.GetSymbolInfo(node); var sym = symInfo.Symbol as IMethodSymbol; if (null != sym && sym.Parameters.Length == 1) { if (node.Body is BlockSyntax) { var param = sym.Parameters[0]; CodeBuilder.AppendFormat("(function({0})", param.Name); CodeBuilder.AppendLine(); ++m_Indent; node.Body.Accept(this); if (!sym.ReturnsVoid) { CodeBuilder.AppendFormat("{0}return {1};", GetIndentString(), param.Name); CodeBuilder.AppendLine(); } --m_Indent; CodeBuilder.AppendFormat("{0}end)", GetIndentString()); } else { var param = sym.Parameters[0]; CodeBuilder.AppendFormat("(function({0}) return ", param.Name); IConversionExpression opd = null; var oper = m_Model.GetOperation(node) as ILambdaExpression; if (null != oper && oper.Body.Statements.Length == 1) { var iret = oper.Body.Statements[0] as IReturnStatement; if (null != iret) { opd = iret.ReturnedValue as IConversionExpression; } } var exp = node.Body as ExpressionSyntax; if (null != exp) { OutputExpressionSyntax(exp, opd); } else { ReportIllegalSymbol(node, symInfo); } CodeBuilder.Append("; end)"); } } else { ReportIllegalSymbol(node, symInfo); } }
public override void VisitQueryContinuation(QueryContinuationSyntax node) { var paramInfo = m_LinqParamInfoStack.Peek(); var paramNames = paramInfo.ParamNames; string prestr = paramInfo.Prestr; paramInfo.Prestr = ", "; paramNames.Clear(); paramNames.Add(node.Identifier.Text); CodeBuilder.AppendFormat("{0}{{\"continuation\"}}", prestr); node.Body.Accept(this); }
public override void VisitLetClause(LetClauseSyntax node) { var paramInfo = m_LinqParamInfoStack.Peek(); var paramNames = paramInfo.ParamNames; CodeBuilder.AppendFormat("let(function({0}){{ funcobjret(", string.Join(", ", paramNames.ToArray())); var opd = m_Model.GetOperationEx(node.Expression) as IConversionExpression; OutputExpressionSyntax(node.Expression, opd); CodeBuilder.Append("); })"); paramNames.Add(node.Identifier.Text); }
public static void Parse(TheEvent pEvent, CodeBuilder pBuilder) { if (pEvent.IsFlashEvent) return; ImportStatementList.AddImport(@"System.EventHandler"); bool isStatic = pEvent.Modifiers.Contains("static"); pBuilder.AppendFormat(@"private {1} var _e{0}:EventHandler; {2}{1} function get {0}():EventHandler {{ if (_e{0} == null) _e{0} = new EventHandler(); return _e{0}; }}", pEvent.Name, isStatic ? "static" : string.Empty, As3Helpers.ConvertModifiers(pEvent.Modifiers, _notValidClassMod) //,isStatic ? pEvent.MyClass.Name : "this" ); pBuilder.AppendLine(); }
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); }
private void WriteDefinition(CodeBuilder cb) { cb.AppendFormat("private {0} {1} {{", typeName, name).AppendLine().Indent() .AppendFormat("get {{ return ({0})controls[\"{1}\"]; }}", typeName, name).AppendLine(); if (customInstantiate) { cb.AppendLine("set {").Indent() .AppendFormat("controls[\"{0}\"] = value;", name).AppendLine() .AppendLine("if (!string.IsNullOrEmpty(id))").Indent() .AppendFormat("((IControl)controls[\"{0}\"]).Id = id + \"_{0}\";", name).Outdent().AppendLine() .Outdent().AppendLine("}"); } cb.Outdent().AppendLine("}").AppendLine(); }
public static void Parse(TheProperty pProperty, CodeBuilder pBuilder, FactoryExpressionCreator pCreator) { if (pProperty == null) return; bool isInterface = pProperty.MyClass.IsInterface; string type = JsHelpers.Convert(pProperty.ReturnType); if (pProperty.IsEmpty && !isInterface) { pBuilder.AppendFormat("private var _{0}:{1};", pProperty.Name, type); pBuilder.AppendLine(); } TheClass parent = pProperty.MyClass; bool isStandardGetSet = false; while (parent.Base != null) { isStandardGetSet |= parent.FullName.StartsWith("flash."); parent = parent.Base; } if (pProperty.Getter != null) {//Getter if (isStandardGetSet) {//base is flash, use standard setter/getter pBuilder.AppendFormat("{0}function get {1}():{2}{3}", JsHelpers.ConvertModifiers(pProperty.Getter.Modifiers, _notValidPropertyMod), pProperty.Name, type, isInterface ? ";" : " {" ); } else { bool isEnum = false; foreach (string s in pProperty.MyClass.Implements) { if (!s.StartsWith("IEnumerator", StringComparison.Ordinal)) { continue; } isEnum = true; break; } isEnum &= pProperty.Getter.Name.Equals("get_Current"); //bool isEnum = // pProperty.Getter.Name.Equals("get_Current") && // pProperty.MyClass.Implements.Contains() pBuilder.AppendFormat("{0}function {1}():{2}{3}", JsHelpers.ConvertModifiers(pProperty.Getter.Modifiers, _notValidPropertyMod), pProperty.Getter.Name, isEnum ? "*" : type, isInterface ? ";" : " {" ); } pBuilder.AppendLine(); if (!isInterface) { if (pProperty.IsEmpty) { pBuilder.Indent(); pBuilder.AppendFormat("return _{0};", pProperty.Name); pBuilder.Unindent(); } else { BlockParser.Parse(pProperty.Getter.CodeBlock, pBuilder, pCreator); } pBuilder.AppendLine(); pBuilder.AppendLine("}"); pBuilder.AppendLine(); } } if (pProperty.Setter == null) { return; } if (isStandardGetSet) {//Setter //base is flash, use standard setter/getter pBuilder.AppendFormat("{0}function set {1}(value:{2}):void{3}", JsHelpers.ConvertModifiers(pProperty.Setter.Modifiers, _notValidPropertyMod), pProperty.Name, type, isInterface ? ";" : " {" ); } else { pBuilder.AppendFormat("{0}function {1}(value:{2}):{2}{3}", JsHelpers.ConvertModifiers(pProperty.Setter.Modifiers, _notValidPropertyMod), pProperty.Setter.Name, type, isInterface ? ";" : " {" ); } pBuilder.AppendLine(); if (!isInterface) { if (pProperty.IsEmpty) { pBuilder.Indent(); pBuilder.AppendFormat("_{0} = value;", pProperty.Name); pBuilder.AppendLine(); pBuilder.Append("return value;"); pBuilder.Unindent(); } else { BlockParser.InsideSetter = !isStandardGetSet; BlockParser.Parse(pProperty.Setter.CodeBlock, pBuilder, pCreator); BlockParser.InsideSetter = false; if (!isStandardGetSet) pBuilder.AppendLine(" return value;"); } pBuilder.AppendLine(); pBuilder.AppendLine("}"); } pBuilder.AppendLine(); }
private static void parseIfStatement(CsStatement pStatement, CodeBuilder pSb, FactoryExpressionCreator pCreator) { CsIfStatement ifStatement = (CsIfStatement)pStatement; pSb.AppendFormat("if ({0}){{", pCreator.Parse(ifStatement.condition)); pSb.AppendLine(); ParseNode(ifStatement.if_statement, pSb, pCreator); if (ifStatement.else_statement != null) { pSb.AppendLine(); pSb.Append("} else {"); pSb.AppendLine(); pSb.AppendLine(); ParseNode(ifStatement.else_statement, pSb, pCreator); } pSb.Append("}"); pSb.AppendLine(); pSb.AppendLine(); }
private static void parseForeachStatement(CsStatement pStatement, CodeBuilder pSb, FactoryExpressionCreator pCreator) { CsForeachStatement fes = (CsForeachStatement)pStatement; Expression ex = pCreator.Parse(fes.expression); string type = As3Helpers.Convert(Helpers.GetType(fes.type)); pSb.AppendLine(); TheClass theClass = TheClassFactory.Get(ex.Type, pCreator); if (ex.Type.type == cs_entity_type.et_array || ex.IsAs3Generic || (theClass != null && @"System.Array".Equals(theClass.FullName))) {//foreach pSb.AppendFormat("for each(var {0}:{1} in {2}){{", fes.identifier.identifier, type, ex.Value); pSb.AppendLine(); } else if (ex.Type.type == cs_entity_type.et_object || ex.Type.type == cs_entity_type.et_generic_param || (theClass != null && @"flash.utils.Dictionary".Equals(theClass.FullName))) { pSb.AppendFormat("for (var {0}:{1} in {2}){{", fes.identifier.identifier, type, ex.Value); pSb.AppendLine(); if (ex.Type.type == cs_entity_type.et_object) { pSb.AppendFormat(" if (!{1}.hasOwnProperty({0})) continue;", fes.identifier.identifier, ex.Value ); } pSb.AppendLine(); } else { _enumCount++; //TheClass theClass = TheClassFactory.Get(fes.expression.entity_typeref); string enumName = String.Format(@"__ie{0}", _enumCount); pSb.AppendFormat("var {0}:IEnumerator = {1}.GetEnumerator();", enumName, ex.Value); pSb.AppendLine(); pSb.AppendFormat("while ({0}.MoveNext()){{", enumName); pSb.AppendLine(); pSb.AppendFormat("\tvar {1}:{2} = {0}.get_Current() as {2};", enumName, fes.identifier.identifier, type ); pSb.AppendLine(); } ParseNode(fes.statement, pSb, pCreator); pSb.AppendLine("}"); pSb.AppendLine(); }
private static void parseReturnStatement(CsStatement pStatement, CodeBuilder pSb, FactoryExpressionCreator pCreator) { CsReturnStatement returnStatement = (CsReturnStatement) pStatement; if (returnStatement.expression == null) { //pSb.AppendLine(InsideConstructor ? "return this" : InsideSetter ? "return value;" : "return;"); pSb.AppendLine(InsideSetter ? "return value;" : "return;"); } else { pSb.AppendFormat("return {0};", pCreator.Parse(returnStatement.expression).Value); pSb.AppendLine(); } }
private static void parseSwitchStatement(CsStatement pStatement, CodeBuilder pSb, FactoryExpressionCreator pCreator) { CsSwitchStatement switchStatement = (CsSwitchStatement)pStatement; pSb.AppendFormat("switch ({0}){{", pCreator.Parse(switchStatement.expression).Value); pSb.AppendLine(); pSb.Indent(); foreach (CsSwitchSection caseNode in switchStatement.sections) { LinkedList<CsSwitchLabel> labels = caseNode.labels; foreach (CsSwitchLabel label in labels){ if (label.default_label) { pSb.Append("default:"); pSb.AppendLine(); } else { Expression txt = pCreator.Parse(label.expression); pSb.AppendFormat("case {0}:", txt.Value); pSb.AppendLine(); } } foreach (CsStatement statementNode in caseNode.statements) { pSb.Indent(); parseStatement(statementNode, pSb, pCreator); pSb.Unindent(); } } pSb.Unindent(); pSb.Append("}"); pSb.AppendLine(); }