public override void Render(SymbolTable symbols, TextWriter tw, object item) { foreach (var child in Children) { child.Render(symbols, tw, item); } }
public static void ParseProgramOrClass(TextSourceInfo textSourceInfo, ISearchableReadOnlyList<CodeElementsLine> codeElementsLines, TypeCobolOptions compilerOptions, SymbolTable customSymbols, out Program newProgram, out Class newClass, out IList<ParserDiagnostic> diagnostics) { // Create an Antlr compatible token source on top a the token iterator CodeElementsLinesTokenSource tokenSource = new CodeElementsLinesTokenSource( textSourceInfo.Name, codeElementsLines); // Init parser ITokenStream tokenStream = new TokensLinesTokenStream(tokenSource, Token.CHANNEL_SourceTokens); ProgramClassParser cobolParser = new ProgramClassParser(tokenStream); // -> activate full ambiguities detection //parser.Interpreter.PredictionMode = PredictionMode.LlExactAmbigDetection; // Register all parse errors in a list in memory DiagnosticSyntaxErrorListener errorListener = new DiagnosticSyntaxErrorListener(); cobolParser.RemoveErrorListeners(); cobolParser.AddErrorListener(errorListener); // Try to parse a Cobol program or class ProgramClassParser.CobolCompilationUnitContext codeElementParseTree = cobolParser.cobolCompilationUnit(); // Visit the parse tree to build a first class object representing a Cobol program or class ParseTreeWalker walker = new ParseTreeWalker(); CobolNodeBuilder programClassBuilder = new CobolNodeBuilder(); programClassBuilder.CustomSymbols = customSymbols; programClassBuilder.Dispatcher = new NodeDispatcher(); programClassBuilder.Dispatcher.CreateListeners(); walker.Walk(programClassBuilder, codeElementParseTree); // Register compiler results newProgram = programClassBuilder.Program; newClass = programClassBuilder.Class; diagnostics = errorListener.Diagnostics; }
public void AddValue_Correct_Test() { symbolTable = new SymbolTable(); symbolTable.AddValue(id, new Bool(false)); Assert.IsNotNull(symbolTable.GetValue(id)); }
internal LoadLocalAddress(SymbolTable symbols, MethodDefinition method, Instruction untyped, int index) : base(untyped, index) { switch (untyped.OpCode.Code) { case Code.Ldloca_S: case Code.Ldloca: VariableDefinition param = untyped.Operand as VariableDefinition; if (param != null) { Variable = param.Index; Type = param.VariableType; } else { Variable = (int) untyped.Operand; Type = method.Body.Variables[Variable].VariableType; } Name = symbols.LocalName(method, untyped, Variable); break; default: DBC.Fail(untyped.OpCode.Code + " is not a valid LoadLocalAddress"); break; } RealName = symbols.HaveLocalNames(method); }
private bool ProcessExpression(SymbolTable symbolTable) { // TODO: If there are performance problems, we could find a faster way to detect expressions than doing a full parse var tokenSequence = new TokenSequence(XValue); if (tokenSequence.RequiresProcessing) { if (tokenSequence.RequiresTemplateArguments) { var templateInstance = TemplateInstance; if (templateInstance == null || templateInstance.Template == null) { return false; } XValue = tokenSequence.Process(symbolTable, templateInstance.ArgumentDictionary); } else { XValue = tokenSequence.Process(symbolTable, null); } } return true; }
/// <summary> /// Constructs an empty rule builder. /// </summary> public RuleBuilder() { var rootScope = new SymbolTable(); _dependencyBuilder = new DependencyGroupBuilder(rootScope); _groupBuilder = new GroupBuilder(rootScope, GroupType.And); _actionGroupBuilder = new ActionGroupBuilder(rootScope); }
public void Insert_Lookup_WriteTable_SymbolTableTest() { var count = 0; var symTable = new SymbolTable(); symTable.Printer = (val) => { count++; }; symTable.Insert(Token.CreateToken("x", 0), 0); symTable.Insert(Token.CreateToken("y", 0), 0); symTable.Insert(Token.CreateToken("z", 0), 0); symTable.Lookup("x").Content = CreateVariableContent(); symTable.Lookup("y").Content = CreateVariableContent(); symTable.Lookup("z").Content = CreateVariableContent(); symTable.Insert(Token.CreateToken("a", 0), 1); symTable.Insert(Token.CreateToken("x", 0), 1); symTable.Insert(Token.CreateToken("y", 0), 1); symTable.Insert(Token.CreateToken("z", 0), 1); symTable.Lookup("a").Content = CreateVariableContent(); symTable.Lookup("x").Content = CreateVariableContent(); symTable.Lookup("y").Content = CreateVariableContent(); symTable.Lookup("z").Content = CreateVariableContent(); symTable.WriteTable(0); Assert.AreEqual(3, count); count = 0; symTable.WriteTable(1); Assert.AreEqual(4, count); count = 0; symTable.WriteTable(2); Assert.AreEqual(0, count); }
public NameExpression( IExpression identifier, SymbolTable<string, IValue> symbolTable) { _identifier = identifier; _symbolTable = symbolTable; }
public bool Init(ErrorHandling errorContext, SymbolTable symtable) { _runtimeBinderSymbolTable = symtable; Debug.Assert(_pBSymmgr != null); #if !CSEE Debug.Assert(_predefSyms == null); #else // CSEE Debug.Assert(predefSyms == null || aidMsCorLib != KAID.kaidNil); #endif // CSEE if (_aidMsCorLib == KAID.kaidNil) { // If we haven't found mscorlib yet, first look for System.Object. Then use its assembly as // the location for all other pre-defined types. AggregateSymbol aggObj = FindPredefinedType(errorContext, PredefinedTypeFacts.GetName(PredefinedType.PT_OBJECT), KAID.kaidGlobal, AggKindEnum.Class, 0, true); if (aggObj == null) return false; _aidMsCorLib = aggObj.GetAssemblyID(); } _predefSyms = new AggregateSymbol[(int)PredefinedType.PT_COUNT]; Debug.Assert(_predefSyms != null); return true; }
static void Main(string[] args) { while(true) { Console.Write("WinLisp>> "); string input = Console.ReadLine(); // Scan input var tokens = Scanner.scan_input(input); if (tokens.left == null) { Console.WriteLine(tokens.right.ToString()); continue; } foreach (var token in tokens.left) Console.WriteLine(token.ToString()); // Parse Input var funcalls = Parser.parse_tokens(tokens.left); if (funcalls.left == null) foreach (var error in funcalls.right) { Console.WriteLine(error.ToString()); continue; } foreach (var funcall in funcalls.left) Console.WriteLine(funcall.ToString()); // Evaluate Input foreach (var call in funcalls.left) { var result = Evaluator.evaluate_FunCall(table, call); if (result?.left == null) { Console.WriteLine(result.right.ToString()); continue; } Console.WriteLine(result.left.Item2.ToString()); table = result.left.Item1; } } } // End of Main
public NestedProgram(Program containingProgram) { IsNested = true; ContainingProgram = containingProgram; SymbolTable = new SymbolTable(containingProgram.SymbolTable); SyntaxTree.Root.SymbolTable = SymbolTable; }
public void Instantiate(SymbolTable symbolTable, UnboundReferences unboundReferences) { var parentEtl = ParentItem as AstEtlRootNode; var transformationTemplate = Template as AstTransformationTemplateNode; var clonedMapping = new Dictionary<IFrameworkItem, IFrameworkItem>(); if (transformationTemplate != null && parentEtl != null) { var clonedTransformations = new List<AstTransformationNode>(); foreach (var transformation in transformationTemplate.Transformations) { clonedTransformations.Add((AstTransformationNode)transformation.Clone(parentEtl, clonedMapping)); } parentEtl.Transformations.Replace(this, clonedTransformations); } foreach (var bindingItem in transformationTemplate.UnboundReferences) { var clonedBindingItem = new BindingItem( bindingItem.BoundProperty, bindingItem.XObject, bindingItem.XValue, clonedMapping[bindingItem.ParentItem], bindingItem.BimlFile, this); unboundReferences.Add(clonedBindingItem); } }
public Pascal(String operation, String filePath, String flags) { try{ bool intermediate = flags.IndexOf('i') > 1; bool xref = flags.IndexOf('x') > 1; source = new Source(new StreamReader(filePath)); source.AddMessageListener(new SourceMessageListener()); parser = FrontEndFactory.CreateParser("pascal","top-down",source); parser.AddMessageListener(new ParserMessageListener()); backend = BackendFactory.CreateBackend("compile"); backend.AddMessageListener(new BackendMessageListener()); parser.Parse(); source.close(); intermediateCode = parser.IntermediateCode; symbolTable = Parser.SymbolTable; backend.Process(intermediateCode,symbolTable); } catch(Exception ex){ Console.WriteLine ("Internal translation error"); Console.WriteLine (ex.StackTrace); } }
public TypeCheckerVisitor(ErrorHandler errors, StmtList statements) { Errors = errors; SymbolTable = new SymbolTable(); Checker = new TypeChecker(errors); RootStmtList = statements; }
/// <summary> /// Creates a new object code file object. /// </summary> /// <param name="StartAddress">The load address of the object file.</param> /// <param name="Filename">The name of the object file.</param> /// <param name="Architecture">The targeted architecture of the object file.</param> /// <param name="Sections">The sections of the object file.</param> /// <param name="SymbolTable">The symbol table of the object file.</param> /// <param name="Code">The source code of the object file.</param> public ObjectCodeFile(long StartAddress, String Filename, String Architecture, Section[] Sections, SymbolTable SymbolTable, CodeUnit[] Code) { this.loadAddress = StartAddress; this.Filepath = Filename; this.Architecture = Architecture; this.Sections = Sections; this.SymbolTable = SymbolTable; this.Code = Code; this.RequestedLoadAddress = StartAddress; // Sum loaded sections' sizes if (this.Sections != null) this.Size = this.Sections.Sum( sec => sec.Flags.HasFlag(SectionFlags.Load) ? (long)sec.Size : 0); // Get unique source file paths var tmpFiles = new HashSet<string>(); foreach (CodeUnit unit in this.Code) { tmpFiles.Add(unit.SourceFilepath.Trim()); } this.SourceFiles = tmpFiles.ToArray(); }
public void Instantiate(SymbolTable symbolTable, UnboundReferences unboundReferences) { var rootNode = ParentItem as AstRootNode; var tableTemplate = Template as AstTableTemplateNode; var clonedMapping = new Dictionary<IFrameworkItem, IFrameworkItem>(); if (tableTemplate != null && rootNode != null) { var clonedTable = (AstTableNode)tableTemplate.Table.Clone(rootNode, clonedMapping); clonedTable.Emit = this.Emit; // TODO: Some of the ViewModel stuff might not fully support Replace - so simulating with Remove and Insert int index = rootNode.Tables.IndexOf(this); rootNode.Tables.Remove(this); rootNode.Tables.Insert(index, clonedTable); } foreach (var bindingItem in tableTemplate.UnboundReferences) { var clonedBindingItem = new BindingItem( bindingItem.BoundProperty, bindingItem.XObject, bindingItem.XValue, clonedMapping[bindingItem.ParentItem], bindingItem.BimlFile, this); unboundReferences.Add(clonedBindingItem); } }
public override object Execute(SymbolTable table) { base.Execute(table); StatementList.Execute(table); return null; }
public ReplWindow() { this.Width = 450; this.Height = 350; this.Title = "YACQ Console"; this.Content = this.textBox; this.textBox.AcceptsReturn = true; this.textBox.BorderThickness = new Thickness(0); this.textBox.FontFamily = new FontFamily("Consolas"); this.textBox.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled; this.textBox.VerticalScrollBarVisibility = ScrollBarVisibility.Visible; this.textBox.TextWrapping = TextWrapping.Wrap; this.textBox.Text = string.Format("YACQ {0} on Krile {1}\r\n", YacqServices.Version, typeof(App).Assembly.GetName().Version); this.textBox.Select(this.textBox.Text.Length, 0); this.textBox.PreviewKeyDown += this.textBox_PreviewKeyDown; this.symbolTable = new SymbolTable(typeof(Symbols)) { {"*textbox*", YacqExpression.Constant(textBox)}, }; var rcPath = Path.Combine( Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "yacq_lib\\rc.yacq" ); if(File.Exists(rcPath)) { YacqServices.ParseAll(this.symbolTable, File.ReadAllText(rcPath)) .ForEach(e => YacqExpression.Lambda(e).Compile().DynamicInvoke()); this.textBox.AppendText("rc.yacq was loaded.\r\n"); } this.textBox.AppendText(">>> "); }
public void Instantiate(SymbolTable symbolTable, UnboundReferences unboundReferences) { var parentContainer = ParentItem as AstContainerTaskBaseNode; var taskTemplate = Template as AstTaskTemplateNode; var clonedMapping = new Dictionary<IFrameworkItem, IFrameworkItem>(); if (taskTemplate != null && parentContainer != null) { var clonedTasks = new List<AstTaskNode>(); foreach (var task in taskTemplate.Tasks) { clonedTasks.Add((AstTaskNode)task.Clone(parentContainer, clonedMapping)); } parentContainer.Tasks.Replace(this, clonedTasks); } foreach (var bindingItem in taskTemplate.UnboundReferences) { var clonedBindingItem = new BindingItem( bindingItem.BoundProperty, bindingItem.XObject, bindingItem.XValue, clonedMapping[bindingItem.ParentItem], bindingItem.BimlFile, this); unboundReferences.Add(clonedBindingItem); } }
public override void GenerateCode(FileManager fileManager, SymbolTable symbolTable, CodeGeneratorHelper codeGeneratorHelper) { AppendNodeComment(fileManager); // Check condition this._children[0].GenerateCode(fileManager, symbolTable, codeGeneratorHelper); // If the condition is false, jump to the else-statement (exit label if else-statement is null) string elseLabel = codeGeneratorHelper.GenerateNextLabel(); fileManager.Output.Append(Macro.JumpOnFalse(elseLabel)); // Then-statement this._children[1].GenerateCode(fileManager, symbolTable, codeGeneratorHelper); // On existing else-statement jump over it string outLabel = null; if (this._children[2] != null) { outLabel = codeGeneratorHelper.GenerateNextLabel(); fileManager.Output.Append(Macro.Jump(outLabel)); } // Generate else label fileManager.Output.Append(Macro.Label(elseLabel)); // Else-statement and exit label if (this._children[2] != null) { this._children[2].GenerateCode(fileManager, symbolTable, codeGeneratorHelper); fileManager.Output.Append(Macro.Label(outLabel)); } }
public override void GenerateCode(FileManager fileManager, SymbolTable symbolTable, CodeGeneratorHelper codeGeneratorHelper) { AppendNodeComment(fileManager); // Initialization assignment this._children[0].GenerateCode(fileManager, symbolTable, codeGeneratorHelper); // Generate loop start label string startLabel = codeGeneratorHelper.GenerateNextLabel(); fileManager.Output.Append(Macro.Label(startLabel)); // Check condition and jump out if false this._children[1].GenerateCode(fileManager, symbolTable, codeGeneratorHelper); string outLabel = codeGeneratorHelper.GenerateNextLabel(); fileManager.Output.Append(Macro.JumpOnFalse(outLabel)); // Loop body this._children[3].GenerateCode(fileManager, symbolTable, codeGeneratorHelper); // Altering assignment this._children[2].GenerateCode(fileManager, symbolTable, codeGeneratorHelper); // Jump back to condition check fileManager.Output.Append(Macro.Jump(startLabel)); // Generate loop end label fileManager.Output.Append(Macro.Label(outLabel)); }
public static EvalResult evaluate_System_Function(SymbolTable symbols, FunCall fun_call) { var fun_name = fun_call.value.value; EvalFunc f = (s,func) => new EvalResult(new Error(fun_call.value.line_num, "Could not match system function!")); switch (fun_name) { case "define": f = add_definition; break; case "+": f = addition; break; case "-": f = subtraction; break; case "*": f = multiplication; break; case "/": f = division; break; case "%": f = mod; break; case "head": f = head; break; case "tail": f = tail; break; case "++": f = cons; break; case "==": f = equality_test; break; case "not": f = not; break; case "&&": f = logical_and; break; case "||": f = logical_or; break; case "<": f = less_than; break; case ">": f = greater_than; break; } return f(symbols, fun_call); }
public void CreateProgram(string moduleName) { AssemblyName name = new AssemblyName(Path.GetFileNameWithoutExtension(moduleName)); var asmb = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Save); ModuleBuilder modb = asmb.DefineDynamicModule(moduleName); var type = modb.DefineType("$program"); var symbolTable = new SymbolTable(type); symbolTable.AddFunctionHeader("$main", MethodAttributes.Static, null, new FunctionDefinition.Argument[] { },"$program"); var il = symbolTable.functionTable["$main"].GetILGenerator(); Program.GenerateIL(il, symbolTable); il.Emit(OpCodes.Ret); modb.CreateGlobalFunctions(); asmb.SetEntryPoint(symbolTable.functionTable["$main"].methodDefinition); symbolTable.typeTable.types[0].typeBuilder.CreateType(); asmb.Save(moduleName); }
public static void ProcessIsNullPatcherTransformations(SymbolTable symbolTable) { var snapshotSymbolTable = new List<IReferenceableItem>(symbolTable); foreach (var astNamedNode in snapshotSymbolTable) { var nullPatcherNode = astNamedNode as AstIsNullPatcherNode; if (nullPatcherNode != null && astNamedNode.FirstThisOrParent<ITemplate>() == null) { var astDerivedColumnListNode = new AstDerivedColumnListNode(nullPatcherNode.ParentItem) { Name = nullPatcherNode.Name, ValidateExternalMetadata = nullPatcherNode.ValidateExternalMetadata }; foreach (AstIsNullPatcherColumnNode patchColumn in nullPatcherNode.Columns) { var column = new AstDerivedColumnNode(astDerivedColumnListNode) { Name = patchColumn.Name, ReplaceExisting = true, Expression = String.Format(CultureInfo.InvariantCulture, "ISNULL({0}) ? {1} : {0}", patchColumn.Name, patchColumn.DefaultValue), DerivedColumnType = VulcanEngine.IR.Ast.ColumnType.Object }; astDerivedColumnListNode.Columns.Add(column); } Utility.Replace(nullPatcherNode, new List<AstTransformationNode> { astDerivedColumnListNode }); } } }
private void Check(CodeElement e, SymbolTable table, FunctionCall call, FunctionDeclaration definition) { var parameters = definition.Profile.Parameters; if (call.InputParameters.Count > parameters.Count) { var m = System.String.Format("Function {0} only takes {1} parameters", definition.Name, parameters.Count); DiagnosticUtils.AddError(e, m); } for (int c = 0; c < parameters.Count; c++) { var expected = parameters[c]; if (c < call.InputParameters.Count) { var actual = call.InputParameters[c]; if (actual.IsLiteral) continue; var found = table.GetVariable(new URI(actual.Value)); if (found.Count < 1) DiagnosticUtils.AddError(e, "Parameter "+actual.Value+" is not referenced"); if (found.Count > 1) DiagnosticUtils.AddError(e, "Ambiguous reference to parameter "+actual.Value); if (found.Count!= 1) continue; var type = found[0] as Typed; // type check. please note: // 1- if only one of [actual|expected] types is null, overriden DataType.!= operator will detect it // 2- if both are null, we WANT it to break: in TypeCobol EVERYTHING should be typed, // and things we cannot know their type as typed as DataType.Unknown (which is a non-null valid type). if (type == null || type.DataType != expected.DataType) { var m = System.String.Format("Function {0} expected parameter {1} of type {2} (actual: {3})", definition.Name, c+1, expected.DataType, type.DataType); DiagnosticUtils.AddError(e, m); } if (type != null && type.Length > expected.Length) { var m = System.String.Format("Function {0} expected parameter {1} of max length {2} (actual: {3})", definition.Name, c+1, expected.Length, type.Length); DiagnosticUtils.AddError(e, m); } } else { var m = System.String.Format("Function {0} is missing parameter {1} of type {2}", definition.Name, c+1, expected.DataType); DiagnosticUtils.AddError(e, m); } } }
public override void GenerateIL(ILGenerator il, SymbolTable st) { LocalSymbolTable = new SymbolTable(st); foreach(var statement in Block) { statement.GenerateIL(il, LocalSymbolTable); } }
public override void GenerateCode(FileManager fileManager, SymbolTable symbolTable, CodeGeneratorHelper labelHelper) { AppendNodeComment(fileManager); SyntaxTreeDeclarationNode declNode = symbolTable.GetDeclarationNodeLinkToSymbol(this.Identifier) as SyntaxTreeDeclarationNode; fileManager.Output.Append(Macro.LoadAccu(declNode.GetMemoryAddress())); }
public Context() { SourceCode = String.Empty; GlobalVarList = null; execFlagList = null; symbolTable = null; exprExecutionFlags = new Dictionary<int, bool>(); }
public void Is_In_Table_Test() { symbolTable = new SymbolTable(); AddValue_Correct_Test(); Assert.IsTrue(symbolTable.IsInTable(id)); }
public virtual void GenerateCode(FileManager fileManager, SymbolTable symbolTable, CodeGeneratorHelper labelHelper) { foreach (var node in this._children) { if (node != null) node.GenerateCode(fileManager, symbolTable, labelHelper); } }
public override TreeNode GetAstCodeGenerator(SymbolTable t) { MIPSCodeGenerator.Loop w = new MIPSCodeGenerator.Loop((MIPSCodeGenerator.Expression)condition.GetAstCodeGenerator(t), (MIPSCodeGenerator.Expression)body.GetAstCodeGenerator(t)); SetGeneratorType(w); return(w); }
public override dynamic Evaluate(SymbolTable table) { return(LeftNode.Evaluate(table) % RightNode.Evaluate(table)); }
/// <summary> /// Adds a label (an integer value) to the symbol table and to the graph element. /// </summary> /// <param name="table"> the symbol table </param> /// <param name="code"> a label code </param> /// <exception cref="MaltChainedException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void addLabel(org.maltparser.core.symbol.SymbolTable table, int code) throws org.maltparser.core.exception.MaltChainedException public void addLabel(SymbolTable table, int code) { addLabel(table, table.getSymbolCodeToString(code)); }
public ProgNodeContext() { this.SymTable = new SymbolTable(); }
public void Start(SymbolTable t) { }
private IFrontEndController CreateControllerWithDebugger(PathTable pathTable, SymbolTable symbolTable) { var confPort = Configuration.FrontEnd.DebuggerPort(); var debugServerPort = confPort != 0 ? confPort : DebugServer.DefaultDebugPort; var pathTranslator = GetPathTranslator(Configuration.Logging, pathTable); var debugServer = new DebugServer(LoggingContext, pathTable, pathTranslator, debugServerPort); Task <IDebugger> debuggerTask = debugServer.StartAsync(); var evaluationDecorator = new LazyDecorator(debuggerTask, Configuration.FrontEnd.DebuggerBreakOnExit()); var frontEndFactory = new FrontEndFactory(); frontEndFactory.AddPhaseStartHook(EnginePhases.Evaluate, () => { if (!debuggerTask.IsCompleted) { Logger.Log.WaitingForClientDebuggerToConnect(LoggingContext, debugServer.Port); } debuggerTask.Result?.Session.WaitSessionInitialized(); }); frontEndFactory.AddPhaseEndHook(EnginePhases.Evaluate, () => { // make sure the debugger is shut down at the end (unnecessary in most cases, as the debugger will shut itself down after completion) debugServer.ShutDown(); debuggerTask.Result?.ShutDown(); }); return(TryCreateFrontEndController( frontEndFactory, evaluationDecorator, Configuration, symbolTable, LoggingContext, Collector, collectMemoryAsSoonAsPossible: CollectMemoryAsSoonAsPossible, statistics: m_statistics)); }
private IFrontEndController CreateControllerWithProfiler(PathTable pathTable, SymbolTable symbolTable) { var frontEndFactory = new FrontEndFactory(); var profilerDecorator = new ProfilerDecorator(); // When evaluation is done we materialize the result of the profiler frontEndFactory.AddPhaseEndHook(EnginePhases.Evaluate, () => { var entries = profilerDecorator.GetProfiledEntries(); var materializer = new ProfilerMaterializer(pathTable); var reportDestination = Configuration.FrontEnd.ProfileReportDestination(pathTable); Logger.Log.MaterializingProfilerReport(LoggingContext, reportDestination.ToString(pathTable)); try { materializer.Materialize(entries, reportDestination); } catch (BuildXLException ex) { Logger.Log.ErrorMaterializingProfilerReport(LoggingContext, ex.LogEventErrorCode, ex.LogEventMessage); } }); return(TryCreateFrontEndController( frontEndFactory, profilerDecorator, Configuration, symbolTable, LoggingContext, Collector, collectMemoryAsSoonAsPossible: CollectMemoryAsSoonAsPossible, statistics: m_statistics)); }
public static bool TryFormat(this Guid value, Span <byte> buffer, out int bytesWritten, ParsedFormat format = default, SymbolTable symbolTable = null) => CustomFormatter.TryFormat(value, buffer, out bytesWritten, format, symbolTable);
internal DependencyGroupBuilder(SymbolTable scope) : base(scope) { }
public bool TryFormat(Span <byte> buffer, out int bytesWritten, ParsedFormat format, SymbolTable symbolTable) { if (!PrimitiveFormatter.TryFormat(_age, buffer, out bytesWritten, format, symbolTable)) { return(false); } char symbol = _inMonths ? 'm' : 'y'; if (!symbolTable.TryEncode((byte)symbol, buffer.Slice(bytesWritten), out int written)) { return(false); } bytesWritten += written; return(true); }
internal void SetSymbolTable(SymbolTable symbolTable) { RuntimeBinderSymbolTable = symbolTable; }
static void Validate <T>(long value, StandardFormat format, SymbolTable symbolTable) { Validate <T>(unchecked ((ulong)value), format, symbolTable); }
public void SetUp() { IBlacklistManager blacklistManager = new IDbCommandBlacklistManagerStub(); _symbolTable = new SymbolTable(blacklistManager); }
public PipelineTextOutput(PipeWriter writer, SymbolTable symbolTable) { _writer = writer; SymbolTable = symbolTable; }
public StylesheetTask(string stylesheetText, SymbolTable symbolTable) { StylesheetText = stylesheetText; QLSymbolTable = symbolTable; }
public abstract object Eval(SymbolTable vartable);
public void EscapeScope(SymbolTable t) { }
public void EscapeScope(SymbolTable t) { IntermediateCode.CurrentIO.EmitBlock("}"); }
public void ProcessDeclaration(Decl declaration, IPlatform platform, TypeLibraryDeserializer tldser, SymbolTable symbolTable) { var types = symbolTable.AddDeclaration(declaration); var type = types[0]; int?vectorOffset = GetVectorOffset(declaration); if (vectorOffset.HasValue) { var ntde = new NamedDataTypeExtractor(platform, declaration.decl_specs, symbolTable); foreach (var declarator in declaration.init_declarator_list) { var nt = ntde.GetNameAndType(declarator.Declarator); var ssig = (SerializedSignature)nt.DataType; if (ssig.ReturnValue != null) { ssig.ReturnValue.Kind = ntde.GetArgumentKindFromAttributes( "returns", declaration.attribute_list); } var sser = new ProcedureSerializer(platform, tldser, platform.DefaultCallingConvention); var sig = sser.Deserialize(ssig, platform.Architecture.CreateFrame()); SystemServices.Add( vectorOffset.Value, new SystemService { Name = nt.Name, SyscallInfo = new SyscallInfo { Vector = vectorOffset.Value, }, Signature = sig, }); } } }
public ExpNameDiscovery(SymbolTable syms) { this.syms = syms; }
public TemplateContext() { _globalSymbolTable = new SymbolTable(); _symbolTablestack.Push(_globalSymbolTable); _astGeneratorFunc = (snippet, errorfn) => new CachingLiquidASTGenerator(new LiquidASTGenerator()).Generate(snippet, errorfn); }
public static void CupParseProgramOrClass(TextSourceInfo textSourceInfo, ISearchableReadOnlyList <CodeElementsLine> codeElementsLines, TypeCobolOptions compilerOptions, SymbolTable customSymbols, PerfStatsForParserInvocation perfStatsForParserInvocation, out SourceFile root, out List <Diagnostic> diagnostics, out Dictionary <CodeElement, Node> nodeCodeElementLinkers) { PrepareCupParser(); #if DEBUG_ANTRL_CUP_TIME var t1 = DateTime.UtcNow; #endif CodeElementTokenizer scanner = new CodeElementTokenizer(codeElementsLines); CupParser.TypeCobolProgramParser parser = new CupParser.TypeCobolProgramParser(scanner); CupParserTypeCobolProgramDiagnosticErrorReporter diagReporter = new CupParserTypeCobolProgramDiagnosticErrorReporter(); parser.ErrorReporter = diagReporter; ProgramClassBuilder builder = new ProgramClassBuilder(); parser.Builder = builder; ParserDiagnostic programClassBuilderError = null; builder.SyntaxTree = new SyntaxTree <CodeElement>(); //Initializie SyntaxTree for the current source file builder.CustomSymbols = customSymbols; builder.Dispatcher = new NodeDispatcher <CodeElement>(); builder.Dispatcher.CreateListeners(); // Try to parse a Cobol program or class, with cup w are also building the The Syntax Tree Node perfStatsForParserInvocation.OnStartParsing(); try { TUVienna.CS_CUP.Runtime.Symbol symbol = parser.parse(); } catch (Exception ex) { var code = Diagnostics.MessageCode.ImplementationError; programClassBuilderError = new ParserDiagnostic(ex.ToString(), null, null, code, ex); } perfStatsForParserInvocation.OnStopParsing(0, 0); #if DEBUG_ANTRL_CUP_TIME var t2 = DateTime.UtcNow; var t = t2 - t1; System.Diagnostics.Debug.WriteLine("Time[" + textSourceInfo.Name + "];" + t.Milliseconds); #endif root = builder.SyntaxTree.Root; //Set output root node perfStatsForParserInvocation.OnStartTreeBuilding(); //Create link between data definition an Types, will be stored in SymbolTable root.AcceptASTVisitor(new TypeCobolLinker()); //Stop measuring tree building performance perfStatsForParserInvocation.OnStopTreeBuilding(); // Register compiler results diagnostics = diagReporter.Diagnostics ?? new List <Diagnostic>(); nodeCodeElementLinkers = builder.NodeCodeElementLinkers; if (programClassBuilderError != null) { diagnostics.Add(programClassBuilderError); } }
public FhirPathCompiler(SymbolTable symbols) { Symbols = symbols; }
public static bool TryParseUInt16(ReadOnlySpan <byte> text, out ushort value, out int bytesConsumed, StandardFormat format = default, SymbolTable symbolTable = null) { symbolTable = symbolTable ?? SymbolTable.InvariantUtf8; if (!format.IsDefault && format.HasPrecision) { throw new NotImplementedException("Format with precision not supported."); } if (symbolTable == SymbolTable.InvariantUtf8) { if (Parsers.IsHexFormat(format)) { return(Utf8Parser.TryParse(text, out value, out bytesConsumed, 'X')); } else { return(Utf8Parser.TryParse(text, out value, out bytesConsumed)); } } else if (symbolTable == SymbolTable.InvariantUtf16) { ReadOnlySpan <char> utf16Text = text.NonPortableCast <byte, char>(); int charactersConsumed; bool result; if (Parsers.IsHexFormat(format)) { result = Utf16Parser.Hex.TryParseUInt16(utf16Text, out value, out charactersConsumed); } else { result = Utf16Parser.TryParseUInt16(utf16Text, out value, out charactersConsumed); } bytesConsumed = charactersConsumed * sizeof(char); return(result); } if (Parsers.IsHexFormat(format)) { throw new NotImplementedException("The only supported encodings for hexadecimal parsing are InvariantUtf8 and InvariantUtf16."); } if (!(format.IsDefault || format.Symbol == 'G' || format.Symbol == 'g')) { throw new NotImplementedException(String.Format("Format '{0}' not supported.", format.Symbol)); } if (!symbolTable.TryParse(text, out SymbolTable.Symbol nextSymbol, out int thisSymbolConsumed)) { value = default; bytesConsumed = 0; return(false); } if (nextSymbol > SymbolTable.Symbol.D9) { value = default; bytesConsumed = 0; return(false); } uint parsedValue = (uint)nextSymbol; int index = thisSymbolConsumed; while (index < text.Length) { bool success = symbolTable.TryParse(text.Slice(index), out nextSymbol, out thisSymbolConsumed); if (!success || nextSymbol > SymbolTable.Symbol.D9) { bytesConsumed = index; value = (ushort)parsedValue; return(true); } // If parsedValue > (ushort.MaxValue / 10), any more appended digits will cause overflow. // if parsedValue == (ushort.MaxValue / 10), any nextDigit greater than 5 implies overflow. if (parsedValue > ushort.MaxValue / 10 || (parsedValue == ushort.MaxValue / 10 && nextSymbol > SymbolTable.Symbol.D5)) { bytesConsumed = 0; value = default; return(false); } index += thisSymbolConsumed; parsedValue = parsedValue * 10 + (uint)nextSymbol; } bytesConsumed = text.Length; value = (ushort)parsedValue; return(true); }
/// <summary> /// Initializes dictionary and sets the SymbolTable instance to use /// </summary> /// <param name="symbolTable">Used to convert between strings and FullSymbols</param> /// <param name="concurrencyLevel">This setting affects the number of locks that the dictionary is using; default value is 32</param> /// <param name="initialCapacity">Initial capacity of the collection; default value is 31</param> public FullSymbolConcurrentDictionary(SymbolTable symbolTable, int concurrencyLevel = 32, int initialCapacity = 31) { m_fullSymbolsToValues = new ConcurrentDictionary <FullSymbol, TValue>(concurrencyLevel, initialCapacity); m_symbolTable = symbolTable; }
static void Run(CodeGeneratorOptions options, DirectoryAssemblyResolver resolver) { string assemblyQN = options.AssemblyQualifiedName; string api_level = options.ApiLevel; int product_version = options.ProductVersion; bool preserve_enums = options.PreserveEnums; string csdir = options.ManagedCallableWrapperSourceOutputDirectory ?? "cs"; string javadir = "java"; string enumdir = options.EnumOutputDirectory ?? "enum"; string enum_metadata = options.EnumMetadataOutputFile ?? "enummetadata"; var references = options.AssemblyReferences; string enum_fields_map = options.EnumFieldsMapFile; string enum_flags = options.EnumFlagsFile; string enum_methods_map = options.EnumMethodsMapFile; var fixups = options.FixupFiles; string api_versions_xml = options.ApiVersionsXmlFile; var annotations_zips = options.AnnotationsZipFiles; string filename = options.ApiDescriptionFile; string mapping_file = options.MappingReportFile; bool only_xml_adjuster = options.OnlyRunApiXmlAdjuster; string api_xml_adjuster_output = options.ApiXmlAdjusterOutput; var apiSource = ""; var opt = new CodeGenerationOptions() { CodeGenerationTarget = options.CodeGenerationTarget, UseGlobal = options.GlobalTypeNames, IgnoreNonPublicType = true, UseShortFileNames = options.UseShortFileNames, ProductVersion = options.ProductVersion }; // Load reference libraries foreach (var lib in options.LibraryPaths) { resolver.SearchDirectories.Add(lib); } foreach (var reference in references) { resolver.SearchDirectories.Add(Path.GetDirectoryName(reference)); } foreach (var reference in references) { try { Report.Verbose(0, "resolving assembly {0}.", reference); var assembly = resolver.Load(reference); foreach (var md in assembly.Modules) { foreach (var td in md.Types) { // FIXME: at some stage we want to import generic types. // For now generator fails to load generic types that have conflicting type e.g. // AdapterView`1 and AdapterView cannot co-exist. // It is mostly because generator primarily targets jar (no real generics land). if (td.HasGenericParameters && md.GetType(td.FullName.Substring(0, td.FullName.IndexOf('`'))) != null) { continue; } ProcessReferencedType(td, opt); } } } catch (Exception ex) { Report.Warning(0, Report.WarningCodeGenerator + 0, ex, "failed to parse assembly {0}: {1}", reference, ex.Message); } } // For class-parse API description, transform it to jar2xml style. string apiXmlFile = filename; string apiSourceAttr = null; using (var xr = XmlReader.Create(filename)) { xr.MoveToContent(); apiSourceAttr = xr.GetAttribute("api-source"); } if (apiSourceAttr == "class-parse") { apiXmlFile = api_xml_adjuster_output ?? Path.Combine(Path.GetDirectoryName(filename), Path.GetFileName(filename) + ".adjusted"); new Adjuster().Process(filename, SymbolTable.AllRegisteredSymbols().OfType <GenBase> ().ToArray(), apiXmlFile); } if (only_xml_adjuster) { return; } // load XML API definition with fixups. Dictionary <string, EnumMappings.EnumDescription> enums = null; EnumMappings enummap = null; if (enum_fields_map != null || enum_methods_map != null) { enummap = new EnumMappings(enumdir, enum_metadata, api_level, preserve_enums); enums = enummap.Process(enum_fields_map, enum_flags, enum_methods_map); fixups.Add(enum_metadata); } Parser p = new Parser(); List <GenBase> gens = p.Parse(apiXmlFile, fixups, api_level, product_version); if (gens == null) { return; } apiSource = p.ApiSource; opt.Gens = gens; // disable interface default methods here, especially before validation. foreach (var gen in gens) { gen.StripNonBindables(); } Validate(gens, opt); if (api_versions_xml != null) { ApiVersionsSupport.AssignApiLevels(gens, api_versions_xml, api_level); } foreach (GenBase gen in gens) { gen.FillProperties(); } foreach (var gen in gens) { gen.UpdateEnums(opt); } foreach (GenBase gen in gens) { gen.FixupMethodOverrides(); } foreach (GenBase gen in gens) { gen.FixupExplicitImplementation(); } GenerateAnnotationAttributes(gens, annotations_zips); //SymbolTable.Dump (); GenerationInfo gen_info = new GenerationInfo(csdir, javadir, assemblyQN); opt.AssemblyName = gen_info.Assembly; if (mapping_file != null) { GenerateMappingReportFile(gens, mapping_file); } new NamespaceMapping(gens).Generate(opt, gen_info); foreach (IGeneratable gen in gens) { if (gen.IsGeneratable) { gen.Generate(opt, gen_info); } } ClassGen.GenerateTypeRegistrations(opt, gen_info); ClassGen.GenerateEnumList(gen_info); // Create the .cs files for the enums var enumFiles = enums == null ? null : enummap.WriteEnumerations(enumdir, enums, FlattenNestedTypes(gens).ToArray(), opt.UseShortFileNames); gen_info.GenerateLibraryProjectFile(options, enumFiles); }
private static IFrontEndController TryCreateFrontEndController( FrontEndFactory frontEndFactory, IDecorator <EvaluationResult> decorator, ICommandLineConfiguration configuration, SymbolTable symbolTable, LoggingContext loggingContext, PerformanceCollector collector, bool collectMemoryAsSoonAsPossible, IFrontEndStatistics statistics) { Contract.Requires(frontEndFactory != null && !frontEndFactory.IsSealed); var workspaceResolverFactory = new DScriptWorkspaceResolverFactory(); // Statistic should be global for all front-ends, not per an instance. var frontEndStatistics = statistics ?? new FrontEndStatistics(); var sharedModuleRegistry = new ModuleRegistry(symbolTable); // Note, that the following code is absolutely critical for detecting that front-end related objects // are freed successfully after evaluation. // ModuleRegistry was picked intentionally because it holds vast amount of front-end data. FrontEndControllerMemoryObserver.CaptureFrontEndReference(sharedModuleRegistry); frontEndFactory.SetConfigurationProcessor( new ConfigurationProcessor( new FrontEndStatistics(), // Configuration processing is so lightweight that it won't affect overall perf statistics logger: null)); var msBuildFrontEnd = new MsBuildFrontEnd(); var ninjaFrontEnd = new NinjaFrontEnd(); var cmakeFrontEnd = new CMakeFrontEnd(); // TODO: Workspace resolvers and frontends are registered in separate factories. Consider // adding a main coordinator/registry RegisterKnownWorkspaceResolvers( symbolTable.StringTable, workspaceResolverFactory, frontEndStatistics); frontEndFactory.AddFrontEnd(new DScriptFrontEnd( frontEndStatistics, evaluationDecorator: decorator)); frontEndFactory.AddFrontEnd(new NugetFrontEnd( frontEndStatistics, evaluationDecorator: decorator)); frontEndFactory.AddFrontEnd(new DownloadFrontEnd()); frontEndFactory.AddFrontEnd(msBuildFrontEnd); frontEndFactory.AddFrontEnd(ninjaFrontEnd); frontEndFactory.AddFrontEnd(cmakeFrontEnd); if (!frontEndFactory.TrySeal(loggingContext)) { return(null); } return(new FrontEndHostController( frontEndFactory, workspaceResolverFactory, evaluationScheduler: EvaluationScheduler.Default, moduleRegistry: sharedModuleRegistry, frontEndStatistics: frontEndStatistics, logger: BuildXL.FrontEnd.Core.Tracing.Logger.CreateLogger(), collector: collector, collectMemoryAsSoonAsPossible: collectMemoryAsSoonAsPossible)); }
public override IFrameworkItem Clone(IFrameworkItem parentItem, Dictionary <IFrameworkItem, IFrameworkItem> cloneMapping) { SymbolTable.GetSourceToCloneDefinitionMappings(this, parentItem, cloneMapping); CloneInto(cloneMapping[this], cloneMapping); return(cloneMapping[this]); }
public ClassValidationVisitor(MessageLog log, SymbolTable symbols) { Log = log; Symbols = symbols; Success = true; }
public void PopulateSymbolTableWithName(Type callingType, ArgumentObject[] arguments) => SymbolTable.PopulateSymbolTableWithName(SpecialNames.Indexer, null, arguments[0].Type);