/// <summary>
        /// Loads this object's property values from current project.
        /// </summary>
        protected override void BindProperties()
        {
            assemblyName     = ProjectMgr.GetProjectProperty(PropertyTag.AssemblyName.ToString(), true);
            defaultNamespace = ProjectMgr.GetProjectProperty(PropertyTag.DefaultNamespace.ToString(), true);

            string strTargetPlatform = ProjectMgr.GetProjectProperty(PropertyTag.TargetPlatform.ToString(), true);

            if (strTargetPlatform != null && strTargetPlatform.Length > 0)
            {
                try
                {
                    targetPlatform = (TargetPlatform)Enum.Parse(typeof(TargetPlatform), strTargetPlatform);
                }
                catch (ArgumentException) { /* TODO: Default value? */ }
            }
            string strDynOption = ProjectMgr.GetProjectProperty(PropertyTag.DynVarOption.ToString(), true);

            if (strDynOption != null && strDynOption.Length > 0)
            {
                try
                {
                    dynVarOption = (DynVarOption)Enum.Parse(typeof(DynVarOption), strDynOption);
                }
                catch (ArgumentException) { /* TODO: Default value? */ }
            }
        }
예제 #2
0
        public void checkProjectIcon()
        {
            string dynVarOption = GetProjectProperty(PropertyTag.DynVarOption.ToString());

            DynVarOption option = (DynVarOption)Enum.Parse(typeof(DynVarOption), dynVarOption);

            switch (option)
            {
            case DynVarOption.Managed:
                imageOffset = initOffset;
                break;

            case DynVarOption.EverythingStatic:
                imageOffset = initOffset + 1;
                break;

            case DynVarOption.EverythingDynamic:
                imageOffset = initOffset + 2;
                break;

            default:
                break;
            }


            this.ReDraw(UIHierarchyElement.Icon);
        }
예제 #3
0
        public DynVarOption getDynamismMode()
        {
            string       dynVarOption = GetProjectProperty(PropertyTag.DynVarOption.ToString());
            DynVarOption option       = (DynVarOption)Enum.Parse(typeof(DynVarOption), dynVarOption);

            return(option);
        }
