Exemple #1
0
        private void WireUpJavaScriptConfigurationObject(CSharp.Context context)
        {
            var prototype = context.Environment.NewObject();
            var constructor = IronJS.Native.Utils.CreateConstructor<Func<FunctionObject, CommonObject, CommonObject>>(
                context.Environment, 0, (ctor, _) =>
                                            {
                                                var proto = ctor.GetT<CommonObject>("prototype");
                                                return new ConfigJsObject(ctor.Env, this, proto);
                                            });

            prototype.Prototype = context.Environment.Prototypes.Object;

            prototype.Put("run",
                          IronJS.Native.Utils.CreateFunction<Action<FunctionObject, CommonObject, BoxedValue>>(
                              context.Environment, 1, ConfigJsObject.Run));

            prototype.Put("use",
                          IronJS.Native.Utils.CreateFunction<Action<FunctionObject, CommonObject, CommonObject>>(
                              context.Environment, 1, ConfigJsObject.Use));

            prototype.Put("map",
                          IronJS.Native.Utils.CreateFunction<Action<FunctionObject, CommonObject, string, BoxedValue>>(
                              context.Environment, 1, ConfigJsObject.Map));

            constructor.Put("prototype", prototype);

            context.SetGlobal("Config", constructor);
        }
Exemple #2
0
      private static FunctionObject LoadUglify(CSharp.Context context, ResourceHelper resourceHelper)
      {
         string uglifyCode = resourceHelper.Get("uglify-js.js");
         context.Execute(String.Concat(uglifyCode));

         return context.GetGlobalAs<FunctionObject>("uglify");
      }
Exemple #3
0
        public CreateHandler(
			CSharp.Files.IResolveFileTypes fileTypeResolver,
			string keyPath)
        {
            _fileTypeResolver = fileTypeResolver;
            _keyPath = keyPath;
        }
        public SetupForm(CSharp aCSharp, IItemBrowser aBrowser)
        {
            mCSharp     = aCSharp;
            mBrowser    = aBrowser;
            InitializeComponent();

            fastColoredTextBox_Code.Text                = mCSharp.Code;

            Size                                        = mCSharp.mEditorSize;
            mNormalSize                                 = mCSharp.mEditorSize;
            splitContainerControl_Code.SplitterPosition = mCSharp.mEditorSplitterPos;
            tsComboBox_Font.SelectedIndex               = mCSharp.mEditorFontIndex;

            mAutocompleteMenu                           = new AutocompleteMenu(fastColoredTextBox_Code);
            mAutocompleteMenu.SelectedColor             = Color.Green;

            var lItems                                  = mBrowser.TotalItemNames;
            string lMaxName                             = "";

            for (int i = 0; i < lItems.Length; i++)
            {
                if (lMaxName.Length < lItems[i].Length) lMaxName = lItems[i];
            }
            var lWidth                                  = TextRenderer.MeasureText(lMaxName, mAutocompleteMenu.Font).Width;
            lWidth                                      = lWidth + lWidth / 5;
            mAutocompleteMenu.Items.MaximumSize         = new System.Drawing.Size(lWidth, 300);
            mAutocompleteMenu.Items.Width               = lWidth;
            mAutocompleteMenu.Items.SetAutocompleteItems(lItems);

            TriggerTimeMS   = mCSharp.mTriggerTimeMS;
            WatchdogMS      = mCSharp.mWatchdogMS;
        }
Exemple #5
0
        public static new FunctionObject Create(CSharp.Context context)
        {
            var ctor = Utils.CreateConstructor(
                context.Environment, 0,
                (Func<FunctionObject, CommonObject, CommonObject>)Construct);
            ctor.Put("prototype", CreatePrototype(context));

            return ctor;
        }
Exemple #6
0
      private static FunctionObject LoadUglify(CSharp.Context context, ResourceHelper resourceHelper)
      {
         const string defineModule = "var module = {};";

         string uglifyCode = resourceHelper.Get("uglify-js.js");
         context.Execute(String.Concat(defineModule, uglifyCode));

         return context.GetGlobalAs<FunctionObject>("uglify");
      }
      /// <summary>
      /// Initializes a new instance of the <see cref="RequireDefinition"/> class.
      /// </summary>
      /// <param name="context">The context.</param>
      /// <param name="resourceHelper">The resource helper.</param>
      public RequireDefinition(CSharp.Context context, ResourceHelper resourceHelper)
      {
         if (context == null)
            throw new ArgumentNullException("context");

         if (resourceHelper == null)
            throw new ArgumentNullException("resourceHelper");

         this.context = context;
         this.resourceHelper = resourceHelper;
         this.requireCache = new Dictionary<string, CommonObject>();
         this.cacheLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
         this.require = Utils.CreateFunction<Func<string, CommonObject>>(this.context.Environment, 1, Require);
      }
Exemple #8
0
        public Blender(Lexer lexer, CSharp.CSharpSyntaxNode oldTree, IEnumerable<TextChangeRange> changes)
        {
            Debug.Assert(lexer != null);
            _lexer = lexer;
            _changes = ImmutableStack.Create<TextChangeRange>();

            if (changes != null)
            {
                // TODO: Consider implementing NormalizedChangeCollection for TextSpan. the real
                // reason why we are collapsing is because we want to extend change ranges and
                // cannot allow them to overlap. This does not seem to be a big deal since multiple
                // changes are infrequent and typically close to each other. However if we have
                // NormalizedChangeCollection for TextSpan we can have both - we can extend ranges
                // and not require collapsing them. NormalizedChangeCollection would also ensure
                // that changes are always normalized.

                // TODO: this is a temporary measure to prevent individual change spans from
                // overlapping after they are widened to effective width (+1 token at the start).
                // once we have normalized collection for TextSpan we will not need to collapse all
                // the change spans.

                var collapsed = TextChangeRange.Collapse(changes);

                // extend the change to its affected range. This will make it easier 
                // to filter out affected nodes since we will be able simply check 
                // if node intersects with a change.
                var affectedRange = ExtendToAffectedRange(oldTree, collapsed);
                _changes = _changes.Push(affectedRange);
            }

            if (oldTree == null)
            {
                // start at lexer current position if no nodes specified
                _oldTreeCursor = new Cursor();
                _newPosition = lexer.TextWindow.Position;
            }
            else
            {
                _oldTreeCursor = Cursor.FromRoot(oldTree).MoveToFirstChild();
                _newPosition = 0;
            }

            _changeDelta = 0;
            _newDirectives = default(DirectiveStack);
            _oldDirectives = default(DirectiveStack);
            _newLexerDrivenMode = 0;
        }
        public static void AttachToContext(CSharp.Context context)
        {
            CommonObject prototype = context.Environment.NewObject();
            FunctionObject constructor =
                Utils.CreateConstructor<Func<FunctionObject, CommonObject, CommonObject>>
                    (context.Environment, 0, Construct);
            FunctionObject log = Utils.CreateFunction<Action<FunctionObject, CommonObject, object>>
                (context.Environment, 1, ConsoleObject.Log);
            FunctionObject dir = Utils.CreateFunction<Action<FunctionObject, CommonObject, object>>
                (context.Environment, 1, ConsoleObject.Dir);

            prototype.Prototype = context.Environment.Prototypes.Object;
            prototype.Put("log", log, DescriptorAttrs.Immutable);
            prototype.Put("dir", dir, DescriptorAttrs.Immutable);
            constructor.Put("prototype", prototype, DescriptorAttrs.Immutable);
            context.SetGlobal("Console", constructor);
            context.Execute("console = new Console();");
        }
