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();
}
