Пример #1
0
        private void GenerateFrameCode(AstFrame frameInfo)
        {
            Progress.Enabled = true;
            var progressId = this.ReportStart(
                "Generating code files for frame " + frameInfo.AccessName
                );

            CurrentFrame = frameInfo;

            CurrentFrameName = GetSymbolTargetName(CurrentFrame);

            CodeFilesComposer.DownFolder(CurrentFrameName);


            GenerateBladeFiles();

            GenerateVectorFiles();

            GenerateFctoredBladeFiles();

            GenerateOutermorphismFiles();


            CodeFilesComposer.UpFolder();

            Progress.Enabled = true;
            this.ReportFinish(progressId);
        }
Пример #2
0
        private void GenerateFrameCode(AstFrame frameInfo)
        {
            Progress.Enabled = true;
            var progressId = this.ReportStart(
                "Generating code files for frame " + frameInfo.AccessName
                );

            CurrentFrame = frameInfo;

            CurrentFrameName = GetSymbolTargetName(CurrentFrame);

            CodeFilesComposer.DownFolder(CurrentFrameName);


            InitializeMultivectorClassesData();

            GenerateBaseMvClassFile();

            foreach (var classData in MultivectorClassesData.Values)
            {
                GenerateDerivedMvClassFiles(classData);
            }

            //GenerateFctoredBladeFiles();

            //GenerateOutermorphismFiles();


            CodeFilesComposer.UpFolder();

            Progress.Enabled = true;
            this.ReportFinish(progressId);
        }
Пример #3
0
        private void GenerateFactorFiles()
        {
            var gmacStructInfo = AddFactorGMacStructure();

            if (gmacStructInfo.IsNullOrInvalid())
            {
                return;
            }

            var factorMacroList = AddFactorGMacMacros();

            if (factorMacroList.Any(s => s.IsNullOrInvalid()))
            {
                return;
            }

            CodeFilesComposer.InitalizeFile("Factor.cs");

            var fileGen = new FactorMainMethodsFileGenerator(this);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();

            for (var inGrade = 2; inGrade <= CurrentFrame.VSpaceDimension; inGrade++)
            {
                for (var inIndex = 0; inIndex < CurrentFrame.KvSpaceDimension(inGrade); inIndex++)
                {
                    var inId = CurrentFrame.BasisBladeId(inGrade, inIndex);

                    GenerateFactorMethod(inGrade, inId, factorMacroList[inGrade - 2]);
                }
            }
        }
Пример #4
0
        private void GenerateFrameCode(AstFrame frameInfo)
        {
            CodeFilesComposer.InitalizeFile(frameInfo.Name + ".cs", GenerateCodeFileStartCode);

            ActiveFileTextComposer.AppendLineAtNewLine(@"public static class " + frameInfo.Name);
            ActiveFileTextComposer.AppendLineAtNewLine("{");
            ActiveFileTextComposer.IncreaseIndentation();

            GenerateFrameMultivectorCode(frameInfo.FrameMultivector);

            ActiveFileTextComposer.AppendLineAtNewLine();

            foreach (var constantInfo in frameInfo.Constants)
            {
                GenerateConstantCode(constantInfo);
            }

            foreach (var macroInfo in frameInfo.Macros)
            {
                GenerateMacroCode(macroInfo);
            }

            ActiveFileTextComposer.DecreaseIndentation();
            ActiveFileTextComposer.AppendLineAtNewLine("}");

            CodeFilesComposer.UnselectActiveFile(GenerateCodeFileEndCode);
        }
Пример #5
0
        /// <summary>
        /// Performs text files generation based on the given AST information.
        /// This method calls InitializeGenerator(), composeTextFilesAction(), then FinalizeGenerator().
        /// </summary>
        /// <param name="composeTextFilesAction"></param>
        public void Generate(Action composeTextFilesAction)
        {
            if (this.SetProgressRunning() == false)
            {
                return;
            }

            if (VerifyReadyToGenerate() == false)
            {
                this.SetProgressNotRunning();

                return;
            }

            InitializeGenerator();

            try
            {
                composeTextFilesAction();
            }
            catch (OperationCanceledException e)
            {
                this.ReportError(e);
            }
            finally
            {
                CodeFilesComposer.FinalizeAllFiles();

                FinalizeGenerator();

                this.SetProgressNotRunning();
            }
        }
