コード例 #1
0
 /// <summary>
 /// コンストラクタ。
 /// </summary>
 /// <param name="message">メッセージプロバイダのインスタンス。</param>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 public AccessorDefinitionValidator(
     MessageProvider message,
     WarlockProject project)
     : base(message)
 {
     Project = project;
 }
コード例 #2
0
ファイル: ProjectValidator.cs プロジェクト: RaTTiE/Warlock
 /// <summary>
 /// コンストラクタ。
 /// </summary>
 /// <param name="message">メッセージプロバイダのインスタンス。</param>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 public ProjectValidator(
     MessageProvider message,
     WarlockProject project)
     : base(message)
 {
     Project = project;
 }
コード例 #3
0
ファイル: ProjectTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// コンストラクタ。
        /// </summary>
        /// <param name="node">プロジェクトノードのインスタンス。</param>
        public ProjectProperty(ProjectTreeNode node)
            : base(node)
        {
            Project = (WarlockProject)node.Tag;

            Name = Project.Name;
            ProjectFileName = Path.GetFileName(Project.FileName);
        }
コード例 #4
0
 /// <summary>
 /// コンストラクタ。
 /// </summary>
 /// <param name="message">メッセージプロバイダのインスタンス。</param>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 /// <param name="definition">スクリプト定義情報のインスタンス。</param>
 public ScriptDefinitionValidator(
     MessageProvider message,
     WarlockProject project,
     ScriptDefinition definition)
     : base(message)
 {
     Project = project;
     Definition = definition;
 }
コード例 #5
0
        /// <summary>
        /// ツリービューをリフレッシュする。
        /// </summary>
        /// <param name="objectDefinitions">オブジェクト定義の一覧。</param>
        /// <param name="objectDefinitionMap">オブジェクト定義のマップ。</param>
        public void RefreshTreeView(WarlockProject project)
        {
            ctlTreeView.Nodes.Clear();

            if (project == null) return;
            if (project.ObjectDefinitions == null) return;

            foreach (var definition in project.ObjectDefinitions)
            {
                ctlTreeView.Nodes.Add(RubyTreeNode.Create(definition, project.ObjectDefinitionMap));
            }
        }
コード例 #6
0
ファイル: ClassRootTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// ノードを生成する。
        /// </summary>
        /// <param name="definitions">クラス定義のList。</param>
        /// <returns>生成したツリーノード。</returns>
        public static ClassRootTreeNode Create(WarlockProject project)
        {
            var ret = new ClassRootTreeNode()
            {
                Text = "クラス定義"
            };

            ret.ImageKey = "ClassRootIcon.ico";
            ret.SelectedImageKey = ret.ImageKey;
            ret.Tag = project;

            ret.Refresh(project.ClassDefinitions);

            return ret;
        }
コード例 #7
0
ファイル: ScriptRootTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// ノードを生成する。
        /// </summary>
        /// <param name="project">スクリプト定義のList。</param>
        /// <returns>生成したツリーノード。</returns>
        public static ScriptRootTreeNode Create(WarlockProject project)
        {
            var ret = new ScriptRootTreeNode()
            {
                Text = "スクリプト"
            };

            ret.ImageKey = "ScriptRootIcon.ico";
            ret.SelectedImageKey = ret.ImageKey;
            ret.Tag = project;

            ret.Refresh(project.ScriptDefinitions);

            return ret;
        }
コード例 #8
0
        /// <summary>
        /// ノードを生成する。
        /// </summary>
        /// <param name="definitions">データベース定義のList。</param>
        /// <returns>生成したツリーノード。</returns>
        public static DatabaseRootTreeNode Create(WarlockProject project)
        {
            var ret = new DatabaseRootTreeNode()
            {
                Text = "データベース"
            };

            ret.ImageKey = "DatabaseRootIcon.ico";
            ret.SelectedImageKey = ret.ImageKey;
            ret.Tag = project;

            ret.Refresh(project.DatabaseDefinitions);

            return ret;
        }