Exemple #10
0
        public static CommonObject CreatePrototype(CSharp.Context context)
        {
            var addHandler = Utils.CreateFunction(
                context.Environment, 2,
                (Action<FunctionObject, CommonObject, string, FunctionObject>)AddHandler);
            var removeHandler = Utils.CreateFunction(
                context.Environment, 2,
                (Action<FunctionObject, CommonObject, string, FunctionObject>)RemoveHandler);
            var trigger = Utils.CreateFunction(
                context.Environment, 2,
                (Action<FunctionObject, CommonObject, string, BoxedValue>)Trigger);

            var prototype = context.Environment.NewObject();
            prototype.Prototype = context.Environment.Prototypes.Object;
            prototype.Put("addHandler", addHandler);
            prototype.Put("removeHandler", removeHandler);
            prototype.Put("trigger", trigger);

            return prototype;
        }
Exemple #11
0
        public static void AttachToContext(CSharp.Context context, IMainWindow window)
        {
            var jsWindow = new WindowObject(
                context.Environment,
                context.Environment.Prototypes.Object,
                window);

            var setTitle = Utils.CreateFunction(
                context.Environment, 1,
                (Action<FunctionObject, CommonObject, string>)SetTitle);
            var getTitle = Utils.CreateFunction(
                context.Environment, 0,
                (Func<FunctionObject, CommonObject, string>)GetTitle);
            var addCommand = Utils.CreateFunction(
                context.Environment, 1,
                (Action<FunctionObject, CommonObject, CommonObject>)AddCommand);
            var removeCommand = Utils.CreateFunction(
                context.Environment, 1,
                (Action<FunctionObject, CommonObject, CommonObject>)RemoveCommand);
            var addApplicationCommand = Utils.CreateFunction(
                context.Environment, 1,
                (Action<FunctionObject, CommonObject, CommonObject>)AddApplicationCommand);
            var removeApplicationCommand = Utils.CreateFunction(
                context.Environment, 1,
                (Action<FunctionObject, CommonObject, CommonObject>)RemoveApplicationCommand);
            var exit = Utils.CreateFunction(
                context.Environment, 0,
                (Action<FunctionObject, CommonObject>)Exit);
            var editors = new EditorProviderObject(context.Environment, context.Environment.Prototypes.Object, window.Editors);

            jsWindow.Put("setTitle", setTitle, DescriptorAttrs.Immutable);
            jsWindow.Put("getTitle", getTitle, DescriptorAttrs.Immutable);
            jsWindow.Put("addCommand", addCommand, DescriptorAttrs.Immutable);
            jsWindow.Put("removeCommand", removeCommand, DescriptorAttrs.Immutable);
            jsWindow.Put("addApplicationCommand", addApplicationCommand, DescriptorAttrs.Immutable);
            jsWindow.Put("removeApplicationCommand", removeApplicationCommand, DescriptorAttrs.Immutable);
            jsWindow.Put("exit", exit, DescriptorAttrs.Immutable);
            jsWindow.Put("editors", editors, DescriptorAttrs.Immutable);

            context.SetGlobal("window", jsWindow);
        }
Exemple #12
0
        public static SLE.Expression ConvertMethod(SLE.Expression [] parameters, MethodDefinition method)
        {
            var body = method.Body.Decompile(CSharp.GetLanguage(CSharpVersion.V1));

            if (body.Statements.Count != 1)
            {
                throw new ArgumentException();
            }

            var @return = body.Statements [0] as ReturnStatement;

            if (@return == null)
            {
                throw new ArgumentException();
            }

            var converter = new ExpressionConverter(parameters, method);

            converter.Visit(@return.Expression);
            return(converter.Pop());
        }
Exemple #13
0
        private void processFolder(string folderName, string[] foldersToSkip)
        {
            CSharp lang = new CSharp();

            var fileEntries = System.IO.Directory.EnumerateFiles(folderName)
                              .Where(fn => System.IO.Path.GetExtension(fn) == ".cs");

            foreach (var fileEntry in fileEntries)
            {
                Trace.TraceInformation("Parsing file: " + fileEntry);
                lang.Parse(System.IO.File.ReadAllText(fileEntry), fileEntry);
            }
            var dirEntries = System.IO.Directory.EnumerateDirectories(folderName)
                             .Where(fn => false == fn.Contains(".git"))
                             .Where(fn => false == foldersToSkip.Contains(fn));

            foreach (var dirEntry in dirEntries)
            {
                processFolder(dirEntry, foldersToSkip);
            }
        }
Exemple #14
0
        private static SyntaxNode Program(RParser.ProgContext prog, Func <ParserRuleContext, Scope, SyntaxNode> transform, Scope scope)
        {
            var statements = new List <StatementSyntax>();
            var inner      = new Scope(scope);

            inner.InitR();
            var pre = inner.PreStatements();

            foreach (var expr in prog.expr_or_assign())
            {
                pre.Clear();

                var statement = transform(expr, inner) as StatementSyntax;
                Debug.Assert(statement != null);

                statements.AddRange(pre);
                statements.Add(statement);
            }

            return(CSharp.Block(statements));
        }
Exemple #15
0
        private static MethodDeclarationSyntax singletonPublicSignal(MethodDeclarationSyntax method, out MethodDeclarationSyntax result)
        {
            result = method.WithIdentifier(CSharp.ParseToken("__" + method.Identifier.ToString()));

            var sCall = method.ReturnType.ToString() == "void"
                ? Templates.SingletonCall
                        .Get <StatementSyntax>(result.Identifier.ToString())
                : Templates.SingletonReturnCall
                        .Get <StatementSyntax>(result.Identifier.ToString());

            return(method
                   .AddModifiers([email protected]())
                   .WithBody(CSharp.Block(sCall
                                          .ReplaceNodes(sCall
                                                        .DescendantNodes()
                                                        .OfType <ArgumentListSyntax>(),
                                                        (on, nn) => nn.WithArguments(CSharp.SeparatedList(method
                                                                                                          .ParameterList
                                                                                                          .Parameters
                                                                                                          .Select(parameter => CSharp.Argument(CSharp.IdentifierName(parameter.Identifier)))))))));
        }