Пример #6
0
        private void GenerateBaseMvClassFile()
        {
            CodeFilesComposer.InitalizeFile(CurrentFrameName + "Multivector.cs");

            BaseMvClassFileGenerator.Generate(this);

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #7
0
        private void GenerateBladeInvolutionMethodsFile()
        {
            CodeFilesComposer.InitalizeFile("Involutions.cs");

            var fileGen = new InvolutionMethodsFileGenerator(this);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #8
0
        private void GenerateBladeStaticUtilsFile()
        {
            CodeFilesComposer.InitalizeFile(CurrentFrameName + "BladeUtils.cs");

            var fileGen = new StaticCodeFileGenerator(this);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #9
0
        private void GenerateBladeMiscMethodsFile()
        {
            CodeFilesComposer.InitalizeFile("Misc.cs");

            var fileGen = new MiscMethodsFileGenerator(this);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #10
0
        private void GenerateFctoredBladeClassFile()
        {
            CodeFilesComposer.InitalizeFile(CurrentFrameName + "FactoredBlade.cs");

            var fileGen = new FactoredBladeClass.ClassFileGenerator(this);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #11
0
        private void GenerateOutermorphismClassFile()
        {
            CodeFilesComposer.InitalizeFile(CurrentFrameName + "Outermorphism.cs");

            var fileGen = new OutermorphismClass.ClassFileGenerator(this);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #12
0
        private void GenerateApplyVersorMainMethod(string opName)
        {
            CodeFilesComposer.InitalizeFile(opName + ".cs");

            var fileGen = new ApplyVersorMainMethodFileGenerator(this, opName);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #13
0
        private void GenerateVectorClassFile()
        {
            CodeFilesComposer.InitalizeFile(CurrentFrameName + "Vector.cs");

            var fileGen = new VectorClass.ClassFileGenerator(this);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #14
0
        private void GenerateOutermorphismApplyMethodFile(int inGrade)
        {
            CodeFilesComposer.InitalizeFile("Apply_" + inGrade + ".cs");

            var fileGen = new ApplyMethodFileGenerator(this, inGrade);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #15
0
        private void GenerateSelfEuclideanGeometricProductFile()
        {
            const string opName = DefaultMacro.EuclideanUnary.SelfGeometricProduct;

            CodeFilesComposer.InitalizeFile(opName + ".cs");

            var codeGen = new SelfEgpMethodsFileGenerator(this, opName);

            codeGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #16
0
        private void GenerateDeltaProductDualFile()
        {
            const string opName = "DPDual";

            CodeFilesComposer.InitalizeFile(opName + ".cs");

            var codeGen = new DpDualMethodsFileGenerator(this, opName);

            codeGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #17
0
        private void GenerateVectorFiles()
        {
            int progressId = this.ReportStart(
                "Generating Vector class code files for frame " + CurrentFrame.AccessName
                );

            CodeFilesComposer.DownFolder("Vector");

            GenerateVectorClassFile();

            CodeFilesComposer.UpFolder();

            this.ReportFinish(progressId);
        }
Пример #18
0
        private void GenerateFactorMethod(int inGrade, int inId, AstMacro gmacMacroInfo)
        {
            CodeFilesComposer.DownFolder("Factor");

            CodeFilesComposer.InitalizeFile("Factor" + inId + ".cs");

            var fileGen = new FactorMethodFileGenerator(this, inGrade, inId, gmacMacroInfo);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();

            CodeFilesComposer.UpFolder();
        }
Пример #19
0
        private void GenerateFctoredBladeFiles()
        {
            var progressId = this.ReportStart(
                "Generating FactoredBlade class code files for frame " + CurrentFrame.AccessName
                );

            CodeFilesComposer.DownFolder("FactoredBlade");

            GenerateFctoredBladeClassFile();

            CodeFilesComposer.UpFolder();

            this.ReportFinish(progressId);
        }
Пример #20
0
        private void GenerateBladeClassFile()
        {
            CodeFilesComposer.InitalizeFile(CurrentFrameName + "Blade.cs");

            var fileGen = new BladeClass.ClassFileGenerator(this);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();

            //Note: You can use this method instead to finalize, save, free memory,
            //and unselect the active file composer in one step during code generation
            //when the you are done with the file:
            //CodeFilesComposer.SaveActiveFile();
        }
Пример #21
0
        private void GenerateBilinearProductMainMethodFile(string opName, string zeroCondition, Func <int, int, int> getFinalGrade, Func <int, int, bool> isLegalGrade)
        {
            CodeFilesComposer.InitalizeFile(opName + ".cs");

            var fileGen =
                new BilinearProductMainMethodFileGenerator(
                    this,
                    opName,
                    zeroCondition,
                    getFinalGrade,
                    isLegalGrade
                    );

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #22
0
        protected override void ComposeTextFiles()
        {
            CodeFilesComposer.InitalizeFile(MacroBinding.BaseMacro.Name + ".cs");

            var codeBlock = GenerateMacroCode(MacroBinding);

            CodeFilesComposer.UnselectActiveFile();


            Graph = codeBlock.ToGraphViz();

            var progressId = this.ReportStart("Generate GraphViz Code");

            Graph.GenerateDotCode();

            this.ReportFinish(progressId);
        }
Пример #23
0
        private void GenerateVectorsOuterProductFile()
        {
            var macroInfo = AddVectorsOuterProductGMacMacro();

            if (macroInfo.IsNullOrInvalid())
            {
                return;
            }

            CodeFilesComposer.InitalizeFile("VectorsOP.cs");

            var fileGen = new VectorsOpMethodsFileGenerator(this, macroInfo);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #24
0
        protected override void ComposeTextFiles()
        {
            var framesList = SelectedSymbols.Cast <AstFrame>();

            CodeFilesComposer.DownFolder("GMacDSL");

            foreach (var frame in framesList)
            {
                CodeFilesComposer.InitalizeFile("frame_" + GetSymbolTargetName(frame) + ".gmac");

                GenerateFrameCode(frame);

                CodeFilesComposer.UnselectActiveFile();
            }

            CodeFilesComposer.UpFolder();
        }
Пример #25
0
        private void GenerateNamespaceCode(AstNamespace namespaceInfo)
        {
            _currentNamespace = namespaceInfo;

            CodeFilesComposer.DownFolder(namespaceInfo.Name);

            CodeFilesComposer.InitalizeFile(namespaceInfo.Name + "Utils.cs", GenerateCodeFileStartCode);

            ActiveFileTextComposer.AppendLineAtNewLine(@"public static class " + namespaceInfo.Name + "Utils");
            ActiveFileTextComposer.AppendLineAtNewLine("{");
            ActiveFileTextComposer.IncreaseIndentation();

            foreach (var constantInfo in namespaceInfo.ChildConstants)
            {
                GenerateConstantCode(constantInfo);
            }

            foreach (var macroInfo in namespaceInfo.ChildMacros)
            {
                GenerateMacroCode(macroInfo);
            }

            ActiveFileTextComposer.DecreaseIndentation();
            ActiveFileTextComposer.AppendLineAtNewLine("}");

            CodeFilesComposer.UnselectActiveFile(GenerateCodeFileEndCode);

            foreach (var frameInfo in namespaceInfo.ChildFrames)
            {
                GenerateFrameCode(frameInfo);
            }

            foreach (var structureInfo in namespaceInfo.ChildStructures)
            {
                GenerateStructureCode(structureInfo);
            }

            foreach (var childNamespaceInfo in namespaceInfo.ChildNamespaces)
            {
                GenerateNamespaceCode(childNamespaceInfo);
            }

            CodeFilesComposer.UpFolder();
        }
Пример #26
0
        private void GenerateStructureCode(AstStructure structureInfo)
        {
            CodeFilesComposer.InitalizeFile(structureInfo.Name + ".cs", GenerateCodeFileStartCode);

            ActiveFileTextComposer.AppendAtNewLine(@"public sealed class ");
            ActiveFileTextComposer.AppendLine(structureInfo.Name);
            ActiveFileTextComposer.AppendLineAtNewLine("{");
            ActiveFileTextComposer.IncreaseIndentation();

            foreach (var memberInfo in structureInfo.DataMembers)
            {
                ActiveFileTextComposer.AppendAtNewLine("public ");
                GenerateTypeName(memberInfo.GMacType);
                ActiveFileTextComposer.Append(" ");
                ActiveFileTextComposer.Append(memberInfo.Name);
                ActiveFileTextComposer.AppendLine(" { get; set; }");
                ActiveFileTextComposer.AppendLine();
            }

            ActiveFileTextComposer.AppendLine();

            ActiveFileTextComposer.AppendAtNewLine("public ");
            ActiveFileTextComposer.Append(structureInfo.Name);
            ActiveFileTextComposer.AppendLine("()");
            ActiveFileTextComposer.Append("{");
            ActiveFileTextComposer.IncreaseIndentation();

            foreach (var memberInfo in structureInfo.DataMembers.Where(memberInfo => !memberInfo.GMacType.IsValidPrimitiveType))
            {
                ActiveFileTextComposer.AppendAtNewLine(memberInfo.Name);
                ActiveFileTextComposer.Append(" = ");
                GenerateTypeDefaultValue(memberInfo.GMacType);
                ActiveFileTextComposer.AppendLine(";");
            }

            ActiveFileTextComposer.DecreaseIndentation();
            ActiveFileTextComposer.Append("}");

            ActiveFileTextComposer.DecreaseIndentation();
            ActiveFileTextComposer.AppendLineAtNewLine("}");

            CodeFilesComposer.UnselectActiveFile(GenerateCodeFileEndCode);
        }
Пример #27
0
        private void GenerateBladeNormMethodsFile()
        {
            var operatorNames = new[]
            {
                DefaultMacro.MetricUnary.NormSquared,
                DefaultMacro.MetricUnary.Magnitude,
                DefaultMacro.MetricUnary.MagnitudeSquared,
                DefaultMacro.EuclideanUnary.Magnitude,
                DefaultMacro.EuclideanUnary.MagnitudeSquared
            };

            CodeFilesComposer.InitalizeFile("Norms.cs");

            var fileGen = new NormMethodsFileGenerator(this, operatorNames);

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();
        }
Пример #28
0
        /// <summary>
        /// Initializes the text file generation process. This method must be called before
        /// any generation process
        /// </summary>
        protected void InitializeGenerator()
        {
            //Call initialize templates if needed
            if (TemplatesReady == false)
            {
                TemplatesReady = InitializeTemplates();
            }

            //For each template, clear all parameters bindings
            foreach (var template in Templates.Values)
            {
                template.ClearBindings();
            }

            //Clear the contents of the files composer
            CodeFilesComposer.Clear();

            //Initialize any other components of a generator sub-class inherited from this one
            InitializeOtherComponents();
        }
Пример #29
0
        private void GenerateApplyVersorFunction(string opName, string funcName, int inGrade1, int inGrade2, int outGrade)
        {
            CodeFilesComposer.DownFolder(opName);

            CodeFilesComposer.InitalizeFile(funcName + ".cs");

            var fileGen = new ApplyVersorMethodFileGenerator(
                this,
                opName,
                funcName,
                inGrade1,
                inGrade2,
                outGrade
                );

            fileGen.Generate();

            CodeFilesComposer.UnselectActiveFile();

            CodeFilesComposer.UpFolder();
        }
Пример #30
0
        private void GenerateDerivedMvClassFiles(MvClassData classData)
        {
            CodeFilesComposer.DownFolder(classData.ClassName);

            CodeFilesComposer.InitalizeFile(classData.ClassName + ".cs");

            DerivedMvClassFileGenerator.Generate(this, classData);

            CodeFilesComposer.UnselectActiveFile();

            foreach (var classData2 in MultivectorClassesData.Values)
            {
                CodeFilesComposer.InitalizeFile(classData.ClassName + "Calc" + classData2.ClassId + ".cs");

                DerivedMvClassCalcFileGenerator.Generate(this, classData, classData2);

                CodeFilesComposer.UnselectActiveFile();
            }

            CodeFilesComposer.UpFolder();
        }