コード例 #9
0
ファイル: DatabaseTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// コンストラクタ。
        /// </summary>
        /// <param name="node">データベースノードのインスタンス。</param>
        public DatabaseProperty(DatabaseTreeNode node)
            : base(node)
        {
            Definition = (DatabaseDefinition)node.Tag;

            Name = Definition.Name;

            Func<TreeNode, ProjectTreeNode> recursive = null;
            recursive = (parent) =>
            {
                if (parent == null) return null;

                if (parent is ProjectTreeNode) return (ProjectTreeNode)parent;
                return recursive(parent.Parent);
            };

            Project = (WarlockProject)recursive(node).Tag;

            try
            {
                var data = Project.LoadDatabase(Definition);

                if (data is DatabaseClassData)
                {
                    _DataCount = 1;
                }
                else if (data is List<dynamic>)
                {
                    _DataCount = (
                        from d in (List<dynamic>)data
                        where d != null
                        select d
                    ).Count();
                }
                else if (data is Dictionary<dynamic, dynamic>)
                {
                    _DataCount = (
                        from d in (Dictionary<dynamic, dynamic>)data
                        where d.Value != null
                        select d
                    ).Count();
                }
            }
            catch (Exception) { }
        }
コード例 #10
0
        /// <summary>
        /// データベースアイテムのリストを作成する。
        /// </summary>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        /// <param name="file">データベースファイル名。</param>
        /// <returns>データベースアイテムのリスト。</returns>
        public static List<ListItem> CreateDatabaseItemList(
            WarlockProject project,
            string file)
        {
            try
            {
                var itemDefinition = project.FindDatabaseDefinition(file);
                if (itemDefinition == null)
                {
                    return new List<ListItem>();
                }
                List<dynamic> items = project.LoadDatabase(itemDefinition);

                var ret = new List<ListItem>();

                foreach (var i in items)
                {
                    DatabaseClassData item = i;
                    if (item == null) continue;

                    ret.Add(new ListItem()
                    {
                        Text = String.Format(
                            String.Format(
                                "{{0:{0}}}:{{1}}",
                                new String('0', (items.Count - 1).ToString().Length)
                            ),
                            item.Variables["id"],
                            item.Variables["name"]
                        ),
                        Value = item.Variables["id"]
                    });
                }

                return ret;
            }
            catch
            {
                return new List<ListItem>();
            }
        }
コード例 #11
0
ファイル: ScriptTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// コンストラクタ。
        /// </summary>
        /// <param name="node">スクリプトノードのインスタンス。</param>
        public ScriptPropartyBase(ScriptTreeNode node)
            : base(node)
        {
            Definition = (ScriptDefinition)node.Tag;

            Name = Definition.DisplayName;

            Func<TreeNode, ProjectTreeNode> recursive = null;
            recursive = (parent) =>
            {
                if (parent == null) return null;

                if (parent is ProjectTreeNode) return (ProjectTreeNode)parent;
                return recursive(parent.Parent);
            };

            var projectNode = recursive(node);
            if (projectNode != null)
            {
                Project = (WarlockProject)projectNode.Tag;
            }
        }
コード例 #12
0
ファイル: ScriptTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// ノードのドロップ処理を行う。
        /// </summary>
        /// <param name="dragNode">ドラッグ対象のツリーノード。</param>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        public override void Drop(WarlockTreeNode dragNode, WarlockProject project)
        {
            var scriptNode = (ScriptTreeNode)dragNode;
            var dragDefinition = (ScriptDefinition)scriptNode.Tag;
            var dropDefinition = (ScriptDefinition)this.Tag;
            var dragParentNode = scriptNode.Parent;
            var dropParentNode = this.Parent;

            scriptNode.Remove();
            List<ScriptDefinition> dragParentList;
            if (dragParentNode is ScriptRootTreeNode)
            {
                dragParentList = project.ScriptDefinitions;
            }
            else if (dragParentNode is ScriptTreeNode)
            {
                var parentDefinition = (ScriptDefinition)dragParentNode.Tag;
                dragParentList = parentDefinition.Children;
            }
            else
            {
                throw new NotImplementedException();
            }

            dragParentList.Remove(dragDefinition);

            if (dropDefinition.IsFolder)
            {
                dropDefinition.Children.Add(dragDefinition);
                this.Nodes.Add(scriptNode);

                if (!this.IsExpanded) this.Expand();
            }
            else
            {
                List<ScriptDefinition> dropParentList;
                if (dropParentNode is ScriptRootTreeNode)
                {
                    dropParentList = project.ScriptDefinitions;
                }
                else if (dropParentNode is ScriptTreeNode)
                {
                    var parentDefinition = (ScriptDefinition)dropParentNode.Tag;
                    dropParentList = parentDefinition.Children;
                }
                else
                {
                    throw new NotImplementedException();
                }

                int i = 0;
                for (i = 0; i < dropParentList.Count - 1; i++)
                {
                    if (dropParentList[i] == dropDefinition) break;
                }

                dropParentList.Insert(i, dragDefinition);
                dropParentNode.Nodes.Insert(i, scriptNode);
            }
        }
