public TokenStream(StructList <ExpressionToken> tokens) { this.ptr = 0; this.tokens = tokens; this.lastTokenIndex = tokens.Count; this.stack = StackPool <int> .Get(); }
public void ReplaceItem_ShouldThrowIfItemDoesNotExistInCollection() { var list = GetNewList(10); var replaceList = new StructList <DummyClass>(); Assert.Throws <ArgumentOutOfRangeException>(() => list.ReplaceItemAt(11, replaceList)); }
public UIForiaGeometry() { this.positionList = new StructList <Vector3>(); this.texCoordList0 = new StructList <Vector4>(); this.texCoordList1 = new StructList <Vector4>(); this.triangleList = new StructList <int>(); }
public void Tokenize_Operators() { string input = "+"; StructList <ExpressionToken> tokens = ExpressionTokenizer.Tokenize(input); Assert.AreEqual(1, tokens.Count); Assert.AreEqual(ExpressionTokenType.Plus, tokens[0].expressionTokenType); input = "-"; tokens = ExpressionTokenizer.Tokenize(input); Assert.AreEqual(1, tokens.Count); Assert.AreEqual(ExpressionTokenType.Minus, tokens[0].expressionTokenType); input = "*"; tokens = ExpressionTokenizer.Tokenize(input); Assert.AreEqual(1, tokens.Count); Assert.AreEqual(ExpressionTokenType.Times, tokens[0].expressionTokenType); input = "/"; tokens = ExpressionTokenizer.Tokenize(input); Assert.AreEqual(1, tokens.Count); Assert.AreEqual(ExpressionTokenType.Divide, tokens[0].expressionTokenType); input = "%"; tokens = ExpressionTokenizer.Tokenize(input); Assert.AreEqual(1, tokens.Count); Assert.AreEqual(ExpressionTokenType.Mod, tokens[0].expressionTokenType); }
internal void TransformList <T>(ref StructList <T> list) where T : AstNode { for (var i = 0; i < list.Count; i++) { var originalNode = list[i]; var item = Transform(originalNode, true); if (item == Remove) { list.RemoveAt(i); Modified = true; i--; } else if (item is AstSpreadStructList <T> spreadList) { list.ReplaceItemAt(i, spreadList.NodeList); Modified = true; } else { if (originalNode != item) { Modified = true; } list[i] = (T)item; } } }
public TemplateScope(Application application) { this.application = application; this.slotInputs = null; this.parentInputs = null; this.innerSlotContext = null; }
public TokenStream AdvanceAndReturnSubStream(int advance) { StructList <ExpressionToken> subStreamTokens = tokens.GetRange(ptr, advance); Advance(advance); return(new TokenStream(subStreamTokens)); }
private ASTNode ParseInternal(string input) { tokenStream = new TokenStream(ExpressionTokenizer.Tokenize(input, StructList <ExpressionToken> .Get())); expressionStack = expressionStack ?? StackPool <ASTNode> .Get(); operatorStack = operatorStack ?? StackPool <OperatorNode> .Get(); if (tokenStream.Current == ExpressionTokenType.ExpressionOpen) { tokenStream.Advance(); } if (!tokenStream.HasMoreTokens) { throw new ParseException("Failed trying to parse empty expression"); } if (tokenStream.Last == ExpressionTokenType.ExpressionClose) { tokenStream.Chop(); } ASTNode retn = ParseLoop(); Release(); return(retn); }
private void ProcessKeyboardEvents() { StructList <KeyCodeState> keyCodeStates = m_KeyboardState.GetKeyCodeStates(); for (int i = 0; i < keyCodeStates.size; i++) { KeyCodeState keyCodeState = keyCodeStates[i]; InputEventType inputEventType; if (keyCodeState.keyState == KeyState.DownThisFrame) { inputEventType = InputEventType.KeyDown; } else if (keyCodeState.keyState == KeyState.Down) { inputEventType = InputEventType.KeyHeldDown; } else { inputEventType = InputEventType.KeyUp; } ProcessKeyboardEvent(keyCodeState.keyCode, inputEventType, keyCodeState.character, m_KeyboardState.modifiersThisFrame); } }
public IBrowserProcess Create(string urlToOpen) { var browserPathsToRun = new StructList <string>(); var headlessOverride = Environment.GetEnvironmentVariable("BBBROWSER"); if (headlessOverride != null) { browserPathsToRun.AddUnique(headlessOverride); } if (!_fsAbstraction.IsUnixFs && _strategy == "PreferFirefoxOnWindows") { var browserPath = BrowserPathFinder.GetBrowserPath(_fsAbstraction, true); if (browserPath != null) { browserPathsToRun.AddUnique(browserPath); } } if (browserPathsToRun.Count == 0) { var browserPath = BrowserPathFinder.GetBrowserPath(_fsAbstraction, false); if (browserPath != null) { browserPathsToRun.AddUnique(browserPath); } } if (browserPathsToRun.Count == 0) { throw new Exception("Cannot find browser on common known paths, use BBBROWSER environmental variable to define path to browser."); } return(new BrowserProcessFactory(_inDocker, browserPathsToRun[0]).Create(urlToOpen)); }
internal ClipData(UIElement element) { this.element = element; intersected = new StructList <Vector2>(); dependents = new LightList <ClipData>(); clipList = new StructList <ElemRef>(); }
// this might be getting called too many times since im not sure im caching the result private void ParseContentTemplate(TemplateRootNode templateRootNode, TemplateShell shell, ProcessedType processedType) { XElement root = shell.GetElementTemplateContent(processedType.templateAttr.templateId); if (root == null) { throw new TemplateNotFoundException(processedType.templateAttr.filePath, processedType.templateAttr.templateId); } IXmlLineInfo xmlLineInfo = root; StructList <AttributeDefinition> attributes = StructList <AttributeDefinition> .Get(); StructList <AttributeDefinition> injectedAttributes = StructList <AttributeDefinition> .Get(); ParseAttributes(shell, "Contents", root.Attributes(), attributes, injectedAttributes, out string genericTypeResolver, out string requireType); if (attributes.size == 0) { StructList <AttributeDefinition> .Release(ref attributes); } if (injectedAttributes.size == 0) { StructList <AttributeDefinition> .Release(ref injectedAttributes); } templateRootNode.attributes = ValidateRootAttributes(shell.filePath, attributes); templateRootNode.lineInfo = new TemplateLineInfo(xmlLineInfo.LineNumber, xmlLineInfo.LinePosition); templateRootNode.genericTypeResolver = genericTypeResolver; templateRootNode.requireType = requireType; // always null I think ParseChildren(templateRootNode, templateRootNode, root.Nodes()); }
public TypeBodyNode Parse(string input, string fileName, int lineStart) { tokenStream = new TokenStream(ExpressionTokenizer.Tokenize(input, StructList <ExpressionToken> .Get())); if (!tokenStream.HasMoreTokens) { throw new ParseException("Failed trying to parse empty expression"); } TypeBodyNode retn = new TypeBodyNode(); int cnt = 0; while (tokenStream.HasMoreTokens && cnt < 10000) { cnt++; ExpressionToken current = tokenStream.Current; ASTNode node = null; if (ParseDeclaration(ref node)) { retn.nodes.Add(node); continue; } if (current == tokenStream.Current) { throw new ParseException($"Failed to parse {fileName}. Got stuck on {current.value}"); } } return(retn); }
public void BreakCharacterGroupsIntoWords() { string input = "some text"; StructList <WordInfo> result = TextUtil.BreakIntoWords(input.ToCharArray()); WordInfo[] expected = { new WordInfo() { type = WordType.Normal, charStart = 0, charEnd = 4 }, new WordInfo() { type = WordType.Whitespace, charStart = 4, charEnd = 5 }, new WordInfo() { type = WordType.Normal, charStart = 5, charEnd = 9 } }; Assert.AreEqual(expected.Length, result.size); for (int i = 0; i < result.size; i++) { Assert.AreEqual(expected[i], result.array[i]); } }
public static StructList <AttributeDefinition> MergeSlotAttributes(StructList <AttributeDefinition> innerAttributes, SlotAttributeData slotAttributeData, StructList <AttributeDefinition> outerAttributes) { StructList <AttributeDefinition> retn = new StructList <AttributeDefinition>(); if (innerAttributes == null && outerAttributes == null) { retn = new StructList <AttributeDefinition>(); } if (innerAttributes != null) { retn.AddRange(innerAttributes); } if (outerAttributes != null) { for (int i = 0; i < outerAttributes.size; i++) { AttributeDefinition attrCopy = outerAttributes[i]; attrCopy.slotAttributeData = slotAttributeData; retn.Add(attrCopy); } } return(retn); }
public void SetSDFData(UIForiaData data, StructList <Matrix4x4> matrices) { Array.Copy(matrices.array, 0, transformData, 0, matrices.size); Array.Copy(data.colors.array, 0, colorData, 0, data.colors.size); Array.Copy(data.objectData0.array, 0, objectData, 0, data.objectData0.size); Array.Copy(data.clipRects.array, 0, clipRects, 0, data.clipRects.size); matBlock.SetMatrixArray(s_TransformDataKey, transformData); matBlock.SetVectorArray(s_ColorDataKey, colorData); matBlock.SetVectorArray(s_ObjectDataKey, objectData); matBlock.SetVectorArray(s_ClipRectKey, clipRects); matBlock.SetFloat(s_DPIScaleKey, 1f / Application.dpiScaleFactor); if (data.mainTexture != null) { material.SetTexture(s_MainTextureKey, data.mainTexture); } if (data.clipTexture != null) { material.SetTexture(s_ClipTextureKey, data.clipTexture); } if (data.fontData.fontAsset != null) { FontData fontData = data.fontData; matBlock.SetVector(s_FontDataScales, new Vector4(fontData.gradientScale, fontData.scaleRatioA, fontData.scaleRatioB, fontData.scaleRatioC)); matBlock.SetVector(s_FontTextureSize, new Vector4(fontData.textureWidth, fontData.textureHeight, 0, 0)); matBlock.SetTexture(s_FontTexture, fontData.fontAsset.atlas); } }
public static IEnumerable <GridPoint2> GetEdgeFaces(GridPoint2 point) { var color = point.GetColor(2, 2, 2); var faces = new StructList <GridPoint2>(); switch (color) { case 0: //error! break; case 2: faces.Add(point + RectPoint.North); faces.Add(point + RectPoint.South); break; case 1: faces.Add(point + RectPoint.East); faces.Add(point + RectPoint.West); break; /*case 2: * faces.Add(point + RectPoint.NorthEast); * faces.Add(point + RectPoint.NorthWest); * faces.Add(point + RectPoint.SouthEast); * faces.Add(point + RectPoint.SouthWest); * break;*/ } return(faces); }
static AstNode RemoveUnreachableCode(AstFor forStatement, bool inList) { if (forStatement.Condition == null || TypeConverter.ToBoolean(forStatement.Condition.ConstValue() ?? AstTrue.Instance)) { return(forStatement); } var declarations = GetDeclarations(forStatement.Body); if (forStatement.Init == null) { return(declarations ?? Remove); } var statement = forStatement.Init is AstStatement ? forStatement.Init : new AstSimpleStatement(forStatement.Init); if (declarations == null) { return(statement); } var statements = new StructList <AstNode>(); statements.Add(statement); statements.Add(declarations); return(inList ? SpreadStructList(ref statements) : new AstBlock(forStatement) { Body = statements }); }
public AstCall(string?source, Position startLoc, Position endLoc, AstNode expression, ref StructList <AstNode> args, bool optional = false) : base(source, startLoc, endLoc) { Expression = expression; Optional = optional; Args.TransferFrom(ref args); }
public AstVar?GetAllDeclarationsAsVar() { if (_declarations.Count == 0) { return(null); } var varDefs = new StructList <AstVarDef>(); foreach (var astStatement in _declarations) { if (astStatement is AstVar astVar) { foreach (var astVarDef in astVar.Definitions) { if (astVarDef.Name is AstSymbolVar astSymbolVar) { astSymbolVar.Usage = SymbolUsage.Unknown; varDefs.Add(new(astSymbolVar)); } } } if (astStatement is AstLambda astLambda) { varDefs.Add(new(new AstSymbolVar(astLambda.Name !))); } } return(new(ref varDefs)); }
// Parse a list of variable declarations. void ParseVar(ref StructList <AstVarDef> declarations, bool isFor, VariableKind kind) { for (;;) { var startLocation = Start; var id = ParseVarId(kind); AstNode init = null; if (Eat(TokenType.Eq)) { init = ParseMaybeAssign(isFor); } else if (kind == VariableKind.Const && !(Type == TokenType.In || Options.EcmaVersion >= 6 && IsContextual("of"))) { Raise(Start, "Unexpected token"); } else if (!(id is AstSymbol) && !(isFor && (Type == TokenType.In || IsContextual("of")))) { Raise(_lastTokEnd, "Complex binding patterns require an initialization value"); } var decl = new AstVarDef(this, startLocation, _lastTokEnd, id, init); declarations.Add(decl); if (!Eat(TokenType.Comma)) { break; } } }
public AstImport(Parser parser, Position startLoc, Position endLoc, AstString moduleName, AstSymbolImport?importName, ref StructList <AstNameMapping> specifiers) : base(parser, startLoc, endLoc) { ModuleName = moduleName; ImportedName = importName; ImportedNames.TransferFrom(ref specifiers); }
public AstClass(Parser parser, Position startPos, Position endPos, AstSymbolDeclaration?name, AstNode?extends, ref StructList <AstObjectProperty> properties) : base(parser, startPos, endPos) { Name = name; Extends = extends; Properties.TransferFrom(ref properties); }
void InstrumentBlock(ref StructList <AstNode> block, bool seq = false) { var input = new StructList <AstNode>(); input.TransferFrom(ref block); block.Reserve(input.Count * 2); for (var i = 0; i < input.Count; i++) { var ii = input[i]; if (ShouldStatementCover(ii)) { var idx = _owner.LastIndex++; var call = new AstCall(new AstSymbolRef(_owner.FncNameStatement)); call.Args.Add(new AstNumber(idx)); if (seq) { block.Add(call); } else { block.Add(new AstSimpleStatement(call)); } _owner.GetForFile(ii.Source !) .AddInfo(new InstrumentedInfo(InstrumentedInfoType.Statement, idx, ii.Start, ii.End)); } ii = Transform(ii); block.Add(ii); } }
public void GetChangeHandlers(string memberName, StructList <PropertyChangeHandlerDesc> retn) { if (methods == null) { MethodInfo[] candidates = ReflectionUtil.GetInstanceMethods(rawType); for (int i = 0; i < candidates.Length; i++) { IEnumerable <OnPropertyChanged> attrs = candidates[i].GetCustomAttributes <OnPropertyChanged>(); methods = methods ?? new StructList <PropertyChangeHandlerDesc>(); foreach (OnPropertyChanged a in attrs) { methods.Add(new PropertyChangeHandlerDesc() { methodInfo = candidates[i], memberName = a.propertyName }); } } } if (methods == null) { return; } for (int i = 0; i < methods.size; i++) { if (methods.array[i].memberName == memberName) { retn.Add(methods[i]); } } }
void CompactOnePureValueFileIteration(ref StructList <uint> toRemoveFileIds) { _cancellation.ThrowIfCancellationRequested(); _writerBytesPerSecondLimiter = new BytesPerSecondLimiter(_keyValueDB.CompactorWriteBytesPerSecondLimit); var writer = _keyValueDB.StartPureValuesFile(out var valueFileId); var firstIteration = true; while (true) { var wastefulFileId = FindMostWastefulFile(firstIteration ? uint.MaxValue : _keyValueDB.MaxTrLogFileSize - writer.GetCurrentPositionWithoutWriter()); firstIteration = false; if (wastefulFileId == 0) { break; } MoveValuesContent(writer, wastefulFileId, valueFileId); if (_fileStats.GetOrFakeValueRef(wastefulFileId).IsFreeToDelete()) { toRemoveFileIds.Add(wastefulFileId); } _fileStats.GetOrFakeValueRef(wastefulFileId) = new FileStat(0); } var valueFile = _keyValueDB.FileCollection.GetFile(valueFileId); valueFile !.HardFlushTruncateSwitchToReadOnlyMode(); _keyValueDB.Logger?.CompactionCreatedPureValueFile(valueFileId, valueFile.GetSize(), (uint)_newPositionMap.Count, 28 * (ulong)_newPositionMap.EnsureCapacity(0) ); }
public override AstNode ShallowClone() { var prop = new StructList <AstObjectProperty>(); prop.AddRange(Properties); return(new AstClass(Source, Start, End, Name, Extends, ref prop)); }
public void Release() { StackPool <int> .Release(stack); StructList <ExpressionToken> .Release(ref tokens); stack = null; }
public TypeLookup(Type type) { this.resolvedType = type; this.typeName = null; this.namespaceName = null; this.generics = null; this.isArray = false; }
public GridTrack(GridTrackSize size) { this.size = size; this.position = 0; this.outputSize = 0; this.autoPlacementCursor = 0; this.spanningItems = StructList <int> .Get(); }