Exemple #1
0
        static void Main(string[] args)
        {
            // 코드 생성
            GEntry entry = new GEntry();

            GVariable var = new GVariable("valueA");
            GDefine   def = new GDefine(var);

            entry.Append(def);

            GEvent main     = new GEvent(new GCommand("this", "Loaded", typeof(void), GCommand.CommandType.Event));
            GSet   setValue = new GSet(var, new GNumberConst(5));

            main.Append(setValue);

            GIf ifCheck = new GIf(new GCompare(var, GCompare.ConditionType.GREATER_THEN, new GNumberConst(3)));

            ifCheck.Append(
                new GVoidCall(
                    new GCommand("Console", "WriteLine", typeof(void), GCommand.CommandType.Call),
                    new GObject[] { new GStringCat(new GStringConst("A"), new GConvertNumberToString(new GNumberConst(5))) }
                    )
                );

            main.Append(ifCheck);
            entry.Append(main);

            // 생성된 코드 컴파일
            string source     = entry.ToSource();
            string resultFile = Path.GetTempFileName();

            GCompiler        compile = new GCompiler(source);
            GCompilerResults result  = compile.Build(resultFile);

            Console.WriteLine(result.Source);

            // 코드 컴파일 결과 분석
            if (result.IsSuccess)
            {
                // 컴파일 성공
                // 컴파일된 시나리오 실행
                Console.WriteLine("컴파일 성공");
            }
            else
            {
                // 컴파일 실패
                // 컴파일 오류 출력
                foreach (CompilerError error in result.Results.Errors)
                {
                    Console.WriteLine("컴파일 오류 : " + error.Line + " - " + error.ErrorNumber + ":" + error.ErrorText);
                }
            }

            Console.ReadLine();
        }
        private void BtnCancel_Click(object sender, RoutedEventArgs e)
        {
            TextTitle.Clear();
            TextAuthor.Clear();
            TextSummary.Clear();

            preview   = null;
            manager   = null;
            extension = null;
            compiler  = null;

            StackResult.Visibility = Visibility.Collapsed;
            StackOpen.Visibility   = Visibility.Visible;
        }
