private bool GenerateOutput()

in Common/Tools/BuildTasks/ExtractLambdasFromXaml.cs [246:380]
125 lines of code
13 McCabe index (conditional complexity)

        private bool GenerateOutput() {
            string shortClassName, classNamespace;
            int dot = className.LastIndexOf('.');
            if (dot >= 0) {
                classNamespace = className.Substring(0, dot);
                shortClassName = className.Substring(dot + 1);
            } else {
                classNamespace = null;
                shortClassName = className;
            }

            bool isPrivate = false;
            if (classModifier != null) {
                string publicModifier = null, privateModifier = null;
                if (typeAttributesConverter != null && typeAttributesConverter.CanConvertTo(typeof(string))) {
                    try {
                        publicModifier = typeAttributesConverter.ConvertTo(TypeAttributes.Public, typeof(string)) as string;
                        privateModifier = typeAttributesConverter.ConvertTo(TypeAttributes.NotPublic, typeof(string)) as string;
                    } catch (NotSupportedException) {
                    }
                }

                if (string.Equals(classModifier, privateModifier, StringComparison.OrdinalIgnoreCase)) {
                    isPrivate = true;
                } else if (!string.Equals(classModifier, publicModifier, StringComparison.OrdinalIgnoreCase)) {
                    LogError(classModifierLineNumber, 1503, "Language '" + Language + "' does not support x:ClassModifier '" + classModifier + "'.");
                    return false;
                }
            }

            var unit = new CodeCompileUnit();

            var ns = new CodeNamespace(classNamespace);
            unit.Namespaces.Add(ns);
            foreach (string importName in importedNamespaces) {
                var import = new CodeNamespaceImport(importName);
                if (importedNamespacesLineNumber != 0) {
                    import.LinePragma = new CodeLinePragma(InputFileName.ItemSpec, importedNamespacesLineNumber);
                }
                ns.Imports.Add(import);
            }
            var type = new CodeTypeDeclaration {
                Name = shortClassName,
                IsPartial = true,
                BaseTypes = { typeof(ILambdaConverterProvider) }
            };
            ns.Types.Add(type);
            if (isPrivate) {
                type.TypeAttributes &= ~TypeAttributes.Public;
            }

            var method = new CodeMemberMethod {
                Name = "GetConverterForLambda",
                PrivateImplementationType = new CodeTypeReference(typeof(ILambdaConverterProvider)),
                ReturnType = new CodeTypeReference(typeof(LambdaConverter)),
                Parameters =
                {   
                    new CodeParameterDeclarationExpression
                    {
                        Name = "lambda__",
                        Type = new CodeTypeReference(typeof(string))
                    }
                },
                CustomAttributes =
                {
                    new CodeAttributeDeclaration(new CodeTypeReference(typeof(GeneratedCodeAttribute)))
                    {
                        Arguments = 
                        {
                            new CodeAttributeArgument(new CodePrimitiveExpression(ToolName)),
                            new CodeAttributeArgument(new CodePrimitiveExpression(typeof(ExtractLambdasFromXaml).Assembly.GetName().Version.ToString()))
                        }
                    }
                }
            };
            type.Members.Add(method);

            foreach (var lambda in lambdas) {
                var cond = new CodeConditionStatement {
                    Condition = new CodeBinaryOperatorExpression {
                        Operator = CodeBinaryOperatorType.ValueEquality,
                        Left = new CodeArgumentReferenceExpression("lambda__"),
                        Right = new CodePrimitiveExpression(lambda.Code)
                    },
                    TrueStatements =
                    {
                        new CodeMethodReturnStatement
                        {
                            Expression = new CodeMethodInvokeExpression
                            {
                                Method = new CodeMethodReferenceExpression
                                {
                                    TargetObject = new CodeTypeReferenceExpression(typeof(LambdaConverter)),
                                    MethodName = "Create"
                                },
                                Parameters =
                                {
                                    new CodeSnippetExpression(lambda.Code)
                                }
                            },
                            LinePragma = new CodeLinePragma
                            {
                                FileName = InputFileName.ItemSpec,
                                LineNumber = lambda.LineNumber
                            }
                        }
                    }
                };

                method.Statements.Add(cond);
            }

            method.Statements.Add(
                new CodeThrowExceptionStatement {
                    ToThrow = new CodeObjectCreateExpression {
                        CreateType = new CodeTypeReference(typeof(ArgumentOutOfRangeException)),
                        Parameters =
                        {
                            new CodePrimitiveExpression("lambda__")
                        }
                    }
                });

            try {
                using (var writer = File.CreateText(OutputFileName.ItemSpec)) {
                    var options = new CodeGeneratorOptions();
                    codeDomProvider.GenerateCodeFromCompileUnit(unit, writer, options);
                }
            } catch (IOException ex) {
                LogError(2002, ex.Message);
                return false;
            }

            return true;
        }