コード例 #13
0
        /// <summary>
        /// プロジェクトを新規作成する。
        /// </summary>
        /// <param name="fileName">新規作成するプロジェクトのファイル名。</param>
        private void CreateProject(string fileName)
        {
            try
            {
                if (!CloseProject()) return;
                Console.Clear();

                Project = new WarlockProject()
                {
                    FileName = fileName
                };

                Project.Initialize(Console, Settings.Default.AdvancedMode);
                Project.Save();

                AddRecentPath(fileName);

                OnChangeProject();
                ShowProjectProperty();
            }
            catch (Exception ex)
            {
                ProvideMessage("Default.Exception.Error", "プロジェクトの新規作成", ex.Message);

                return;
            }
        }
コード例 #14
0
ファイル: WarlockProject.cs プロジェクト: RaTTiE/Warlock-core
        /// <summary>
        /// XMLNodeをデータにデシリアライズする。
        /// </summary>
        /// <param name="node">復号対象のXMLノード。</param>
        public static WarlockProject DeserializeElement(XmlElement node)
        {
            if (node.Name != "WarlockProject")
            {
                throw new FormatException("ルートノードではありません。");
            }

            var ret = new WarlockProject();

            XmlAttribute attr = null;

            attr = node.Attributes["Type"];
            if (attr == null) throw new FormatException("プロジェクトタイプが見つかりません。");

            try
            {
                ret.ProjectType = EnumExtentions.GetDeserializedValue<WarlockProjectType>(attr.Value);
            }
            catch (InvalidCastException)
            {
                throw new FormatException("不正なプロジェクトタイプです。");
            }

            foreach (XmlNode child in node.ChildNodes)
            {
                var childElement = child as XmlElement;
                if (childElement == null) continue;

                switch (childElement.Name)
                {
                    case "Name":
                        ret.Name = childElement.InnerText;

                        break;
                    case "ScriptFileName":
                        ret.ScriptFileName = childElement.InnerText;

                        break;
                    case "DataFolderPath":
                        ret.DataFolderPath = childElement.InnerText;

                        break;
                    case "ScriptFolderPath":
                        ret.ScriptFolderPath = childElement.InnerText;

                        break;
                    case "Classes":
                        foreach (XmlNode gChild in childElement.ChildNodes)
                        {
                            var gChildElement = gChild as XmlElement;
                            if (gChildElement == null) continue;

                            ret.ClassDefinitions.Add(ClassDefinition.DeserializeElement(gChildElement));
                        }

                        break;
                    case "Databases":
                        foreach (XmlNode gChild in childElement.ChildNodes)
                        {
                            var gChildElement = gChild as XmlElement;
                            if (gChildElement == null) continue;

                            ret.DatabaseDefinitions.Add(DatabaseDefinition.DeserializeElement(gChildElement));
                        }

                        break;
                    case "Scripts":
                        foreach (XmlNode gChild in childElement.ChildNodes)
                        {
                            var gChildElement = gChild as XmlElement;
                            if (gChildElement == null) continue;

                            ret.ScriptDefinitions.Add(ScriptDefinition.DeserializeElement(gChildElement));
                        }

                        break;
                    default:
                        throw new FormatException("未定義のエレメントを検出しました。");
                }
            }

            return ret;
        }