Exemple #16
0
        static RExtension()
        {
            _binaryOperators["+"]  = CSharp.ParseExpression("RR.add");
            _binaryOperators["-"]  = CSharp.ParseExpression("RR.sub");
            _binaryOperators["*"]  = CSharp.ParseExpression("RR.mul");
            _binaryOperators["/"]  = CSharp.ParseExpression("RR.div");
            _binaryOperators[">"]  = CSharp.ParseExpression("RR.gt");
            _binaryOperators[">="] = CSharp.ParseExpression("RR.ge");
            _binaryOperators["<"]  = CSharp.ParseExpression("RR.lt");
            _binaryOperators["<="] = CSharp.ParseExpression("RR.le");
            _binaryOperators["=="] = CSharp.ParseExpression("RR.eq");
            _binaryOperators["!="] = CSharp.ParseExpression("RR.neq");
            _binaryOperators["&&"] = CSharp.ParseExpression("RR.and");
            _binaryOperators["&"]  = CSharp.ParseExpression("RR.bnd");
            _binaryOperators["||"] = CSharp.ParseExpression("RR.or");
            _binaryOperators["|"]  = CSharp.ParseExpression("RR.bor");

            _unaryOperators["+"] = CSharp.ParseExpression("RR.ps");
            _unaryOperators["-"] = CSharp.ParseExpression("RR.ns");
            _unaryOperators["!"] = CSharp.ParseExpression("RR.neg");
        }
Exemple #17
0
        private static ExpressionSyntax Call(ParserRuleContext node)
        {
            if (node.ChildCount == 1)
            {
                return(Expression(node.GetRuleContext <ParserRuleContext>(0)));
            }

            var expr = visitNode(node.GetRuleContext <ParserRuleContext>(0));
            var args = null as ArgumentListSyntax;

            if (node.ChildCount == 4)
            {
                args = Arguments(node.GetRuleContext <ParserRuleContext>(2));
            }
            else
            {
                args = CSharp.ArgumentList();
            }

            return(CSharp.InvocationExpression(expr, args));
        }
Exemple #18
0
        private StatementSyntax LinkThisInvocation(InvocationExpressionSyntax invocation, InvocationExpressionSyntax success, InvocationExpressionSyntax failure)
        {
            Debug.Assert(invocation.Expression is IdentifierNameSyntax);

            //internal calls
            StatementSyntax result;

            if (syntaxOperation(invocation, success, failure, out result))
            {
                return(result);
            }
            else
            {
                var identifier = (invocation.Expression as IdentifierNameSyntax)
                                 .ToString();
                Signal signal = _class.GetSignal(identifier);
                if (signal != null)
                {
                    var expr = invocation
                               .WithExpression(CSharp.IdentifierName("__concurrent" + identifier))
                               .WithArgumentList(invocation
                                                 .ArgumentList
                                                 .AddArguments(
                                                     CSharp.Argument(
                                                         Templates.CancelationArgument),
                                                     CSharp.Argument(WrapInLambda(success)
                                                                     .AddParameterListParameters(CSharp.Parameter(CSharp.ParseToken(
                                                                                                                      "__res")))),
                                                     CSharp.Argument(WrapInLambda(failure)
                                                                     .AddParameterListParameters(CSharp.Parameter(CSharp.ParseToken(
                                                                                                                      "__ex"))))));

                    return(CSharp.ExpressionStatement(Templates
                                                      .Advance
                                                      .Get <ExpressionSyntax>(expr)));
                }

                return(CSharp.ExpressionStatement(invocation));
            }
        }
Exemple #19
0
        private static TypeDeclarationSyntax ParseModel(ClassDeclarationSyntax @class, ParameterListSyntax parameters, Scope scope)
        {
            var init  = new List <ParameterSyntax>();
            var props = new List <PropertyDeclarationSyntax>();

            foreach (var member in @class.Members)
            {
                var field = ParseField(member);
                if (field == null)
                {
                    continue; //error has already been registered
                }
                var type     = field.Declaration.Type;
                var variable = field.Declaration
                               .Variables
                               .Single();


                init.Add(CSharp.Parameter(variable.Identifier)
                         .WithType(type)
                         .WithDefault(CSharp.EqualsValueClause(
                                          variable.Initializer != null
                            ? variable.Initializer.Value
                            : CSharp.DefaultExpression(type))));

                props.Add(ModelProperty.Get <PropertyDeclarationSyntax>(type)
                          .WithIdentifier(variable.Identifier));
            }

            if (!RoslynCompiler.HasVisibilityModifier(@class.Modifiers))
            {
                @class = @class.AddModifiers(CSharp.Token(SyntaxKind.PublicKeyword));
            }

            return(@class
                   .WithMembers(CSharp.List <MemberDeclarationSyntax>(
                                    props.Union(new[] {
                GenerateConstructor(@class, init)
            }))));
        }
Exemple #20
0
        private static MethodDeclarationSyntax CompileAppMain(MethodDeclarationSyntax main, Options options)
        {
            foreach (var parameter in main.ParameterList.Parameters)
            {
                if (parameter.Default != null)
                {
                    switch (parameter.Identifier.ToString())
                    {
                    case "threads":
                        var value = parameter
                                    ?.Default
                                    .Value;

                        Debug.Assert(value != null);     //td: error
                        options.ThreadCount = int.Parse(value.ToString());
                        break;
                    }
                }
            }

            return(main.WithParameterList(CSharp.ParameterList()));
        }
Exemple #21
0
        private StatementSyntax LinkExternalInvocation(InvocationExpressionSyntax invocation, InvocationExpressionSyntax success, InvocationExpressionSyntax failure)
        {
            var queueStatement = null as StatementSyntax;

            if (_class.isQueueInvocation(invocation, true, success, out queueStatement))
            {
                return(queueStatement);
            }

            Debug.Assert(invocation.Expression is MemberAccessExpressionSyntax);
            Debug.Assert(!invocation.Expression
                         .DescendantNodes()
                         .OfType <InvocationExpressionSyntax>()
                         .Any()); //td: errors

            var symbol = _model.GetSymbolInfo(invocation.Expression).Symbol;

            if (symbol == null)
            {
                return(CSharp.ExpressionStatement(invocation));
            }

            if (isConcurrent(symbol))
            {
                return(CSharp.ExpressionStatement(
                           invocation
                           .WithArgumentList(invocation
                                             .ArgumentList
                                             .AddArguments(
                                                 CSharp.Argument(Templates
                                                                 .SuccessFunction
                                                                 .Get <ExpressionSyntax>(success)),
                                                 CSharp.Argument(Templates
                                                                 .FailureFunction
                                                                 .Get <ExpressionSyntax>(failure))))));
            }

            return(CSharp.ExpressionStatement(invocation));
        }
Exemple #22
0
        private SyntaxNode LinkTryStatements(List <StatementSyntax> statements, string variable)
        {
            var newStatements = new List <StatementSyntax>();
            var firstTry      = _trysInStack == 1;

            if (firstTry)
            {
                foreach (var v in _tryVariables)
                {
                    newStatements.Add(Templates
                                      .TryVariable
                                      .Get <StatementSyntax>(v));
                }

                _tryConcurrent = false;
                _tryVariables.Clear();
            }

            return(CSharp.Block(
                       newStatements.Union(
                           CreateTrySplit(statements, 0, variable))));
        }