Exemple #3
0
        private void StackOpen_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            var openDialog = new OpenFileDialog
            {
                Filter = "라이브러리 파일 (*.dll)|*.dll"
            };

            if (openDialog.ShowDialog() == false || !File.Exists(openDialog.FileName))
            {
                return;
            }

            try
            {
                GridLoading.Visibility = Visibility.Visible;

                Task.Run(() =>
                {
                    manager   = new ExtensionManager();
                    extension = manager.LoadExtension(openDialog.FileName);

                    if (extension.Commands.Count <= 0 && extension.Controls.Count <= 0)
                    {
                        MessageBox.Show("해당 파일에는 사용 가능한 블럭이 없습니다.\n올바른 확장 파일을 선택해주시기 바랍니다.", "오류", MessageBoxButton.OK, MessageBoxImage.Error);
                        return;
                    }

                    extension.Path = openDialog.FileName;

                    Dispatcher.Invoke(() =>
                    {
                        StackOpen.Visibility   = Visibility.Collapsed;
                        StackResult.Visibility = Visibility.Visible;
                        LabelResult.Content    = $"본 모듈은 {extension.Commands.Count}개의 블럭과 {extension.Controls.Count}개의 컨트롤을 포함하고 있습니다.";
                        GridLoading.Visibility = Visibility.Collapsed;
                    });

                    compiler = new GCompiler();
                    compiler.LoadReference(openDialog.FileName);
                });
            }
            catch (Exception ex)
            {
                MessageBox.Show("해당 파일은 불러올 수 없습니다.\n" + ex.Message, "오류", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
        private void StackOpen_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            OpenFileDialog openDialog = new OpenFileDialog
            {
                Filter = "라이브러리 파일 (*.dll)|*.dll"
            };

            if (openDialog.ShowDialog() == true)
            {
                if (File.Exists(openDialog.FileName))
                {
                    try
                    {
                        manager   = new ExtensionManager();
                        extension = manager.LoadExtension(openDialog.FileName);
                        if (extension.Commands.Count > 0 || extension.Controls.Count > 0)
                        {
                            extension.Path = openDialog.FileName;

                            StackOpen.Visibility   = Visibility.Collapsed;
                            StackResult.Visibility = Visibility.Visible;
                            LabelResult.Content    = $"본 모듈은 {extension.Commands.Count}개의 블럭과 {extension.Controls.Count}개의 컨트롤을 포함하고 있습니다.";

                            compiler = new GCompiler();
                            compiler.LoadReference(openDialog.FileName);
                        }
                        else
                        {
                            MessageBox.Show("해당 파일에는 사용 가능한 블럭이 없습니다.\n올바른 확장 파일을 선택해주시기 바랍니다.", "오류", MessageBoxButton.OK, MessageBoxImage.Error);
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show("해당 파일은 불러올 수 없습니다.\n" + ex.Message, "오류", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                }
            }
        }
Exemple #5
0
        public static void Create(string path, string title, string author, string summary, string output, GCompiler compiler)
        {
            var moduleName     = Path.GetFileName(path);
            var tempResultPath = Path.Combine(Path.GetTempPath(), $"{moduleName}_{DateTime.Now.Millisecond}");

            Directory.CreateDirectory(tempResultPath);
            File.Copy(path, Path.Combine(tempResultPath, moduleName), true);

            foreach (var dll in compiler.References)
            {
                if (File.Exists(dll))
                {
                    File.Copy(dll, Path.Combine(tempResultPath, Path.GetFileName(dll)), true);
                }
            }

            var ini = new INI(Path.Combine(tempResultPath, $"{Path.GetFileNameWithoutExtension(moduleName)}.ini"));

            ini.SetValue("General", "Title", title);
            ini.SetValue("General", "Author", author);
            ini.SetValue("General", "Summary", summary);
            ini.SetValue("Assembly", "File", $@"<%LOCAL%>\{moduleName}");

            var builder = new PackageBuilder
            {
                Title  = title,
                Author = author
            };

            builder.Add(tempResultPath);
            builder.Create(output);
        }
Exemple #6
0
        public void Save(string path, string designXML, GCompiler compiler)
        {
            string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);

            FileStream    stream = new FileStream(path, FileMode.Create);
            XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8)
            {
                Formatting  = Formatting.Indented,
                Indentation = 4
            };

            writer.WriteStartDocument();
            writer.WriteStartElement("Canvas");

            writer.WriteStartElement("Code");

            foreach (var block in Master.Children)
            {
                if (block is BaseBlock)
                {
                    writer.WriteStartElement("Blocks");
                    writer.WriteAttributeString("Position", (block as BaseBlock).Position.ToString());
                    (block as BaseBlock).SaveXML(writer);
                    writer.WriteEndElement();
                }
            }

            writer.WriteEndElement(); // End Code

            writer.WriteStartElement("Design");

            byte[] base64 = Encoding.UTF8.GetBytes(designXML);
            writer.WriteBase64(base64, 0, base64.Length);

            writer.WriteEndElement(); // End Design

            writer.WriteStartElement("Extension");

            foreach (string reference in compiler.LoadedReferences)
            {
                if (reference != null && reference.Length > 0 && File.Exists(reference))
                {
                    writer.WriteStartElement("Reference");
                    writer.WriteAttributeString("Path", reference.Replace(appData, "%APPDATA%"));
                    writer.WriteEndElement();
                }
            }

            foreach (string dependencies in compiler.Dependencies)
            {
                if (dependencies != null && dependencies.Length > 0 && Directory.Exists(dependencies))
                {
                    writer.WriteStartElement("Dependencies");
                    writer.WriteAttributeString("Path", dependencies.Replace(appData, "%APPDATA%"));
                    writer.WriteEndElement();
                }
            }

            writer.WriteEndElement(); // End Extension

            writer.WriteEndElement(); // End Canvas

            writer.WriteEndDocument();

            writer.Flush();
            stream.Close();
        }