コード例 #15
0
ファイル: ScriptRootTreeNode.cs プロジェクト: RaTTiE/Warlock
 /// <summary>
 /// コンストラクタ。
 /// </summary>
 /// <param name="node">スクリプトルートノードのインスタンス。</param>
 public ScriptRootProperty(ScriptRootTreeNode node)
     : base(node)
 {
     Project = (WarlockProject)node.Tag;
 }
コード例 #16
0
 /// <summary>
 /// ノードのドロップ処理を行う。
 /// </summary>
 /// <param name="dragNode">ドラッグ対象のツリーノード。</param>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 public virtual void Drop(
     WarlockTreeNode dragNode, 
     WarlockProject project)
 {
     throw new NotImplementedException();
 }
コード例 #17
0
 /// <summary>
 /// クラス定義をデータベース上で使用しているかチェックする。
 /// </summary>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 /// <returns>クラス定義をデータベース上で使用している場合はtrue。</returns>
 public bool IsUsingDatabase(WarlockProject project)
 {
     return FindUsingDatabase(project).Count > 0;
 }
コード例 #18
0
        /// <summary>
        /// 継承元のアクセサを含んだアクセサの一覧を取得する。
        /// </summary>
        /// <returns>継承元のアクセサを含んだアクセサの一覧。</returns>
        public List<AccessorDefinition> GetAllAccessors(WarlockProject project)
        {
            var ret = new List<AccessorDefinition>();

            foreach (var extendClass in GetExtendClasses(project))
            {
                if (extendClass is ClassDefinition)
                {
                    ret.AddRange(((ClassDefinition)extendClass).Accessors);
                }
            }

            return ret;
        }
コード例 #19
0
 /// <summary>
 /// 継承クラスの一覧を取得する。
 /// </summary>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 /// <returns>継承クラスの一覧。</returns>
 public List<dynamic> GetExtendClasses(WarlockProject project)
 {
     return ClassDefinition.GetExtendClasses(FullName, project);
 }
コード例 #20
0
        /// <summary>
        /// クラス定義を使用しているデータベース定義の一覧を取得する。
        /// </summary>
        /// <param name="project">プロジェクト定義のインスタンス。</param>
        /// <returns>クラス定義を使用しているデータベース定義の一覧。</returns>
        public List<DatabaseDefinition> FindUsingDatabase(WarlockProject project)
        {
            var ret = new List<DatabaseDefinition>();

            foreach (var database in project.DatabaseDefinitions)
            {
                if (database.FindUsingClass(project).Contains(this))
                {
                    ret.Add(database);
                }
            }

            return ret;
        }
コード例 #21
0
        /// <summary>
        /// クラス定義を使用中のクラス定義を取得する。
        /// </summary>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        /// <returns>クラス定義を使用中のクラス定義の一覧。</returns>
        public List<dynamic> FindUsingClass(WarlockProject project)
        {
            var ret = new List<dynamic>();

            var query = from d in project.DatabaseDefinitions
                        where d.DataClass == FullName
                        select d;

            foreach (var database in query)
            {
                ret.AddRange(database.FindUsingClass(project));
            }

            ret.Distinct();

            return ret;
        }
コード例 #22
0
        /// <summary>
        /// 継承クラスの一覧を取得する。
        /// </summary>
        /// <param name="fullName">クラスのフル名。</param>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        /// <returns>継承クラスの一覧。</returns>
        public static List<dynamic> GetExtendClasses(
            string fullName,
            WarlockProject project)
        {
            var ret = new List<dynamic>();

            Action<string> recursive = null; recursive = (name) =>
            {
                var classDefinition = project.FindClassDefinition(name);
                if (classDefinition != null)
                {
                    if (ret.Contains(classDefinition))
                    {
                        throw new InvalidOperationException("クラス定義の継承に循環参照が存在しています。");
                    }

                    ret.Add(classDefinition);

                    if (!String.IsNullOrEmpty(classDefinition.Extends))
                    {
                        recursive(classDefinition.Extends);
                    }

                    return;
                }

                RubyClassDefinition objectDefinition = null;
                if (project.ObjectDefinitionMap.ContainsKey(name))
                {
                    objectDefinition = project.ObjectDefinitionMap[name] as RubyClassDefinition;

                    if (objectDefinition != null)
                    {
                        ret.Add(objectDefinition);

                        if (!String.IsNullOrEmpty(objectDefinition.SuperClassName) && objectDefinition.SuperClassName != "Object")
                        {
                            recursive(objectDefinition.SuperClassName);
                        }

                        return;
                    }
                }
            };
            recursive(fullName);

            ret.Reverse();

            return ret;
        }