Exemple #23
0
        private static StatementSyntax ParseConnection(
            IEnumerable<SyntaxToken> arguments,
            Scope scope,
            out IdentifierNameSyntax identifier, 
            out bool resolved)
        {
            var id = scope.GetUniqueId("__connection");
            identifier = CSharp.IdentifierName(id);
            resolved = false;
            if (arguments != null)
            {
                var service = scope.GetService<SyntaxToken, SyntaxNode, SemanticModel>();
                var argumentList = (ArgumentListSyntax)service.ParseArgumentListFromTokens(arguments);
                var expr = default(ExpressionSyntax);
                foreach (var argument in argumentList.Arguments)
                {
                    if (argument.NameColon != null && !argument.NameColon.IsMissing)
                    {
                        throw new NotImplementedException(); //td: connection related parameters
                    }
                    else if (expr == null)
                        expr = argument.Expression;
                    else
                    {
                        Debug.Assert(false); //td: error, too many parameters
                    } 
                }

                if (expr != null)
                {
                    //assume the single parameter to be an already-constructed connection
                    resolved = true;
                    return AssignConnectionVariable.Get<StatementSyntax>(id, expr);
                }
            }


            return null;
        }
Exemple #24
0
        public void SyntacticalMatching_Usage()
        {
            RoslynCompiler compiler = new RoslynCompiler();
            var            syntax   = compiler.Syntax();

            //simple match
            syntax
            .match <ClassDeclarationSyntax>(c => !c.Members.OfType <ConstructorDeclarationSyntax>().Any())
            .then(addConstructor);

            var tree = compiler.ApplySyntacticalPass("class foo { } class bar { bar() {} }");

            Assert.IsTrue(tree
                          .GetRoot()
                          .DescendantNodes()
                          .OfType <ConstructorDeclarationSyntax>()
                          .Count() == 2); //must have added a constructor to "foo"

            //scope match & transform
            syntax
            .match <ClassDeclarationSyntax>(c => c.Identifier.ToString() == "foo")
            .descendants <MethodDeclarationSyntax>(named: "methods")
            .descendants <PropertyDeclarationSyntax>(prop => prop.Identifier.ToString().StartsWith("my"), named: "myProps")
            .then(syntax.transform()
                  .replace("methods", method => ((MethodDeclarationSyntax)method)
                           .WithIdentifier(CSharp.ParseToken("my" + ((MethodDeclarationSyntax)method).Identifier.ToString())))
                  .remove("myProps"));


            var scopeTree = compiler.ApplySyntacticalPass("class foo { public void Method() {} int myProp {get; set;} }");

            Assert.IsTrue(scopeTree.ToString() == "class foo { public void myMethod() {} foo (){}}");

            Assert.IsTrue(scopeTree
                          .GetRoot()
                          .DescendantNodes()
                          .OfType <ConstructorDeclarationSyntax>()
                          .Count() == 1); //must have added a constructor to "foo", since the syntax is the same
        }
Exemple #25
0
        static void Main(string [] args)
        {
            var method = GetProgramMethod("Main");

            var cfg = ControlFlowGraph.Create(method);

            FormatControlFlowGraph(Console.Out, cfg);

            Console.WriteLine("--------------------");

            var store = AnnotationStore.CreateStore(cfg, BlockOptimization.Detailed);

            PrintAnnotations(method, store);

            var language = CSharp.GetLanguage(CSharpVersion.V1);

            var body = method.Body.Decompile(language);

            var writer = language.GetWriter(new PlainTextFormatter(Console.Out));

            writer.Write(method);
        }
Exemple #26
0
        private static Func <SyntaxNode, Scope, SyntaxNode> ProcessCodeFunction(IdentifierNameSyntax name, BlockSyntax body)
        {
            return((node, scope) =>
            {
                LocalDeclarationStatementSyntax localDeclaration = (LocalDeclarationStatementSyntax)CSharp.ParseStatement("var id = () => {}");
                var variable = localDeclaration.Declaration.Variables[0];
                var lambda = variable.Initializer.Value as ParenthesizedLambdaExpressionSyntax;
                Debug.Assert(lambda != null);

                return localDeclaration
                .WithDeclaration(localDeclaration
                                 .Declaration
                                 .WithVariables(CSharp.SeparatedList(new[] {
                    variable
                    .WithIdentifier(name.Identifier)
                    .WithInitializer(variable.Initializer
                                     .WithValue(lambda
                                                //.WithParameterList(invocation.ArgumentList) //td: extension arguments
                                                .WithBody(body)))
                })));
            });
        }
Exemple #27
0
        public SpearToolsManager(string gameName)
        {
            log = Log4NetLogger.getInstance(LogAppender.APP_CORE, Consts.DIR_SETTINGS);
            CSharp.setLogger(Log4NetLogger.getInstance(LogAppender.APP_CORE, Consts.DIR_SETTINGS));
            this.theGame = gameName;
            SPConfig config = SPConfig.loadConfig();

            if (config != null)
            {
                log.Debug("-- config.selectSettings() game:" + gameName);
                this.settings     = config.settings;
                this.gameSettings = config.selectGame(gameName);
                this.paths        = new PathsHelper(this.settings, this.gameSettings);
            }
            else
            {
                log.Warn("COULD NOT LOAD CONFIGURATION FILE");
                this.settings     = null;
                this.gameSettings = null;
                this.paths        = null;
            }
        }
        public async Task RemoveAsync_AfterInserting3Languages_AndRemoving1_2ShouldBeInTable()
        {
            // arrange
            var repo = await SetupAsync();

            var toBeRemoved = new CSharp();
            var langs       = new[] { toBeRemoved, new CSharp(), new CSharp() };
            await repo.InsertAllAsync(langs);

            // act
            var removedCount = await repo.RemoveAsync(toBeRemoved);

            // assert
            var count = await repo.Connection.Table <Language>().CountAsync();

            count.ShouldBe(2);
            removedCount.ShouldBe(1);

            var itemsInTable = await repo.Connection.Table <Language>().ToListAsync();

            itemsInTable.ShouldNotContain(toBeRemoved);
        }
        public void CSharpComposerExtraNamespace()
        {
            testSnippet = "<%=5+5%>lol<%for (int i = 0; i < 5; i++) %>*" +
                          "<%var blah = new List<int>();%>";
            string[] namespaces = { "System.Collections.Generic" };
            expectedCode = "using System.IO;\n\n" +
                           "using System.Collections.Generic;\n" +
                           "class CSharpTemplate\n{\n" +
                           "public static TextWriter method(string json)\n{\n" +
                           "StringWriter output = new StringWriter();\n" +
                           "output.Write((5+5).ToString());\n" +
                           "output.Write(\"lol\");\n" +
                           "for (int i = 0; i < 5; i++) output.Write(\"*\");\n" +
                           "var blah = new List<int>();" +
                           "return output;\n}\n}";
            chunks = new Parser(testSnippet).Parse();
            var lang = new CSharp();

            lang.AddExtras(null, namespaces, null);
            actualCode = lang.ComposeCode(chunks);
            Assert.AreEqual(expectedCode, actualCode);
        }
