示例#1
0
        /// <summary>
        /// フィールド類取得
        /// </summary>
        /// <param name="item">C#ソースを解析したインスタンス</param>
        /// <param name="index">インデックス数(半角スペース数)</param>
        /// <returns>TypeScriptのクラスフィールドに変換した文字列</returns>
        private string GetFieldDeclarationText(FieldDeclarationSyntax item, int index = 0)
        {
            var classObject = ClassObject.GetInstance();
            var variable    = item.Declaration.Variables[0];

            // 前処理の場合はメソッドチェックと格納のみ
            if (classObject.IsPreAnalyze)
            {
                if (item.Modifiers.Any(modifier => modifier.Kind() == SyntaxKind.StaticKeyword))
                {
                    classObject.AddStaticMember(variable.Identifier.ValueText);
                }
                return(string.Empty);
            }

            var result = new StringBuilder();

            //初期化処理を取得
            var defineAssignmentAssertion = string.Empty;
            var createInitializeValue     = classObject.GetCreateInitializeValue(item.Declaration.Type, variable.Initializer);

            if (string.IsNullOrEmpty(createInitializeValue))
            {
                // 初期化情報がない場合は限定代入アサーションを設定
                defineAssignmentAssertion = "!";
            }

            // キーワード設定
            var modifiers = new List <string>();

            modifiers.Add(GetModifierText(item.Modifiers));
            foreach (var modifer in item.Modifiers)
            {
                switch (modifer.Text)
                {
                case "const":
                    modifiers.Add("readonly");
                    break;

                case "static":
                    modifiers.Add("static");
                    break;
                }
            }

            result.Append(GetComments(item.GetLeadingTrivia().ToString()));
            result.Append($"{GetSpace(index)}{string.Join(' ',modifiers)} {variable.Identifier.ValueText}{defineAssignmentAssertion}: {classObject.GetTypeScriptType(item.Declaration.Type)}");

            // 初期化処理を設定
            result.Append(ReplaceMethodName(createInitializeValue));

            result.AppendLine(";");

            return(result.ToString());
        }
示例#2
0
        /// <summary>
        /// 解析処理
        /// </summary>
        /// <param name="targetCode">C#ソース</param>
        /// <returns>TypeScript情報</returns>
        public AnalyzeResult Analyze(SyntaxTree tree)
        {
            var classObject   = ClassObject.GetInstance();
            var analyzeResult = new AnalyzeResult();

            // クリア
            classObject.Clear();

            // 構文エラーチェック
            foreach (var item in tree.GetDiagnostics())
            {
                return(new AnalyzeResult());
            }

            // ルート取得
            var root = tree.GetRoot();

            // 前処理の場合はクラス名変更確認と格納
            if (classObject.IsPreAnalyze)
            {
                foreach (CSharpSyntaxNode item in root.DescendantNodes())
                {
                    if (item is ClassDeclarationSyntax cds)
                    {
                        if (cds.Parent is ClassDeclarationSyntax parentClass)
                        {
                            var renameClassName = parentClass.Identifier + "_" + cds.Identifier.ValueText;
                            var csClassName     = parentClass.Identifier + "." + cds.Identifier.ValueText;
                            classObject.RenameClasseNames.Add(csClassName, renameClassName);
                        }
                    }
                }
            }

            // ソース解析
            var result = new StringBuilder();

            foreach (CSharpSyntaxNode item in root.DescendantNodes())
            {
                switch (item.Kind())
                {
                case SyntaxKind.ClassDeclaration:
                    result.Append(GetItemText(item as ClassDeclarationSyntax));
                    break;
                }
            }

            // 戻り値用クラスインスタンスを作成
            analyzeResult.SourceCode = result.ToString();
            classObject.CopyUnknownReferences(ref analyzeResult);
            analyzeResult.ClassNames.AddRange(classObject.ClassNames);
            return(analyzeResult);
        }
示例#3
0
        /// <summary>
        /// 解析前処理
        /// </summary>
        /// <param name="csInfos">C#ファイル情報リスト</param>
        /// <remarks>クラス名変換とクラスメンバの格納</remarks>
        public void PreAnalyze(List <CSFileInfo> csInfos)
        {
            // ClassObjectインスタンス取得
            var classObject = ClassObject.GetInstance();

            // モードを前処理に設定
            classObject.IsPreAnalyze = true;

            // 解析によってクラス名変更とクラスメンバの格納を行う
            foreach (var csInfo in csInfos)
            {
                Analyze(csInfo.SourceCode);
            }
        }