コード例 #23
0
ファイル: ProjectTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// ノードを生成する。
        /// </summary>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        /// <returns>生成したツリーノード。</returns>
        public static ProjectTreeNode Create(WarlockProject project)
        {
            var ret = new ProjectTreeNode();

            ret.SelectedImageKey = ret.ImageKey;
            ret.Refresh(project);

            if (project != null)
            {
                ret.Nodes.Add(ClassRootTreeNode.Create(project));
                ret.Nodes.Add(DatabaseRootTreeNode.Create(project));

                if (Settings.Default.AdvancedMode)
                {
                    ret.Nodes.Add(ScriptRootTreeNode.Create(project));
                }

                foreach (TreeNode node in ret.Nodes)
                {
                    node.Expand();
                }

                ret.Expand();
            }

            return ret;
        }
コード例 #24
0
 /// <summary>
 /// クラス定義をデータベース上で使用しているかチェックする。
 /// </summary>
 /// <param name="databaseDefinition">データベース定義のインスタンス。</param>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 /// <returns>クラス定義をデータベース上で使用している場合はtrue。</returns>
 public bool IsUsingDatabase(
     DatabaseDefinition databaseDefinition,
     WarlockProject project)
 {
     return FindUsingDatabase(project).Contains(databaseDefinition);
 }
コード例 #25
0
ファイル: ProjectTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// ノードにプロジェクト情報の内容を反映する。
        /// </summary>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        public void Refresh(WarlockProject project)
        {
            Tag = project;
            if (project != null)
            {
                Text = String.Format("{0}({1})", project.Name, project.FileName);
                ImageKey = "ProjectIcon.ico";
                Enabled = true;
            }
            else
            {
                Text = "プロジェクトがロードされていません";
                ImageKey = "NullIcon.ico";
                Enabled = false;
            }

            SelectedImageKey = ImageKey;
        }
コード例 #26
0
        /// <summary>
        /// クラス定義を他のクラスで使用しているかチェックする。
        /// </summary>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        /// <returns>クラス定義を他のクラス上で使用している場合はtrue。</returns>
        public bool IsUsingOtherClass(WarlockProject project)
        {
            foreach (var classDefinition in project.ClassDefinitions)
            {
                if (this.Equals(classDefinition)) continue;

                if (classDefinition.IsUsingClass(this, project)) return true;
            }

            return false;
        }
コード例 #27
0
ファイル: ScriptRootTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// ノードのドロップ処理を行う。
        /// </summary>
        /// <param name="dragNode">ドラッグ対象のツリーノード。</param>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        public override void Drop(WarlockTreeNode dragNode, WarlockProject project)
        {
            var scriptNode = (ScriptTreeNode)dragNode;
            var dragDefinition = (ScriptDefinition)scriptNode.Tag;

            scriptNode.Remove();
            project.ScriptDefinitions.Remove(dragDefinition);
            project.ScriptDefinitions.Add(dragDefinition);
            this.Nodes.Add(scriptNode);
            if (!this.IsExpanded) this.Expand();
        }
コード例 #28
0
ファイル: ClassTreeNode.cs プロジェクト: RaTTiE/Warlock
        /// <summary>
        /// ノードのドロップ処理を行う。
        /// </summary>
        /// <param name="dragNode">ドラッグ対象のツリーノード。</param>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        public override void Drop(WarlockTreeNode dragNode, WarlockProject project)
        {
            var classNode = (ClassTreeNode)dragNode;
            var dragDefinition = (ClassDefinition)classNode.Tag;
            var dropDefinition = (ClassDefinition)this.Tag;

            classNode.Remove();
            project.ClassDefinitions.Remove(dragDefinition);

            int i = 0;
            for (i = 0; i < project.ClassDefinitions.Count - 1; i++)
            {
                if (project.ClassDefinitions[i] == dropDefinition) break;
            }

            project.ClassDefinitions.Insert(i, dragDefinition);
            Parent.Nodes.Insert(i, classNode);
        }