Exemple #30
0
        private ExpressionSyntax CreateCallback(bool success, bool leftOfParent, SyntaxToken token)
        {
            var arg1 = leftOfParent
                ? success ? Roslyn.@true : Roslyn.@false
                : Roslyn.@null;

            var arg2 = leftOfParent
                ? Roslyn.@null
                : success ? Roslyn.@true : Roslyn.@false;

            var ex = success
                ? Roslyn.@null
                : Templates.FailureParameter;

            return(CSharp
                   .InvocationExpression(CSharp.IdentifierName(token))
                   .WithArgumentList(CSharp.ArgumentList(CSharp.SeparatedList(new[] {
                CSharp.Argument(arg1),
                CSharp.Argument(arg2),
                CSharp.Argument(ex)
            }))));
        }
Exemple #31
0
        //type code extensions
        private Func <ClassDeclarationSyntax, ParameterListSyntax, BlockSyntax, Scope, TypeDeclarationSyntax> TypeCodeExtensions_Transform(
            bool expectsIdentifier,
            bool expectsParameters)
        {
            return((@class, parameters, code, scope) =>
            {
                var hasIdentifier = @class.Identifier.ToString().Equals("SomeIdentifier");
                if (expectsIdentifier)
                {
                    Assert.IsTrue(hasIdentifier);
                }

                if (expectsParameters)
                {
                    Assert.IsNotNull(parameters);
                }

                if (!hasIdentifier)
                {
                    @class = @class.WithIdentifier(CSharp
                                                   .ParseToken("SomeIdentifier"));
                }

                if (parameters != null)
                {
                    @class = @class.AddMembers(CSharp
                                               .MethodDeclaration(RoslynCompiler.@void, "SomeParameters")
                                               .AddParameterListParameters(parameters
                                                                           .Parameters
                                                                           .ToArray()));
                }

                return @class
                .AddMembers(CSharp
                            .MethodDeclaration(RoslynCompiler.@void, "SomeMethod")
                            .WithBody(code));
            });
        }
Exemple #32
0
        //member extensions
        private static Func <SyntaxNode, Scope, LexicalExtension <SyntaxToken>, SyntaxNode> TransformMember(
            Func <MethodDeclarationSyntax, Scope, MemberDeclarationSyntax> transform)
        {
            return((node, scope, extension) =>
            {
                var method = node as MethodDeclarationSyntax;
                if (method == null)
                {
                    Debug.Assert(false); //td: error
                    return node;
                }

                if (node.Parent is TypeDeclarationSyntax)
                {
                    var service = scope.GetService <SyntaxToken, SyntaxNode, SemanticModel>();
                    var body = (BlockSyntax)service.ParseCodeFromTokens(extension.Body);

                    var identifier = extension.Identifier.IsKind(SyntaxKind.None)
                        ? CSharp.Identifier("__")
                        : extension.Identifier;

                    var parameters = default(ParameterListSyntax);
                    if (extension.Arguments != null && extension.Arguments.Any())
                    {
                        parameters = (ParameterListSyntax)service.ParseParamListFromTokens(extension.Arguments);
                        method = method.WithParameterList(parameters);
                    }

                    return transform(method
                                     .WithIdentifier(identifier)
                                     .WithReturnType(CSharp.ParseTypeName(extension.Keyword.ToString()))
                                     .WithBody(body), scope);
                }

                Debug.Assert(false); //td: error
                return node;
            });
        }
Exemple #33
0
        //type extensions
        private static Func <SyntaxNode, Scope, LexicalExtension <SyntaxToken>, SyntaxNode> TransformType(
            Func <ClassDeclarationSyntax, ParameterListSyntax, Scope, TypeDeclarationSyntax> transform)
        {
            return((node, scope, extension) =>
            {
                var @class = node as ClassDeclarationSyntax;
                if (@class == null)
                {
                    Debug.Assert(false); //td: error
                    return node;
                }

                if (node.Parent is NamespaceDeclarationSyntax || node.Parent is CompilationUnitSyntax)
                {
                    var service = scope.GetService <SyntaxToken, SyntaxNode, SemanticModel>();
                    var members = (service
                                   .ParseMembersFromTokens(extension.Body) as ClassDeclarationSyntax)
                                  .Members;

                    var identifier = extension.Identifier.IsKind(SyntaxKind.None)
                        ? CSharp.Identifier("__")
                        : extension.Identifier;

                    var parameters = default(ParameterListSyntax);
                    if (extension.Arguments != null && extension.Arguments.Any())
                    {
                        parameters = (ParameterListSyntax)service.ParseParamListFromTokens(extension.Arguments);
                    }

                    return transform(@class
                                     .WithIdentifier(identifier)
                                     .WithMembers(members), parameters, scope);
                }

                Debug.Assert(false); //td: error
                return node;
            });
        }
        private static BlockStatement DecompileStateMachine(this MethodBody body, MethodSpecificContext enclosingMethodContext,
                                                            IStateMachineRemoverStep removeStateMachineStep,
                                                            Func <DecompilationContext, IStateMachineData> stateMachineDataSelector,
                                                            out DecompilationContext decompilationContext)
        {
            ILanguage language = CSharp.GetLanguage(CSharpVersion.V4);

            removeStateMachineStep.Language = language;

            DecompilationPipeline thePipeline = GetStateMachineRemovalPipeline(removeStateMachineStep, stateMachineDataSelector);

            decompilationContext = thePipeline.Run(body, language);

            enclosingMethodContext.Variables.AddRange(decompilationContext.MethodContext.Variables);
            enclosingMethodContext.VariableDefinitionToNameMap.AddRange(decompilationContext.MethodContext.VariableDefinitionToNameMap);
            enclosingMethodContext.AddInnerMethodParametersToContext(decompilationContext.MethodContext);
            enclosingMethodContext.VariableAssignmentData.AddRange(decompilationContext.MethodContext.VariableAssignmentData);
            enclosingMethodContext.GotoLabels.AddRange(decompilationContext.MethodContext.GotoLabels);
            enclosingMethodContext.GotoStatements.AddRange(decompilationContext.MethodContext.GotoStatements);
            BlockStatement theBlockStatement = thePipeline.Body;

            return(theBlockStatement);
        }
Exemple #35
0
        private SyntaxNode myExtSyntactical(SyntaxNode node, Scope scope, LexicalExtension <SyntaxToken> extension)
        {
            Assert.IsTrue(node is MethodDeclarationSyntax);
            var method = node as MethodDeclarationSyntax;

            Assert.IsTrue(method.Identifier.ToString() == "__extension");

            var argString = RoslynCompiler.TokensToString(extension.Arguments);

            Assert.IsTrue(argString == "(int i) ");
            var arguments = CSharp.ParseParameterList(argString);

            var codeString = RoslynCompiler.TokensToString(extension.Body);
            var codeNode   = CSharp.ParseStatement(codeString);

            Assert.IsTrue(codeNode is BlockSyntax);
            var code = codeNode as BlockSyntax;

            return(method
                   .WithIdentifier(CSharp.ParseToken("my_ext_s"))
                   .WithParameterList(arguments)
                   .WithBody(code));
        }
        public static string Generate(IEnumerable <TypeMeta> items, bool writable, string targetNamespace, GenerationType gt)
        {
            if (items == null || items.Count() < 1)
            {
                MessageBox.Show("No items imported");
                return(null);
            }
            switch (gt)
            {
            case GenerationType.FSharpRecord:
                return(MapItems(items, x => FSharp.generateRecord(writable, x)));

            case GenerationType.CSharpClass:
                return(MapItems(items, x => CSharp.generateClass(writable, x)));

            case GenerationType.CSharpFile:
                return(MapItems(items, x => CSharp.generateClassFile(targetNamespace, writable, x)));

            default:
                MessageBox.Show("Not implemented");
                return(null);
            }
        }