예제 #4
0
        //void _buffer_Changed(object sender, TextContentChangedEventArgs e)
        //{
        //    if (e.After != _buffer.CurrentSnapshot)
        //        return;

        //    OnTagsChanged(new SnapshotSpan(_buffer.CurrentSnapshot, 0, _buffer.CurrentSnapshot.Length));
        //}

        //void OnTagsChanged(SnapshotSpan span)
        //{

        //    if (TagsChanged != null)
        //        TagsChanged(this, new SnapshotSpanEventArgs(span));
        //}

        public IEnumerable <ITagSpan <StaDynTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans)
        {
            var currentFile = ProjectFileAST.Instance.getAstFile(FileUtilities.Instance.getCurrentOpenDocumentFilePath());

            //Get the compileMode
            string       dynOption   = StaDyn.StaDynProject.ProjectConfiguration.Instance.GetProperty(PropertyTag.DynVarOption.ToString());
            DynVarOption compileMode = (DynVarOption)Enum.Parse(typeof(DynVarOption), dynOption);

            foreach (SnapshotSpan curSpan in spans)
            {
                ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
                int    curLoc                = containingLine.Start.Position;
                int    charsMatched          = 0;
                int    currentPositionInLine = 1;
                string tokenText             = null;
                lexer = new StaDynLexer(containingLine.GetText());

                while (curLoc < containingLine.End)
                {
                    IToken StaDynToken = null;
                    try
                    {
                        StaDynToken = lexer.nextToken();
                    }
                    catch (Exception e)
                    {
                    }
                    if (StaDynToken == null)
                    {
                        break;
                    }
                    tokenText = StaDynToken.getText();

                    if (!string.IsNullOrEmpty(tokenText))
                    {
                        charsMatched           = StaDynToken.getText().Length;
                        currentPositionInLine += StaDynToken.getText().Length;
                    }
                    else
                    {
                        charsMatched = 0;
                    }


                    //Sets the line number
                    StaDynToken.setLine(containingLine.LineNumber);
                    StaDynToken.setColumn(currentPositionInLine);

                    StaDynTokenTypes tokenType = lexer.getTokenType(StaDynToken.Type);


                    //Check if the current token its a type
                    //Needed for highlighting
                    if (tokenType == StaDynTokenTypes.Identifier && StaDynTypeTableFunctions.Instance.CheckTokenTypeOnCurrentDocument(StaDynToken))
                    {
                        tokenType = StaDynTokenTypes.TypeDefinition;
                    }

                    //If the compile mode is set to EverythingDynamic
                    //We hace to check wich AST identifires are varibales declared by user
                    //And then check if can ve dynamic
                    else if (tokenType == StaDynTokenTypes.Identifier && compileMode == DynVarOption.EverythingDynamic)
                    {
                        if (currentFile == null)
                        {
                            break;
                        }

                        StaDynLanguage.Visitors.StaDynVariablesInScopeTable infoVariablesInScope = StaDynLanguage.Intellisense.StaDynIntellisenseHelper.Instance.getVariablesInCurrentScope(StaDynToken.getLine(), StaDynToken.getColumn(), _buffer.CurrentSnapshot, 0, false);

                        for (int i = 0; i < infoVariablesInScope.Table.Count; i++)
                        {
                            if (infoVariablesInScope.Table[i].Count > 0)
                            {
                                foreach (KeyValuePair <string, AST.IdDeclaration> variable in infoVariablesInScope.Table[i])
                                {
                                    if (variable.Key == tokenText && variable.Value.Symbol != null)
                                    {
                                        //Only identifiers declared as var
                                        //HACK: Harcoded the "[Var
                                        if (variable.Value.Symbol.SymbolType.FullName.StartsWith("[Var"))
                                        {
                                            tokenType = StaDynTokenTypes.DynamicVar;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    //Atmanaged compile mode
                    //Check if the current token its a dynamicVar
                    //Needed for highlighting
                    else if (tokenType == StaDynTokenTypes.Identifier && StaDynDynamicHelper.Instance.checkDynamicVar(StaDynToken.getText(), StaDynToken.getLine(), StaDynToken.getColumn(), currentFile) && compileMode == DynVarOption.Managed)
                    {
                        tokenType = StaDynTokenTypes.DynamicVar;
                    }

                    var tokenSpan = new SnapshotSpan(curSpan.Snapshot, new Span(curLoc, charsMatched));
                    if (tokenSpan.IntersectsWith(curSpan))
                    {
                        yield return(new TagSpan <StaDynTokenTag>(tokenSpan,
                                                                  new StaDynTokenTag(tokenType, StaDynToken)));
                    }

                    curLoc += charsMatched;
                }
            }
        }
예제 #5
0
        /// <summary>
        /// Execute the Build task. This will call the Inference compiler passing the files obtained in the
        /// Files property of this task and other received arguments.
        /// </summary>
        /// <remarks>
        /// Error log is stored in: [OutputPath]\ErrorLog.txt
        /// Type table log is stored in: [OutputPath]\TypeTable.txt
        /// </remarks>
        /// <returns>true if succesful.</returns>
        public override bool Execute()
        {
            if (files.Length == 0)
            {
                return(false);
            }

            string outputPath = ProjectConfiguration.Instance.GetProperty(PropertyTag.OutputPath.ToString());

            if (!Path.IsPathRooted(outputPath))
            {
                outputPath = Path.Combine(ProjectConfiguration.Instance.GetActiveProjectFilePath(), outputPath);
            }

            string debugFilesPath = outputPath;

            string typeTableFileName = Path.Combine(outputPath, Resources.TypeTable);

            //string ilasmFileName = Path.Combine(ProjectConfiguration.Instance.GetProperty("LibPath"), Resources.Ilasm);
            string ilasmFileName = Path.Combine(ProjectConfiguration.Instance.GetProperty("StaDynPath"), Resources.Ilasm);

            ErrorManager.Instance.LogFileName = Path.Combine(outputPath, Resources.ErrorLog);

            ErrorManager.Instance.Clear();

            StaDynLanguage.Errors.ErrorPresenter.Instance.ClearErrors();


            TargetPlatform targetPlatform = (TargetPlatform)Enum.Parse(typeof(TargetPlatform), Target);

            DynVarOption option = (DynVarOption)Enum.Parse(typeof(DynVarOption), DynVarOption);

            DynVarOptions.Instance.EverythingDynamic = option == StaDynLanguage_Project.DynVarOption.EverythingDynamic;

            DynVarOptions.Instance.EverythingStatic = option == StaDynLanguage_Project.DynVarOption.EverythingStatic;

            Program app = new Program();

            Program.ClearMemory();

            IDictionary <string, string> dictionary = new Dictionary <string, string>();


            string directory = Path.GetDirectoryName(outputPath);

            //req.FileName.Remove(req.FileName.Length - ast.Location.FileName.Length);

            IDictionary <string, string> name = new Dictionary <string, string>();

            //name.Add(outputPath, directory);

            //app.LoadFile(new FileInfo(ProjectConfiguration.Instance.GetActiveProjectFilePath()), dictionary);

            foreach (string file in Files)
            {
                var fileInfo = new FileInfo(file);
                app.LoadFile(fileInfo, dictionary);

                name.Add(fileInfo.FullName, directory);
            }

            string fileName = Path.GetFileName(outputFileName);
            string target   = Path.Combine(outputPath, fileName);



            //app.Run(name, target + ".exe", debugFilesPath, ilasmFileName, typeTableFileName, targetPlatform, false);


            //app.Run(dictionary, OutputFileName + ".exe", debugFilesPath, typeTableFileName, ilasmFileName, targetPlatform, false);
            //app.Run(dictionary, null, debugFilesPath, typeTableFileName, null, targetPlatform, false);

            DirectoryInfo outputDir = new DirectoryInfo(outputPath);

            if (!outputDir.Exists)
            {
                outputDir.Create();
            }

            if (ErrorManager.Instance.ErrorFound)
            {
                handleErrors();
                return(false);
            }
            else
            {
                //app.Run(dictionary, OutputFileName + Resources.ExecutableExt, debugFilesPath, typeTableFileName, ilasmFileName, targetPlatform, false);
                app.Run(name, target + ".exe", debugFilesPath, ilasmFileName, typeTableFileName, targetPlatform, false);
            }

            if (ErrorManager.Instance.ErrorFound)
            {
                handleErrors();
                return(false);
            }


            return(true);
        }