コード例 #29
0
 /// <summary>
 /// クラス定義をクラス上で使用しているかチェックする。
 /// </summary>
 /// <param name="databaseDefinition">データベース定義のインスタンス。</param>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 /// <returns>クラス定義をクラス上で使用している場合はtrue。</returns>
 public bool IsUsingClass(
     ClassDefinition classDefinition,
     WarlockProject project)
 {
     return FindUsingClass(project).Contains(classDefinition);
 }
コード例 #30
0
ファイル: RubyHost.cs プロジェクト: RaTTiE/Warlock-core
        /// <summary>
        /// コンストラクタ。
        /// </summary>
        /// <param name="project">プロジェクト情報のインスタンス。</param>
        public RubyHost(WarlockProject project)
        {
            _Runtime = Ruby.CreateRuntime();

            _Errors = new List<WarlockErrorData>();
            _Engine = Runtime.GetEngine("rb");
            string rgssDefinition = null;

            // RGSS定義ソースの実行
            switch (project.ProjectType)
            {
                case WarlockProjectType.Xp:
                    rgssDefinition = "rpgxp.rb";

                    break;
                case WarlockProjectType.Vx:
                    rgssDefinition = "rpgvx.rb";

                    break;
                case WarlockProjectType.VxAce:
                    rgssDefinition = "rpgvxace.rb";

                    break;
            }

            if (!String.IsNullOrEmpty(rgssDefinition))
            {
                var rgssPath = Path.Combine(
                    Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
                    "RGSS",
                    rgssDefinition
                );

                if (File.Exists(rgssPath))
                {
                    var rgssSource = Engine.CreateScriptSourceFromFile(rgssPath);

                    rgssSource.Compile().Execute();
                }
            }

            // 例外からエラーを作成する匿名メソッド
            Func<dynamic, Exception, WarlockErrorData> convertError = (definition, ex) => {
                var ret = new WarlockErrorData()
                {
                    Type = WarlockErrorType.Error
                };

                ret.Message = ex.Message;
                if (definition is ScriptDefinition)
                {
                    ret.Target = ((ScriptDefinition)definition).DisplayName;
                }
                else if (definition is ClassDefinition)
                {
                    ret.Target = ((ClassDefinition)definition).FullName;
                }
                else
                {
                    return ret;
                }

                try
                {
                    if (ex.Data.Contains(typeof(InterpretedFrameInfo)))
                    {
                        InterpretedFrameInfo[] infos = (InterpretedFrameInfo[])ex.Data[typeof(InterpretedFrameInfo)];
                        DebugInfo info = (
                            from i in infos
                            where i.DebugInfo != null
                            select i.DebugInfo
                        ).FirstOrDefault();

                        if (info != null)
                        {
                            ret.Location = String.Format("{0}, {1}", info.StartLine, info.Index);
                        }
                    }
                }
                catch { }

                return ret;
            };

            foreach (var definition in project.GetAllScripts())
            {
                if (definition is ScriptDefinition)
                {
                    // インポートしたスクリプトを実行
                    var castedDefinition = (ScriptDefinition)definition;

                    if (!castedDefinition.ExecuteTarget) continue;

                    try
                    {
                        Engine.CreateScriptSourceFromFile(
                            Path.Combine(
                                project.ScriptFolderFullPath,
                                castedDefinition.FileName
                            ),
                            Encoding.UTF8
                        ).Compile().Execute();
                    }
                    catch (Exception ex)
                    {
                        _Errors.Add(convertError(castedDefinition, ex));
                    }
                }
                else if (definition is ClassDefinition)
                {
                    // クラス定義のクラスを実行
                    var castedDefinition = (ClassDefinition)definition;

                    try
                    {
                        Engine.Execute(castedDefinition.ToScript());
                    }
                    catch (Exception ex)
                    {
                        _Errors.Add(convertError(castedDefinition, ex));
                    }
                }
                else
                {
                    throw new NotImplementedException();
                }
            }
        }