Exemple #37
0
        public static bool Train(string currentDirectory, string searchPattern,
                                 Func <bool> IsTerminated)
        {
            currentDirectory = @"D:\Mozart\src\";

            var lex = new CSharp();

            string outputFileName = @"D:\Mozart\Mozart.cbow";

            Matrix <Word> Model = null;

            if (File.Exists(outputFileName))
            {
                Model = LoadFromFile(outputFileName,
                                     SIZE, out string fmt, out int dims);
            }
            else
            {
                Model = BuildFromPlainText(currentDirectory,
                                           "*.cs", lex, outputFileName);
            }

            TrainMikolovModel(MakeFileList(new string[] { currentDirectory },
                                           "*.cs", SearchOption.AllDirectories),
                              lex,
                              Model,
                              (loss) => { },
                              IsTerminated);

            CBOW.SaveToFile(
                Matrix <Word> .Sort(Model),
                "CBOW",
                CBOW.DIMS,
                outputFileName);

            return(false);
        }
Exemple #38
0
        private IEnumerable <StatementSyntax> CreateTrySplit(List <StatementSyntax> statements, int index, string variable)
        {
            bool foundTry = false;

            for (int i = index; i < statements.Count; i++, index++)
            {
                if (foundTry)
                {
                    yield return(CSharp.IfStatement(
                                     Templates.Negation.Get <ExpressionSyntax>(CSharp.IdentifierName(variable)),
                                     CSharp.Block(CreateTrySplit(statements, index, variable))));

                    yield break;
                }

                var statement = statements[i];
                if (statement is TryStatementSyntax)
                {
                    foundTry = true;
                    var @try = statement as TryStatementSyntax;
                    yield return(@try
                                 .WithCatches(CSharp.List(
                                                  @try
                                                  .Catches
                                                  .Select(c => c.WithBlock(CSharp.Block(new [] {
                        Templates
                        .SetTryVariable
                        .Get <StatementSyntax>(variable)
                    }.Union(
                                                                                            c.Block.Statements)))))));
                }
                else
                {
                    yield return(statement);
                }
            }
        }
Exemple #39
0
        public void DelegatesAndExternTest()
        {
            CSharp   lang = new CSharp();
            CodeFile cf   = lang.Parse(System.IO.File.ReadAllText(@".\Programs\CSharp\DelegatesAndExterns.txt"), @".\Programs\CSharp\DelegatesAndExterns.txt");

            var functionsAndDelegates = cf.Children.First().Children.First().Children;

            Assert.AreEqual(3, functionsAndDelegates.Count()); //top level functions.

            var del1 = (functionsAndDelegates.First() as FunctionDefinition);

            Assert.IsTrue(del1.TypeOfFunction == FunctionTypes.Delegate);
            Assert.AreEqual("GetNative", del1.Name);
            Assert.AreEqual(1, del1.Parameters.Count());
            Assert.AreEqual(AccessSpecifiers.Private, del1.AccessSpecifiers);

            var fn1 = functionsAndDelegates.Skip(1).First() as FunctionDefinition;

            Assert.AreEqual(FunctionTypes.MemberFunction, fn1.TypeOfFunction);
            var childDel1 = fn1.Children.First() as FunctionDefinition;

            Assert.AreEqual(childDel1.TypeOfFunction, FunctionTypes.AnonymousDelegate);
            Assert.AreEqual(0, childDel1.Parameters.Count());
            var childDel2 = fn1.Children.Skip(1).First() as FunctionDefinition;

            Assert.AreEqual(childDel2.TypeOfFunction, FunctionTypes.AnonymousDelegate);
            Assert.AreEqual(1, childDel2.Parameters.Count());

            var fn2 = functionsAndDelegates.Skip(2).First() as FunctionDefinition;

            Assert.AreEqual(FunctionTypes.External, fn2.TypeOfFunction);
            Assert.IsTrue(fn2.IsExtern);
            Assert.IsTrue((fn2.StorageSpecifiers & StorageSpecifiers.Extern) > 0);
            Assert.IsTrue((fn2.StorageSpecifiers & StorageSpecifiers.Static) > 0);
            Assert.AreEqual(3, fn2.Parameters.Count());
        }
Exemple #40
0
        private static ExpressionSyntax ParseBody(IEnumerable<SyntaxToken> body, Scope scope, out AnonymousObjectCreationExpressionSyntax parameters)
        {
            parameters = null;

            var builder = new StringBuilder();
            var @params = new List<AnonymousObjectMemberDeclaratorSyntax>();
            builder.Append("@\"");
            foreach (var token in body)
            {
                var str = token.ToFullString();
                if (token.IsKind(SyntaxKind.IdentifierToken) && str.StartsWith("@"))
                {
                    var newToken = CSharp.ParseToken(str.Substring(1))
                        .WithAdditionalAnnotations(token.GetAnnotations());

                    @params.Add(CSharp.AnonymousObjectMemberDeclarator(
                        CSharp.NameEquals(CSharp.IdentifierName(newToken)),
                        CSharp.IdentifierName(newToken)));
                }

                builder.Append(str);
            }
            builder.Append("\"");

            var result = CSharp.ParseExpression(builder.ToString());
            if (result == null)
            {
                Debug.Assert(false); //td: error
                return null;
            }

            parameters = CSharp.AnonymousObjectCreationExpression(CSharp.SeparatedList(
                @params));

            return result;
        }
Exemple #41
0
        public void GetContextBlockTest()
        {
            Trace.Listeners.Add(new ConsoleTraceListener());
            CSharp   csharp = new CSharp();
            CodeFile cf     = csharp.Parse(System.IO.File.ReadAllText(@".\Programs\CSharp\Blocks.txt"), @".\Programs\CSharp\Blocks.txt");

            var list = cf.GetContextAtLine(30).ToList();

            Assert.AreEqual(list.Count, 9);
            Assert.AreEqual(list[0].Kind, SyntaxEntityKind.Else);
            Assert.AreEqual(list[1].Kind, SyntaxEntityKind.If);
            Assert.AreEqual(list[2].Kind, SyntaxEntityKind.For);
            Assert.AreEqual(list[3].Kind, SyntaxEntityKind.Try);
            Assert.AreEqual(list[4].Kind, SyntaxEntityKind.Function);
            Assert.AreEqual(list[5].Kind, SyntaxEntityKind.Class);
            Assert.AreEqual(list[6].Kind, SyntaxEntityKind.Class);
            Assert.AreEqual(list[7].Kind, SyntaxEntityKind.Namespace);
            Assert.AreEqual(list[8].Kind, SyntaxEntityKind.CodeFile);

            Assert.AreEqual(list[4].Name, "Foo");
            Assert.AreEqual(list[5].Name, "InnerClass");
            Assert.AreEqual(list[6].Name, "OuterClass");
            Assert.AreEqual(list[7].Name, "Microsoft.CodeTalk.LanguageService.Tests.Programs");
        }