示例#4
0
        /// <summary>
        /// クラス取得
        /// </summary>
        /// <param name="item">C#ソースを解析したインスタンス</param>
        /// <param name="index">インデックス数(半角スペース数)</param>
        /// <returns>TypeScriptのクラスに変換した文字列</returns>
        private string GetItemText(ClassDeclarationSyntax item, int index = 0)
        {
            var classObject = ClassObject.GetInstance();
            var result      = new StringBuilder();

            // TSメソッド管理クラス生成
            var MethodDataManager = new MethodDataManager();

            var className  = item.Identifier.ValueText;
            var superClass = string.Empty;

            if (item.BaseList != null)
            {
                superClass = $" extends {classObject.GetTypeScriptType(item.BaseList.Types[0].Type)}";
            }

            // 親クラスがある場合はクラス名に付加する
            if (item.Parent is ClassDeclarationSyntax parentClass)
            {
                className = parentClass.Identifier + "_" + className;
            }

            // クラスコメント追加
            result.Append(GetComments(item.GetLeadingTrivia().ToString(), string.Empty));

            // クラス定義追加
            result.AppendLine($"{GetSpace(index)}export class {className}{superClass} {item.OpenBraceToken.ValueText}");

            // クラス名を追加
            if (!classObject.ClassNames.Contains(className))
            {
                classObject.ClassNames.Add(className);
            }
            classObject.ProcessClassName = className;

            // インスタンス要素を格納
            foreach (var childItem in item.Members)
            {
                // インナークラスの場合は処理をしない
                if (childItem is ClassDeclarationSyntax)
                {
                    continue;
                }

                SyntaxTokenList?tokenList = null;
                switch (childItem)
                {
                case FieldDeclarationSyntax fieldDeclaration:
                    tokenList = fieldDeclaration.Modifiers;
                    break;

                case PropertyDeclarationSyntax prop:
                    tokenList = prop.Modifiers;
                    break;

                case BaseMethodDeclarationSyntax method:
                    if (!method.IsKind(SyntaxKind.ConstructorDeclaration))
                    {
                        tokenList = method.Modifiers;
                    }
                    break;
                }

                // インスタンス要素の場合は要素名を格納
                if (tokenList.HasValue)
                {
                    var targetName = childItem.DescendantTokens().Where(token => token.IsKind(SyntaxKind.IdentifierToken)).FirstOrDefault();
                    if (targetName != null && !tokenList.Value.Any(token => token.ValueText == "static"))
                    {
                        if (!classObject.InstanceMembers.Contains(targetName.ValueText))
                        {
                            classObject.InstanceMembers.Add(targetName.ValueText);
                        }
                    }
                }
            }

            // 子要素を設定
            foreach (var childItem in item.Members)
            {
                // インナークラスの場合は処理をしない
                if (childItem is ClassDeclarationSyntax)
                {
                    continue;
                }

                try
                {
                    switch (childItem)
                    {
                    case FieldDeclarationSyntax fieldDeclaration:
                        result.Append(GetFieldDeclarationText(fieldDeclaration, index + IndentSize));
                        break;

                    case PropertyDeclarationSyntax prop:
                        result.Append(GetPropertyText(prop, index + IndentSize));
                        break;

                    case BaseMethodDeclarationSyntax method:
                        var methodInstance = new Method();
                        var methodData     = methodInstance.GetMethodText(method, IsOutputMethod, index + IndentSize);
                        if (methodData != null)
                        {
                            MethodDataManager.AddMethodData(methodData);
                        }
                        break;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"[{ex.Message}]");
                    Console.WriteLine(childItem.ToString());
                }
            }

            // 前処理の場合は終了
            if (classObject.IsPreAnalyze)
            {
                return(string.Empty);
            }

            // メソッドを出力
            result.Append(MethodDataManager.GetMethodText());

            result.AppendLine($"{GetSpace(index)}{item.CloseBraceToken.ValueText}");
            return(result.ToString());
        }