public override PathCond And(CachedAtom cond)
{
if (conds.Contains(cond.Negate()))
{
return(FALSE);
}
else
{
return(Make(AddItem(this.conds, cond)));
}
}
public void AddBody(SoftBody body)
{
if (body == null)
{
throw new ArgumentNullException("body", "body can't be null.");
}
if (softbodies.Contains(body))
{
throw new ArgumentException("The body was already added to the world.", "body");
}
this.softbodies.Add(body);
this.CollisionSystem.AddEntity(body);
events.RaiseAddedSoftBody(body);
foreach (Constraint constraint in body.EdgeSprings)
{
AddConstraint(constraint);
}
foreach (SoftBody.MassPoint massPoint in body.VertexBodies)
{
events.RaiseAddedRigidBody(massPoint);
rigidBodies.Add(massPoint);
}
}
public void AddBody(SoftBody body)
{
if (body == null)
{
throw new ArgumentNullException("body", "body can't be null.");
}
if (softbodies.Contains(body))
{
throw new ArgumentException("The body was already added to the world.", "body");
}
this.softbodies.Add(body);
this.CollisionSystem.AddEntity(body);
events.RaiseAddedSoftBody(body);
foreach (Constraint constraint in body.EdgeSprings)
{
CBFrame.Utils.Logger.Debug("line260 body2.linearVelocity:" + constraint.body2.linearVelocity + ",body1.linearVelocity:" + constraint.body1.linearVelocity);
AddConstraint(constraint);
}
foreach (SoftBody.MassPoint massPoint in body.VertexBodies)
{
events.RaiseAddedRigidBody(massPoint);
rigidBodies.Add(massPoint);
}
}
public static string NextUniqueString(this Random random, HashList <string> hash, int size, bool includeDigits = false)
{
char[] chars = new char[size];
char[] charSet = includeDigits ? StringGenerator.AsciiLetterOrDigit : StringGenerator.AsciiLetter;
int charSetLength = charSet.Length;
int count = 0;
string s;
do
{
if (count > 20)
{
count = 0;
size++;
chars = new char[size];
}
for (int i = 0; i < size; i++)
{
chars[i] = charSet[random.Next(0, charSetLength)];
}
s = new string(chars);
count++;
}while (hash.Contains(s));
return(s);
}
void AddAlert(TDBaseAlertData alert)
{
if (AlertDatasSet.Contains(alert))
{
return;
}
GameObject go = GOPool.Spawn();
BaseAlertItem alertItem = go.GetComponent <BaseAlertItem>();
alertItem.PUIView = this;
alertItem.CancleInit();
alertItem.Init(new UButtonData
{
Icon = () => alert.GetIcon(),
Bg = () => alert.GetBg(),
OnClick = (x, y) => alert.DoClick(x, y),
OnEnter = (x) => alert.DoEnter(),
OnShowActive = OnAlertShow,
});
alertItem.SetID(alert.ID);
alertItem.Show(true, true);
alertItem.RectTrans.position = StartPos.position;
ActiveItems.Add(alertItem);
AlertDatasSet.Add(alert);
}
public void Add(int id)
{
if (_list.Contains(id))
{
return;
}
_list.Add(id);
}
public override PathCond Or(PathCond other)
{
if (other is CachedAtom && conds.Contains(((CachedAtom)other).Negate()))
{
// Reduce Or(OR(...,e,...), NOT(e)) and Or(OR(...,NOT(e),...), e) to TRUE
return(TRUE);
}
else if (other is Disj)
{
HashList <PathCond> result = new HashList <PathCond>();
result.AddAll(conds);
foreach (PathCond cond in ((Disj)other).conds)
{
if (cond is CachedAtom && conds.Contains((cond as CachedAtom).Negate()))
{
// Reduce Or(OR(...,e,...),OR(...,NOT(e),...)) to TRUE
// and Or(OR(...,NOT(e),...),OR(...,e,...)) to TRUE
return(TRUE);
}
result.Add(cond);
}
return(Disj.Make(result.ToArray()));
}
else if (other is Conj)
{
if (((Conj)other).conds.Contains(this))
{
// Reduce (pi | (p1 & ... & pn)) to pi
return(this);
}
else
{
if (((Conj)other).conds.Any(cond => conds.Contains(cond)))
{
return(this);
}
}
return(Disj.Make(AddItem(this.conds, other)));
}
else
{
return(Disj.Make(AddItem(this.conds, other)));
}
}
internal IType RegisterArrayType(IType elementType)
{
var type = TypeFactory.MakeArray(elementType);
if (!_constructedTypes.Contains(type))
{
_constructedTypes.Add(type);
}
return(type);
}
public void Test_Contains_After_Remove()
{
var list = new HashList <int>
{
2
};
list.Remove(2);
Assert.AreEqual(false, list.Contains(2), "#0");
}
/// <summary>
/// Add a <see cref="Constraint"/> to the world.
/// </summary>
/// <param name="constraint">The constraint which should be removed.</param>
public void AddConstraint(Constraint constraint)
{
if (constraints.Contains(constraint))
{
throw new ArgumentException("The constraint was already added to the world.", "constraint");
}
constraints.Add(constraint);
islands.ConstraintCreated(constraint);
events.RaiseAddedConstraint(constraint);
}
/// <summary>
/// Adds a <see cref="RigidBody"/> to the world.
/// </summary>
/// <param name="body">The body which should be added.</param>
public void AddBody(RigidBody body)
{
if (body == null)
{
throw new ArgumentNullException("body", "body can't be null.");
}
if (rigidBodies.Contains(body))
{
throw new ArgumentException("The body was already added to the world.", "body");
}
events.RaiseAddedRigidBody(body);
this.CollisionSystem.AddEntity(body);
rigidBodies.Add(body);
}
public virtual void AddItem(C item)
{
PropertyDescriptor prop = TypeDescriptor.GetProperties(item).Find("Oid", false);
this.Add(item);
long oid = (long)prop.GetValue(item);
while (HashList.Contains(oid) && item.IsNew)
{
Random r = new Random();
oid = (long)r.Next();
item.Oid = oid;
}
HashList.Add(oid, item);
}
public string GenerateString()
{
string s;
do
{
if (_stringIndex < _strings.Count)
{
s = _strings[_stringIndex];
}
else
{
s = GenerateNextString();
}
_stringIndex++;
}while (_existingStrings.Contains(s));
return(s);
}
/// <summary>
/// Adds or modifies object in display list.
/// </summary>
/// <param name="obj">The object to add or modify.</param>
/// <param name="transform">The transformation of object.</param>
public void PlaceObject(ISwfDisplayObject obj, Matrix transform)
{
var tag = obj as SwfTag;
if (tag == null)
{
throw new ArgumentException();
}
if (_displayList.Contains(obj))
{
Tags.Add(new SwfTagPlaceObject2(obj, transform, SwfPlaceMode.Modify));
}
else
{
obj.Depth = (ushort)(_displayList.Count + 1);
_displayList.Add(obj);
Tags.Add(new SwfTagPlaceObject2(obj, transform, SwfPlaceMode.New));
}
}
void Add(BaseLogData data)
{
if (DatasSet.Contains(data))
{
return;
}
GameObject go = GOPool.Spawn();
BaseLogItem logItem = go.GetComponent <BaseLogItem>();
logItem.CancleInit();
logItem.Init(new UButtonData
{
OnShowActive = OnAlertShow,
});
logItem.SetID(data.ID);
logItem.Show(true, true);
logItem.NameText = data.GetDesc();
logItem.RectTrans.position = StartPos.position;
ActiveItems.Add(logItem);
DatasSet.Add(data);
}
/// <summary>Load all tokens from the token source and put in tokens.
/// This is done upon first LT request because you might want to
/// set some token type / channel overrides before filling buffer.
/// </summary>
protected virtual void FillBuffer()
{
int index = 0;
IToken t = tokenSource.NextToken();
while ((t != null) && (t.Type != (int)Antlr.Runtime.CharStreamConstants.EOF))
{
bool discard = false;
// is there a channel override for token type?
if (channelOverrideMap != null)
{
object channelI = channelOverrideMap[(int)t.Type];
if (channelI != null)
{
t.Channel = (int)channelI;
}
}
if (discardSet != null && discardSet.Contains(t.Type.ToString()))
{
discard = true;
}
else if (discardOffChannelTokens && t.Channel != this.channel)
{
discard = true;
}
if (!discard)
{
t.TokenIndex = index;
tokens.Add(t);
index++;
}
t = tokenSource.NextToken();
}
// leave p pointing at first token on channel
p = 0;
p = SkipOffTokenChannels(p);
}
private void AddNode(HashList <FullCellAddr> sorted, FullCellAddr node)
{
HashSet <FullCellAddr> precedents;
if (GetPrecedents(node, out precedents))
{
Cell cell;
foreach (FullCellAddr precedent in precedents)
{
// By including only non-input Formula and ArrayFormula cells, we avoid that
// constant cells get stored in local variables. The result will not contain
// constants cells (and will contain an input cell only if it is also the
// output cell), so must the raw graph to find all cells belonging to an SDF.
if (!sorted.Contains(precedent) &&
precedent.TryGetCell(out cell) &&
(cell is Formula || cell is ArrayFormula) &&
!inputCellSet.Contains(precedent))
{
AddNode(sorted, precedent);
}
}
}
sorted.Add(node); // Last in HashList
}
// Use this for initialization
void Start()
{
list = new List <HashList <int> >();
for (int i = 0; i < 1000; i++)
{
var hash = new HashList <int>(15000);
for (int j = 0; j < 10000; j++)
{
hash.Add(Random.Range(int.MinValue, int.MaxValue));
}
}
var set = new HashList <int>();
Debug.Log("Add 1 " + set.Add(1));
Debug.Log("Add 1 " + set.Add(1));
set.Add(30000);
set.Add(444);
Debug.Log("Add 5555 " + set.Add(5555));
set.Add(500000);
set.Add(364892679);
set.Remove(444);
Debug.Log("Set contains 444 = " + set.Contains(444));
Debug.Log("Size = " + set.Count);
foreach (var i in set)
{
Debug.Log("Set contains " + i + " = " + set.Contains(i));
}
Debug.Log("Set contains 11 = " + set.Contains(11));
Debug.Log("Set contains 23 = " + set.Contains(23));
Debug.Log("Set contains 16 = " + set.Contains(16));
Debug.Log("Set contains 32 = " + set.Contains(32));
Debug.Log("Set contains 33 = " + set.Contains(33));
}
// Use this for initialization
void Start ()
{
list = new List<HashList<int>>();
for (int i = 0; i < 1000; i++)
{
var hash = new HashList<int>(15000);
for (int j = 0; j < 10000; j++)
{
hash.Add(Random.Range(int.MinValue, int.MaxValue));
}
}
var set = new HashList<int>();
Debug.Log("Add 1 " + set.Add(1));
Debug.Log("Add 1 " + set.Add(1));
set.Add(30000);
set.Add(444);
Debug.Log("Add 5555 " + set.Add(5555));
set.Add(500000);
set.Add(364892679);
set.Remove(444);
Debug.Log("Set contains 444 = " + set.Contains(444));
Debug.Log("Size = " + set.Count);
foreach (var i in set)
{
Debug.Log("Set contains " + i + " = " + set.Contains(i));
}
Debug.Log("Set contains 11 = " + set.Contains(11));
Debug.Log("Set contains 23 = " + set.Contains(23));
Debug.Log("Set contains 16 = " + set.Contains(16));
Debug.Log("Set contains 32 = " + set.Contains(32));
Debug.Log("Set contains 33 = " + set.Contains(33));
}
static bool SearchHash(uint hash, bool reverse, bool printFileList, System.Text.RegularExpressions.Regex regexpFilterString)
{
bool found = false;
// walk the hash lists
foreach (var pair in _HashFiles)
{
if (pair.Value.Contains(hash))
{
if (reverse == false)
{
Console.WriteLine(" hash found in {0}", Path.GetFileNameWithoutExtension(pair.Key));
}
else
{
Console.WriteLine(" reverse hash found in {0}", Path.GetFileNameWithoutExtension(pair.Key));
}
found = true;
}
}
// ask _Files for a name
if (_Files.Contains(hash))
{
if (reverse == false)
{
Console.WriteLine(" found file that matches: {0}", _Files[hash]);
}
else
{
Console.WriteLine(" found file that matches for reverse hash: {0}", _Files[hash]);
}
found = true;
}
// ask _Name for a name
if (_Names.Contains(hash))
{
if (reverse == false)
{
Console.WriteLine(" found string: {0}", _Names[hash]);
}
else
{
Console.WriteLine(" found string for reverse hash: {0}", _Names[hash]);
}
found = true;
}
// lookup the file list for this hash:
if (_HashFileDict.ContainsKey(hash))
{
var l = _HashFileDict[hash];
if (printFileList || l.Count <= 3)
{
foreach (var h in l)
{
string fileName = _FileHashDict[h];
if (regexpFilterString != null && regexpFilterString.IsMatch(fileName) == false)
{
continue;
}
if (reverse == false)
{
Console.WriteLine(" used in {0}", fileName);
}
else
{
Console.WriteLine(" reverse used in {0}", fileName);
}
}
}
else if (l.Count > 0)
{
if (reverse == false)
{
Console.WriteLine(" appears in {0} files. (prefix the query with : to print the list)", l.Count, hash);
}
else
{
Console.WriteLine(" reverse appears in {0} files. (prefix the query with : to print the list)", l.Count, hash);
}
}
}
return(found);
}
/// <summary>
/// Find or create an output file for a corresponding input file
/// </summary>
/// <param name="InputFile">The input file</param>
/// <param name="IncludeStack">The current include stack</param>
/// <param name="OutputFiles">List of output files</param>
/// <param name="OutputFileLookup">Mapping from source file to output file</param>
/// <returns>The new or existing output file</returns>
static OutputFile FindOrCreateOutputFile(List <SourceFile> InputFileStack, Dictionary <SourceFile, SourceFile> CppFileToHeaderFile, HashList <OutputFile> PreviousFiles, Dictionary <SourceFile, OutputFile> OutputFileLookup, Dictionary <Symbol, OutputFile> FwdSymbolToHeader, bool bMakeStandalone, bool bUseOriginalIncludes, LineBasedTextWriter Log)
{
// Get the file at the top of the stack
SourceFile InputFile = InputFileStack[InputFileStack.Count - 1];
// Try to find an existing file
OutputFile OutputFile;
if (OutputFileLookup.TryGetValue(InputFile, out OutputFile))
{
if (OutputFile == null)
{
throw new Exception("Circular include dependencies are not allowed.");
}
foreach (OutputFile IncludedFile in OutputFile.OriginalIncludedFiles.Where(x => !PreviousFiles.Contains(x)))
{
PreviousFiles.Add(IncludedFile);
}
}
else
{
// Add a placeholder entry in the output file lookup, so we can detect circular include dependencies
OutputFileLookup[InputFile] = null;
// Duplicate the list of previously included files, so we can construct the
List <OutputFile> PreviousFilesCopy = new List <OutputFile>(PreviousFiles);
// Build a list of includes for this file. First include is a placeholder for any missing includes that need to be inserted.
List <OutputFileInclude> Includes = new List <OutputFileInclude>();
if ((InputFile.Flags & SourceFileFlags.External) == 0)
{
for (int MarkupIdx = 0; MarkupIdx < InputFile.Markup.Length; MarkupIdx++)
{
PreprocessorMarkup Markup = InputFile.Markup[MarkupIdx];
if (Markup.IsActive && Markup.IncludedFile != null && (Markup.IncludedFile.Flags & SourceFileFlags.Inline) == 0 && Markup.IncludedFile.Counterpart == null)
{
InputFileStack.Add(Markup.IncludedFile);
OutputFile IncludeFile = FindOrCreateOutputFile(InputFileStack, CppFileToHeaderFile, PreviousFiles, OutputFileLookup, FwdSymbolToHeader, bMakeStandalone, bUseOriginalIncludes, Log);
InputFileStack.RemoveAt(InputFileStack.Count - 1);
Includes.Add(new OutputFileInclude(MarkupIdx, IncludeFile));
}
}
}
// Find the matching header file
OutputFile HeaderFile = null;
if ((InputFile.Flags & SourceFileFlags.TranslationUnit) != 0)
{
SourceFile CandidateHeaderFile;
if (CppFileToHeaderFile.TryGetValue(InputFile, out CandidateHeaderFile) && (CandidateHeaderFile.Flags & SourceFileFlags.Standalone) != 0)
{
OutputFileLookup.TryGetValue(CandidateHeaderFile, out HeaderFile);
}
}
// Create the output file.
if ((InputFile.Flags & SourceFileFlags.Output) != 0 && !bUseOriginalIncludes)
{
OutputFile = CreateOptimizedOutputFile(InputFile, HeaderFile, PreviousFilesCopy, Includes, InputFileStack, FwdSymbolToHeader, bMakeStandalone, Log);
}
else
{
OutputFile = CreatePassthroughOutputFile(InputFile, Includes, Log);
}
// Replace the null entry in the output file lookup that we added earlier
OutputFileLookup[InputFile] = OutputFile;
// Add this file to the list of included files
PreviousFiles.Add(OutputFile);
// If the output file dependends on something on the stack, make sure it's marked as pinned
if ((InputFile.Flags & SourceFileFlags.Pinned) == 0)
{
SourceFragment Dependency = OutputFile.Dependencies.FirstOrDefault(x => InputFileStack.Contains(x.File) && x.File != InputFile);
if (Dependency != null)
{
throw new Exception(String.Format("'{0}' is not marked as pinned, but depends on '{1}' which includes it", InputFile.Location.GetFileName(), Dependency.UniqueName));
}
}
}
return(OutputFile);
}
public void ContainsTest()
{
Assert.IsTrue(_list1.Contains(22));
Assert.IsFalse(_list1.Contains(23));
}
/// <summary>
/// Write out an optimized file to the given location
/// </summary>
/// <param name="IncludePaths">Base directories for relative include paths</param>
/// <param name="SystemIncludePaths">Base directories for system include paths</param>
/// <param name="Writer">Writer for the output text</param>
public void Write(IEnumerable <DirectoryReference> IncludePaths, IEnumerable <DirectoryReference> SystemIncludePaths, TextWriter Writer, bool bRemoveForwardDeclarations, TextWriter Log)
{
// Write the file header
TextLocation LastLocation = Text.Start;
// Write the standalone includes
if (MissingIncludes.Count > 0)
{
TextLocation BoilerplateLocation = (BodyMinIdx == Markup.Length || (Markup[BodyMinIdx].Type != PreprocessorMarkupType.Include && BodyMinIdx > 0))? Markup[BodyMinIdx - 1].EndLocation : Markup[BodyMinIdx].Location;
WriteLines(Text, LastLocation, BoilerplateLocation, Writer);
LastLocation = BoilerplateLocation;
if (LastLocation.LineIdx > 0 && Text.Lines[LastLocation.LineIdx - 1].TrimEnd().Length > 0)
{
if (LastLocation.LineIdx + 1 < Text.Lines.Length && Text.Lines[LastLocation.LineIdx].TrimEnd().Length == 0 && Text.Lines[LastLocation.LineIdx + 1].TrimEnd().Length == 0)
{
LastLocation.LineIdx++;
}
Writer.WriteLine();
}
foreach (SourceFile MissingInclude in MissingIncludes)
{
string IncludeText = FormatInclude(Location.Directory, MissingInclude.Location, IncludePaths, SystemIncludePaths, Log);
Writer.WriteLine("#include {0}", IncludeText);
}
}
// Figure out before which markup object to write forward declarations, skipping over all the includes at the start of the file
int ForwardDeclarationsBeforeMarkupIdx = -1;
if ((Flags & SourceFileFlags.TranslationUnit) == 0)
{
int ConditionDepth = 0;
for (int MarkupIdx = BodyMinIdx; MarkupIdx < Markup.Length; MarkupIdx++)
{
if (ConditionDepth == 0)
{
ForwardDeclarationsBeforeMarkupIdx = MarkupIdx;
}
if (Markup[MarkupIdx].Type == PreprocessorMarkupType.Text)
{
break;
}
ConditionDepth += Markup[MarkupIdx].GetConditionDepthDelta();
}
}
// Write all the other markup
for (int MarkupIdx = BodyMinIdx; MarkupIdx < Markup.Length; MarkupIdx++)
{
PreprocessorMarkup ThisMarkup = Markup[MarkupIdx];
// Write the forward declarations
if (MarkupIdx == ForwardDeclarationsBeforeMarkupIdx)
{
// Write out at least up to the end of the last markup
if (MarkupIdx > 0 && LastLocation <= Markup[MarkupIdx - 1].EndLocation)
{
WriteLines(Text, LastLocation, Markup[MarkupIdx - 1].EndLocation, Writer);
LastLocation = Markup[MarkupIdx - 1].EndLocation;
}
// Skip a blank line in the existing text.
TextLocation NewLastLocation = LastLocation;
if (LastLocation.LineIdx < Text.Lines.Length && String.IsNullOrWhiteSpace(Text.Lines[LastLocation.LineIdx]))
{
NewLastLocation = new TextLocation(LastLocation.LineIdx + 1, 0);
}
// Merge all the existing forward declarations with the new set.
HashSet <string> PreviousForwardDeclarations = new HashSet <string>();
while (NewLastLocation.LineIdx < Text.Lines.Length)
{
string TrimLine = Text.Lines[NewLastLocation.LineIdx].Trim();
if (TrimLine.Length > 0 && !TrimLine.Equals("// Forward declarations", StringComparison.InvariantCultureIgnoreCase) && !TrimLine.Equals("// Forward declarations.", StringComparison.InvariantCultureIgnoreCase))
{
// Create a token reader for the current line
TokenReader Reader = new TokenReader(Text, new TextLocation(NewLastLocation.LineIdx, 0), new TextLocation(NewLastLocation.LineIdx, Text.Lines[NewLastLocation.LineIdx].Length));
// Read it into a buffer
List <Token> Tokens = new List <Token>();
while (Reader.MoveNext())
{
Tokens.Add(Reader.Current);
}
// Check it matches the syntax for a forward declaration, and add it to the list if it does
if (Tokens.Count == 3 && (Tokens[0].Text == "struct" || Tokens[0].Text == "class") && Tokens[1].Type == TokenType.Identifier && Tokens[2].Text == ";")
{
PreviousForwardDeclarations.Add(String.Format("{0} {1};", Tokens[0].Text, Tokens[1].Text));
}
else if (Tokens.Count == 4 && Tokens[0].Text == "enum" && Tokens[1].Text == "class" && Tokens[2].Type == TokenType.Identifier && Tokens[3].Text == ";")
{
PreviousForwardDeclarations.Add(String.Format("enum class {0};", Tokens[2].Text));
}
else if (Tokens.Count == 6 && Tokens[0].Text == "enum" && Tokens[1].Text == "class" && Tokens[2].Type == TokenType.Identifier && Tokens[3].Text == ":" && Tokens[4].Type == TokenType.Identifier && Tokens[5].Text == ";")
{
PreviousForwardDeclarations.Add(String.Format("enum class {0} : {1};", Tokens[2].Text, Tokens[4].Text));
}
else if (ForwardDeclarations.Contains(Text.Lines[NewLastLocation.LineIdx]))
{
PreviousForwardDeclarations.Add(Text.Lines[NewLastLocation.LineIdx]);
}
else
{
break;
}
}
NewLastLocation = new TextLocation(NewLastLocation.LineIdx + 1, 0);
}
// Create a full list of new forward declarations, combining with the ones that are already there. Normally we optimize with the forward declarations present,
// so we shouldn't remove any unless running a specific pass designed to do so.
HashSet <string> MergedForwardDeclarations = new HashSet <string>(ForwardDeclarations);
if (!bRemoveForwardDeclarations)
{
MergedForwardDeclarations.UnionWith(PreviousForwardDeclarations);
}
// Write them out
if (MergedForwardDeclarations.Count > 0)
{
Writer.WriteLine();
foreach (string ForwardDeclaration in MergedForwardDeclarations.Distinct().OrderBy(x => GetForwardDeclarationSortKey(x)).ThenBy(x => x))
{
Writer.WriteLine("{0}{1}", GetIndent(MarkupIdx), ForwardDeclaration);
}
Writer.WriteLine();
LastLocation = NewLastLocation;
}
else if (PreviousForwardDeclarations.Count > 0)
{
Writer.WriteLine();
LastLocation = NewLastLocation;
}
}
// Write the includes
if (ThisMarkup.Type == PreprocessorMarkupType.Include && ThisMarkup.IsActive && !ThisMarkup.IsInlineInclude())
{
// Write up to the start of this include
WriteLines(Text, LastLocation, ThisMarkup.Location, Writer);
// Get the original include text. Some modules - particularly editor modules - include headers from other modules based from Engine/Source which are not listed as dependencies. If
// the original include is based from a shallower directory than the one we would include otherwise, we'll use that instead.
string OriginalIncludeText = null;
if (ThisMarkup.Tokens.Count == 1)
{
OriginalIncludeText = ThisMarkup.Tokens[0].Text.Replace('\\', '/');
}
// Write the replacement includes
foreach (SourceFile OutputIncludedFile in ThisMarkup.OutputIncludedFiles)
{
string IncludeText = FormatInclude(Location.Directory, OutputIncludedFile.Location, IncludePaths, SystemIncludePaths, Log);
if (OutputIncludedFile == ThisMarkup.IncludedFile && Rules.IsExternalIncludeMacro(ThisMarkup.Tokens))
{
IncludeText = Token.Format(ThisMarkup.Tokens);
}
else if (OutputIncludedFile == ThisMarkup.IncludedFile && (OutputIncludedFile.Flags & SourceFileFlags.External) != 0)
{
IncludeText = OriginalIncludeText;
}
else if (OriginalIncludeText != null && (Flags & SourceFileFlags.TranslationUnit) == 0 && OriginalIncludeText.EndsWith(IncludeText.TrimStart('\"'), StringComparison.InvariantCultureIgnoreCase) && (OriginalIncludeText.StartsWith("\"Runtime/", StringComparison.InvariantCultureIgnoreCase) || OriginalIncludeText.StartsWith("\"Developer/", StringComparison.InvariantCultureIgnoreCase) || OriginalIncludeText.StartsWith("\"Editor/", StringComparison.InvariantCultureIgnoreCase)))
{
IncludeText = OriginalIncludeText;
}
Writer.WriteLine("{0}#include {1}", GetIndent(MarkupIdx), IncludeText);
}
// Copy any formatting
if (ThisMarkup.EndLocation.LineIdx > ThisMarkup.Location.LineIdx + 1)
{
WriteLines(Text, new TextLocation(ThisMarkup.Location.LineIdx + 1, 0), ThisMarkup.EndLocation, Writer);
}
// Update the location to the start of the next line
LastLocation = new TextLocation(ThisMarkup.Location.LineIdx + 1, 0);
}
}
// Write to the end of the file
WriteLines(Text, LastLocation, Text.End, Writer);
}
public static void Main(string[] args)
{
bool showHelp = false;
string currentProject = null;
var options = new OptionSet()
{
{ "h|help", "show this message and exit", v => showHelp = v != null },
{ "p|project=", "override current project", v => currentProject = v },
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extras.Count != 0 || showHelp == true)
{
Console.WriteLine("Usage: {0} [OPTIONS]+", GetExecutableName());
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
Console.WriteLine("Loading project...");
var manager = Manager.Load(currentProject);
if (manager.ActiveProject == null)
{
Console.WriteLine("Nothing to do: no active project loaded.");
return;
}
var project = manager.ActiveProject;
var version = -1;
HashList <ulong> knownHashes = null;
HashList <ulong> subFatHashes = null;
var installPath = project.InstallPath;
var listsPath = project.ListsPath;
if (installPath == null)
{
Console.WriteLine("Could not detect install path.");
return;
}
if (listsPath == null)
{
Console.WriteLine("Could not detect lists path.");
return;
}
Console.WriteLine("Searching for archives...");
var fatPaths = new List <string>();
fatPaths.AddRange(Directory.GetFiles(installPath, "*.fat", SearchOption.AllDirectories));
var outputPaths = new List <string>();
var breakdown = new Breakdown();
var tracking = new Tracking();
Console.WriteLine("Processing...");
for (int i = 0; i < fatPaths.Count; i++)
{
var fatPath = fatPaths[i];
var datPath = Path.ChangeExtension(fatPath, ".dat");
var outputPath = GetListPath(installPath, fatPath);
if (outputPath == null)
{
throw new InvalidOperationException();
}
Console.WriteLine(outputPath);
outputPath = Path.Combine(listsPath, outputPath);
if (outputPaths.Contains(outputPath) == true)
{
throw new InvalidOperationException();
}
outputPaths.Add(outputPath);
if (File.Exists(fatPath + ".bak") == true)
{
fatPath += ".bak";
datPath += ".bak";
}
var fat = new BigFile();
using (var input = File.OpenRead(fatPath))
{
fat.Deserialize(input);
}
if (version == -1)
{
version = fat.Version;
knownHashes = manager.LoadListsFileNames(fat.Version);
subFatHashes = manager.LoadListsSubFatNames(fat.Version);
}
else if (version != fat.Version)
{
throw new InvalidOperationException();
}
if (knownHashes == null ||
subFatHashes == null)
{
throw new InvalidOperationException();
}
HandleEntries(fat.Entries.Select(e => e.NameHash).Distinct(),
knownHashes,
tracking,
breakdown,
outputPath);
using (var input = File.OpenRead(datPath))
{
foreach (var headerEntry in fat.Entries.Where(e => subFatHashes.Contains(e.NameHash) == true))
{
var subFat = new SubFatFile();
using (var temp = new MemoryStream())
{
Big.EntryDecompression.Decompress(headerEntry, input, temp);
temp.Position = 0;
subFat.Deserialize(temp, fat);
}
var matchingSubFats = fat.SubFats
.Where(sf => subFat.Entries.SequenceEqual(sf.Entries))
.ToArray();
if (matchingSubFats.Length == 0)
{
continue;
}
if (matchingSubFats.Length > 1)
{
throw new InvalidOperationException();
}
var subfatPath = GetListPath(installPath,
fatPath,
FilterEntryName(subFatHashes[headerEntry.NameHash]));
if (subfatPath == null)
{
throw new InvalidOperationException();
}
Console.WriteLine(subfatPath);
subfatPath = Path.Combine(listsPath, subfatPath);
HandleEntries(subFat.Entries.Select(e => e.NameHash),
knownHashes,
tracking,
breakdown,
subfatPath);
}
}
}
using (var output = new StreamWriter(Path.Combine(Path.Combine(listsPath, "files"), "status.txt")))
{
output.WriteLine("{0}",
new Breakdown()
{
Known = tracking.Names.Distinct().Count(),
Total = tracking.Hashes.Distinct().Count(),
});
}
}
/// <summary>
/// type_method = [ "static" ], signature, method_name, [ ":", signature, identifier, { ",", signature, identifier } ], "{", { local_stmt }, "}" ;
/// </summary>
private void ParseTypeMethod()
{
// ? "static"
bool isStatic = false;
if (PeekLexem(LexemType.Static))
{
SkipLexem();
isStatic = true;
}
// signature
var methodType = ParseSignature();
// <method_name>
if (!PeekLexem(LexemType.Identifier)) Error(Resources.errMethodNameExpected);
var methodName = GetLexem();
if (ReservedMethods.ContainsKey(methodName.Data) && ReservedMethods[methodName.Data] != methodType.Signature)
Error(String.Format(Resources.errSpecialIncorrectReturnType, methodName.Data, ReservedMethods[methodName.Data]));
// validate static constructor
if (methodName.Data == "construct" && isStatic)
Error(String.Format(Resources.errStaticConstructor, Compiler.Emitter.CurrentType.Name));
SkipLexem();
HashList<ParameterNode> parameters = null;
// ? "(", params, ")"
if(PeekLexem(LexemType.ParenOpen))
{
SkipLexem();
parameters = new HashList<ParameterNode>();
var idx = 0;
while(!PeekLexem(LexemType.ParenClose, LexemType.EOF))
{
// separator
if(idx > 0)
{
if (!PeekLexem(LexemType.Comma)) Error(Resources.errCommaExpected);
SkipLexem();
}
// signature
var paramType = ParseSignature();
// <name>
if (!PeekLexem(LexemType.Identifier)) Error(Resources.errParameterNameExpected);
var paramName = GetLexem();
if (parameters.Contains(paramName.Data)) Error(String.Format(Resources.errParameterNameDuplicated, paramName.Data));
parameters.Add(paramName.Data, new ParameterNode(paramName.Data, paramType, idx));
SkipLexem();
idx++;
}
// ")"
if (!PeekLexem(LexemType.ParenClose))
Error(Resources.errParenExpected);
SkipLexem();
}
MethodNode method;
if (methodName.Data == "construct")
method = Compiler.Emitter.CreateCtor(Compiler.Emitter.CurrentType, parameters);
else
method = Compiler.Emitter.CreateMethod(Compiler.Emitter.CurrentType, methodName.Data, methodType, parameters, isStatic);
method.Lexem = methodName;
Compiler.Emitter.CurrentMethod = method;
// lookahead "{"
if (!PeekLexem(LexemType.CurlyOpen)) Error(Resources.errMethodCurlyBrace);
method.Body = ParseCodeBlock();
Compiler.Emitter.CurrentMethod = null;
}
/// <summary>
/// Calculate the route from start to end.
/// </summary>
/// <param name="start">Start.</param>
/// <param name="end">End.</param>
public void Route(T start, T end, List <T> route)
{
route.Clear();
if (start == null || end == null)
{
return;
}
for (int i = 0, nodesLength = nodes.Length; i < nodesLength; i++)
{
var s = nodes[i];
g[s] = 0f;
parent[s] = null;
inPath[s] = false;
}
openset.Clear();
closedset.Clear();
path.Clear();
var current = start;
openset.Add(current);
while (openset.Count > 0)
{
current = openset[0];
for (var i = 1; i < openset.Count; i++)
{
var d = g[current].CompareTo(g[openset[i]]);
if (d < 0)
{
current = openset[i];
}
}
//openset.Sort ((a,b) => g [a].CompareTo (g [b]));
current = openset[0];
if (current == end)
{
while (parent[current] != null)
{
path.Enqueue(current);
inPath[current] = true;
current = parent[current];
if (path.Count >= nodes.Length)
{
return;
}
}
inPath[current] = true;
path.Enqueue(current);
while (path.Count > 0)
{
route.Add(path.Dequeue());
}
return;
}
openset.Remove(current);
closedset.Add(current);
var connectedNodes = current.GetConnectedNodes();
for (int i = 0, connectedNodesCount = connectedNodes.Count; i < connectedNodesCount; i++)
{
var node = connectedNodes[i];
if (closedset.Contains(node))
{
continue;
}
if (openset.Contains(node))
{
var new_g = g[current] + current.CalculateMoveCost(node);
if (g[node] > new_g)
{
g[node] = new_g;
parent[node] = current;
}
}
else
{
g[node] = g[current] + current.CalculateMoveCost(node);
parent[node] = current;
openset.Add(node);
}
}
}
return;
}
private void AddNode(HashList<FullCellAddr> sorted, FullCellAddr node) {
HashSet<FullCellAddr> precedents;
if (GetPrecedents(node, out precedents)) {
Cell cell;
foreach (FullCellAddr precedent in precedents) {
// By including only non-input Formula and ArrayFormula cells, we avoid that
// constant cells get stored in local variables. The result will not contain
// constants cells (and will contain an input cell only if it is also the
// output cell), so must the raw graph to find all cells belonging to an SDF.
if (!sorted.Contains(precedent)
&& precedent.TryGetCell(out cell)
&& (cell is Formula || cell is ArrayFormula)
&& !inputCellSet.Contains(precedent)) {
AddNode(sorted, precedent);
}
}
}
sorted.Add(node); // Last in HashList
}
public bool IsPlayEligible(IEnumerable <WhiteCard> play)
{
return(play.Any(c => _triggerCards.Contains(c.Id)) || _triggerContent.Any(tc => play.Any(p => p.ContainsContentFlags(tc))));
}
public bool Contains(T item)
{
return(hashset.Contains(item));
}