Exemple #42
0
        private static bool IsInsideInterpolation(CSharp.CSharpSyntaxNode oldTree, int start)
        {
            var token = oldTree.FindToken(start, findInsideTrivia: false);
            for (var parent = token.Parent; // for each parent
                parent != null;
                parent = parent.Parent)
            {
                if (parent.Kind() == SyntaxKind.InterpolatedStringExpression)
                {
                    return true;
                }
            }

            return false;
        }
Exemple #43
0
        /// <summary>
        /// Affected range of a change is the range within which nodes can be affected by a change
        /// and cannot be reused. Because of lookahead effective range of a change is larger than
        /// the change itself.
        /// </summary>
        private static TextChangeRange ExtendToAffectedRange(
            CSharp.CSharpSyntaxNode oldTree,
            TextChangeRange changeRange)
        {
            // we will increase affected range of the change by the number of lookahead tokens
            // original code in Blender seem to imply the lookahead at the end of a node is 1 token
            // max. TODO: 1 token lookahead seems a bit too optimistic. Increase if needed. 
            const int maxLookahead = 1;

            // check if change is not after the end. TODO: there should be an assert somwhere about
            // changes starting at least at the End of old tree
            var lastCharIndex = oldTree.FullWidth - 1;

            // Move the start of the change range so that it is contained within oldTree.
            var start = Math.Max(Math.Min(changeRange.Span.Start, lastCharIndex), 0);

            // the first iteration aligns us with the change start. subsequent iteration move us to
            // the left by maxLookahead tokens.  We only need to do this as long as we're not at the
            // start of the tree.  Also, the tokens we get back may be zero width.  In that case we
            // need to keep on looking backward.
            for (var i = 0; start > 0 && i <= maxLookahead;)
            {
                var token = oldTree.FindToken(start, findInsideTrivia: false);
                Debug.Assert(token.Kind() != SyntaxKind.None, "how could we not get a real token back?");

                start = Math.Max(0, token.Position - 1);

                // Only increment i if we got a non-zero width token.  Otherwise, we want to just do
                // this again having moved back one space.
                if (token.FullWidth > 0)
                {
                    i++;
                }
            }

            if (IsInsideInterpolation(oldTree, start))
            {
                // If the changed range starts inside an interpolated string, we
                // move the start of the change range to the beginning of the line so that any
                // interpolated string literal in the changed range will be scanned in its entirety.
                var column = oldTree.SyntaxTree.GetLineSpan(new TextSpan(start, 0)).Span.Start.Character;
                start = Math.Max(start - column, 0);
            }

            var finalSpan = TextSpan.FromBounds(start, changeRange.Span.End);
            var finalLength = changeRange.NewLength + (changeRange.Span.Start - start);
            return new TextChangeRange(finalSpan, finalLength);
        }
Exemple #44
0
 /// <summary>
 /// Returns the name of a given AstType
 /// </summary>
 /// <param name="type"></param>
 /// <returns>The name</returns>
 public static string GetTypeName(CSharp.AstType type)
 {
     if (type is CSharp.SimpleType)
         return (type as CSharp.SimpleType).Identifier;
     else if (type == CSharp.AstType.Null)
         return String.Empty;
     else if (type is CSharp.PrimitiveType)
         return (type as CSharp.PrimitiveType).Keyword;
     else if (type is CSharp.ComposedType)
     {
         CSharp.ComposedType ct = type as CSharp.ComposedType;
         return GetTypeName(ct.BaseType);
     }
     else
     {
         return type.ToString();
     }
 }
Exemple #45
0
 public static TypeDefinition ResolveMemberType(CSharp.MemberReferenceExpression mref)
 {
     foreach (var ann in mref.Annotations)
     {
         if (ann is ICSharpCode.Decompiler.Ast.TypeInformation)
         {
             ICSharpCode.Decompiler.Ast.TypeInformation typeAn = ann as ICSharpCode.Decompiler.Ast.TypeInformation;
             if (typeAn.InferredType != null)
             {
                 return typeAn.InferredType.Resolve();                        
             }
         }
     }
     return null;            
     
 }
Exemple #46
0
 /// <summary>
 /// Returns if a method is marked as an external method or not
 /// </summary>
 /// <param name="method"></param>
 /// <returns>True if is external</returns>
 public static bool IsDLLImportMethod(CSharp.MethodDeclaration method)
 {
     foreach (CSharp.AttributeSection section in method.Attributes)
     {
         foreach (CSharp.Attribute t in section.Attributes)
         {
             if (Resolver.GetTypeName(t.Type).Equals("DllImport"))
             {
                 return true;
             }
         }
     }
     return false;
 }
Exemple #47
0
 /// <summary>
 /// Checks if the node is child of other node of the specified type
 /// </summary>
 /// <param name="member">Node</param>
 /// <param name="type">Type of the parent node</param>
 /// <returns>Bool indicating if is child or not</returns>
 public static bool IsChildOf(CSharp.AstNode member, Type type)
 {
     CSharp.AstNode m = member as CSharp.AstNode;
     while (m.Parent != null)
     {
         if (m.Parent.GetType() == type)
         {
             return true;
         }
         m = m.Parent;
     }
     return false;
 }
 protected CSharp.CSharpCompilation CreateCSharpCompilation(
     string code,
     CSharp.CSharpParseOptions parseOptions = null,
     CSharp.CSharpCompilationOptions compilationOptions = null,
     string assemblyName = null,
     IEnumerable<MetadataReference> referencedAssemblies = null)
 {
     return CreateCSharpCompilation(assemblyName, code, parseOptions, compilationOptions, referencedAssemblies, referencedCompilations: null);
 }
Exemple #49
0
 /// <summary>
 /// Returns the childs nodes of type specified by variable type
 /// </summary>
 /// <param name="member">Original node</param>
 /// <param name="type">Target type of</param>
 /// <returns>The resulting node</returns>
 public static List<CSharp.AstNode> GetChildrenOf(CSharp.AstNode member, Type type)
 {
     List<CSharp.AstNode> result = new List<CSharp.AstNode>();
     CSharp.AstNode m = member as CSharp.AstNode;
     foreach (CSharp.AstNode n in m.Children)
     {
         if (n.GetType() == type)
         {
             result.Add(n);
         }
         result.AddRange(GetChildrenOf(n, type));
     }
     return result;
 }
Exemple #50
0
 /// <summary>
 /// Returns if the node has a child of a specified type
 /// </summary>
 /// <param name="member">Original node</param>
 /// <param name="type">Target type of</param>
 /// <returns>The resulting node</returns>
 public static bool HasChildOf(CSharp.AstNode member, Type type)
 {
     CSharp.AstNode m = member as CSharp.AstNode;
     foreach (CSharp.AstNode n in m.Children)
     {
         if (n.GetType() == type)
         {
             return true;
         }
         bool tmp = HasChildOf(n, type);
         if (tmp)
             return true;
     }
     return false;
 }
Exemple #51
0
 /// <summary>
 /// Gets the library in which the external method is located
 /// </summary>
 /// <param name="attributes"></param>
 /// <returns>The library name</returns>
 public static string GetLibraryFromDllImport(CSharp.AstNodeCollection<CSharp.AttributeSection> attributes)
 {
     foreach (CSharp.AttributeSection section in attributes)
     {
         foreach (CSharp.Attribute t in section.Attributes)
         {
             if (Resolver.GetTypeName(t.Type).Equals("DllImport"))
             {
                 foreach (CSharp.Expression e in t.Arguments)
                 {
                     if (e is CSharp.PrimitiveExpression)
                     {
                         return (e as CSharp.PrimitiveExpression).Value as string;
                     }
                 }
             }
         }
     }
     return String.Empty;
 }
Exemple #52
0
 /// <summary>
 /// Returns the name of the target external function
 /// </summary>
 /// <param name="attributes"></param>
 /// <returns>The real name of the external function in the library</returns>
 public static string GetEntryPointFromDllImport(CSharp.AstNodeCollection<CSharp.AttributeSection> attributes)
 {
     foreach (CSharp.AttributeSection section in attributes)
     {
         foreach (CSharp.Attribute t in section.Attributes)
         {
             if (Resolver.GetTypeName(t.Type).Equals("DllImport"))
             {
                 foreach (CSharp.Expression e in t.Arguments)
                 {
                     if (e is CSharp.AssignmentExpression)
                     {
                         CSharp.AssignmentExpression assign = e as CSharp.AssignmentExpression;
                         if (assign.Left is CSharp.IdentifierExpression)
                         {
                             if ((assign.Left as CSharp.IdentifierExpression).Identifier.Equals("EntryPoint"))
                             {
                                 return (assign.Right as CSharp.PrimitiveExpression).Value.ToString();
                             }
                         }
                     }
                 }
             }
         }
     }
     return String.Empty;
 }
Exemple #53
0
 public static string InferNamespace(CSharp.AstType type)
 {
     if (type.Annotations.Any())
     {
         foreach (Object obj in type.Annotations)
         {
             if (obj is TypeDefinition)
             {
                 var typeDef = obj as TypeDefinition;
                 return typeDef.Namespace;
             }
             else if (obj is MemberReference)
             {
                 var member = obj as MemberReference;
                 return member.FullName.Substring(0, member.FullName.Length - member.FullName.LastIndexOf('.') - 1);
             }
         }
     }
     return String.Empty;
 }
 internal BlendedNode(CSharp.CSharpSyntaxNode node, SyntaxToken token, Blender blender)
 {
     this.Node = node;
     this.Token = token;
     this.Blender = blender;
 }
        protected CSharp.CSharpCompilation CreateCSharpCompilation(
            string assemblyName,
            string code,
            CSharp.CSharpParseOptions parseOptions = null,
            CSharp.CSharpCompilationOptions compilationOptions = null,
            IEnumerable<MetadataReference> referencedAssemblies = null,
            IEnumerable<Compilation> referencedCompilations = null)
        {
            if (assemblyName == null)
            {
                assemblyName = GetUniqueName();
            }

            if (parseOptions == null)
            {
                parseOptions = CSharp.CSharpParseOptions.Default.WithDocumentationMode(DocumentationMode.None);
            }

            if (compilationOptions == null)
            {
                compilationOptions = new CSharp.CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
            }

            var references = new List<MetadataReference>();
            if (referencedAssemblies == null)
            {
                references.Add(MscorlibRef);
                references.Add(SystemRef);
                references.Add(SystemCoreRef);
                //TODO: references.Add(MsCSRef);
                references.Add(SystemXmlRef);
                references.Add(SystemXmlLinqRef);
            }
            else
            {
                references.AddRange(referencedAssemblies);
            }

            AddReferencedCompilations(referencedCompilations, references);

            var tree = CSharp.SyntaxFactory.ParseSyntaxTree(code, options: parseOptions);

            return CSharp.CSharpCompilation.Create(assemblyName, new[] { tree }, references, compilationOptions);
        }
Exemple #56
0
 /// <summary>
 /// Returns if the specified type name is a delegate type
 /// </summary>
 /// <param name="type">Identifier</param>
 /// <returns>True/False</returns>
 public static bool IsDelegateType(CSharp.AstType type)
 {
     return IsDelegateType(Resolver.GetTypeName(type));
 }
Exemple #57
0
        /// <summary>
        /// Checks if the node is direct child of other node of the specified type
        /// </summary>
        /// <param name="member">Node</param>
        /// <param name="type">Type of the parent node</param>
        /// <returns>Bool indicating if is child or not</returns>
        public static bool IsDirectChildOf(CSharp.AstNode member, Type type)
        {
            if (member == null)
                return false;
            if (member.Parent == null)
                return false;

            return member.Parent.GetType() == type;
        }
Exemple #58
0
 /// <summary>
 /// Returns if a method is marked as synchronized or not
 /// </summary>
 /// <param name="method"></param>
 /// <returns>True if synchronized</returns>
 public static bool IsSynchronizedMethod(CSharp.MethodDeclaration method)
 {
     foreach (CSharp.AttributeSection section in method.Attributes)
     {
         foreach (CSharp.Attribute t in section.Attributes)
         {
             if (Resolver.GetTypeName(t.Type).Equals("MethodImpl"))
             {
                 foreach (CSharp.Expression e in t.Arguments)
                 {
                     if (e is CSharp.MemberReferenceExpression)
                     {
                         if ((e as CSharp.MemberReferenceExpression).MemberName == "Synchronized")
                         {
                             return true;
                         }
                     }
                 }
             }
         }
     }
     return false;
 }
Exemple #59
0
 /// <summary>
 /// Returns if a type has template arguments
 /// </summary>
 /// <param name="type"></param>
 /// <returns></returns>
 public static bool IsTemplatizedType(CSharp.AstType type)
 {
     if (type is CSharp.SimpleType)
     {
         CSharp.SimpleType t = type as CSharp.SimpleType;
         return t.TypeArguments.Any();
     }
     else
     {
         if (HasChildOf(type, typeof(CSharp.SimpleType)))
         {
             bool aux = false;
             foreach (var node in GetChildrenOf(type, typeof(CSharp.SimpleType)))
             {
                 if (IsTemplatizedType(type))
                     aux = true;
             }
             return aux;
         }
         return false;
     }
 }
Exemple #60
0
 /// <summary>
 /// Returns the first parent node of type specified by variable type
 /// </summary>
 /// <param name="member">Original node</param>
 /// <param name="type">Target type of</param>
 /// <returns>The resulting node</returns>
 public static CSharp.AstNode GetParentOf(CSharp.AstNode member, Type type)
 {
     CSharp.AstNode m = member as CSharp.AstNode;
     while (m.Parent != null)
     {
         if (m.Parent.GetType() == type)
         {
             return m.Parent;
         }
         m = m.Parent;
     }
     return CSharp.AstNode.Null;
 }