private void processLine(PropertyLine line)
{
if (line.IsAmountCalculated)
{
line.Amount = 0.00M;
foreach (var subLine in line.Sublines)
{
processLine(subLine);
switch (subLine.AmountOperand)
{
case PropertyLine.AmountOperation.Plus:
line.Amount += subLine.Amount;
break;
case PropertyLine.AmountOperation.Subtract:
line.Amount -= subLine.Amount;
break;
case PropertyLine.AmountOperation.None:
break;
default:
break;
}
}
}
else
{
}
line.Message = "";
}
private void ClearMessageLine(PropertyLine line)
{
line.Message = "";
foreach (var subL in line.Sublines)
{
ClearMessageLine(subL);
}
}
private void handleValidationResult()
{
PropertyEntry propertyEntry = new PropertyEntry();
PropertyLine propLine = ValidationPropertyUtil.readPropertyLine("");
if (propLine != null)
{
propertyEntry.MessageLine = propLine;
if (propLine.Type == "message")
{
PropertyLine pathPropLine = ValidationPropertyUtil.readPropertyLine("");
propertyEntry.PathLine = pathPropLine;
}
}
}
public static PropertyLine readPropertyLine(String line)
{
String[] split = line.Split('=');
String[] type = split[0].Split('.');
if (type.Length > 1)
{
PropertyLine propLine = new PropertyLine();
propLine.Type = type[1].Trim();
propLine.Value = split[1].Trim();
propLine.Count = ExtractIntFromString(type[0]);
return(propLine);
}
return(null);
}
public async Task ReadFile(StreamReader reader)
{
string line;
IGedcomReader objectReader = new Discarder();
while ((line = reader.ReadLine()) != null)
{
PropertyLine pline = new PropertyLine(line);
if (pline.Level == 0)
{
// save previous object
await objectReader.Store(this.treeService).ConfigureAwait(false);
switch (pline.Value)
{
case "INDI":
objectReader = new IndividualReader(pline);
break;
case "FAM":
objectReader = new FamilyReader(pline);
break;
default:
// HEAD, TRLR, SOUR, NOTE, ...
objectReader = new Discarder();
break;
}
}
else
{
objectReader.ProcessNextLine(pline);
}
}
// and store the last object (although that would be an ignored TRLR in a real file)
await objectReader.Store(this.treeService).ConfigureAwait(false);
}
public IList <PropertyLine> GetInitialData(IConfigurationSection arrayOfLines)
{
var lines = new List <PropertyLine>();
foreach (IConfigurationSection section in arrayOfLines.GetChildren())
{
var id = section.GetSection("Id").Value;
var header = section.GetSection("Header").Value;
var footer = section.GetSection("Footer").Value;
var amount = decimal.Parse(section.GetSection("Amount").Value);
var isAmountCalculated = bool.Parse(section.GetSection("IsAmountCalculated").Value);
var amountPos = (PropertyLine.AmountLocation)Int32.Parse(section.GetSection("AmountPos").Value);
var amountOperSection = section.GetSection("AmountOperand").Value;
var amountOperand = amountOperSection != null ? (PropertyLine.AmountOperation)Int32.Parse(amountOperSection) : PropertyLine.AmountOperation.Plus;
var subLines = GetInitialData(section.GetSection("Sublines"));
var aLine = new PropertyLine()
{
Id = id, Header = header, Footer = footer, Amount = amount, IsAmountCalculated = isAmountCalculated, AmountPos = amountPos, Sublines = subLines, AmountOperand = amountOperand
};
lines.Add(aLine);
}
return(lines);
}
private void Stream( ArrayList data, PropertyLine propLine )
{
data.Add( new Snoop.Data.ClassSeparator( typeof( PropertyLine ) ) );
// No data at this level yet!
}
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
// we want gcc toolchain 4.9, but fall back to 4.8 or 4.6 for now if it doesn't exist
string NDKPath = Environment.GetEnvironmentVariable("NDKROOT");
NDKPath = NDKPath.Replace("\"", "");
AndroidToolChain ToolChain = new AndroidToolChain(Target.ProjectFile, false, Target.AndroidPlatform.Architectures, Target.AndroidPlatform.GPUArchitectures);
// figure out the NDK version
string NDKToolchainVersion = "unknown";
string NDKDefine = "100500"; // assume r10e
string SourcePropFilename = Path.Combine(NDKPath, "source.properties");
if (File.Exists(SourcePropFilename))
{
string RevisionString = "";
string[] PropertyContents = File.ReadAllLines(SourcePropFilename);
foreach (string PropertyLine in PropertyContents)
{
if (PropertyLine.StartsWith("Pkg.Revision"))
{
RevisionString = PropertyLine;
break;
}
}
int EqualsIndex = RevisionString.IndexOf('=');
if (EqualsIndex > 0)
{
string[] RevisionParts = RevisionString.Substring(EqualsIndex + 1).Trim().Split('.');
int RevisionMinor = int.Parse(RevisionParts.Length > 1 ? RevisionParts[1] : "0");
char RevisionLetter = Convert.ToChar('a' + RevisionMinor);
int RevisionBeta = 0; // @TODO
NDKToolchainVersion = "r" + RevisionParts[0] + (RevisionMinor > 0 ? Char.ToString(RevisionLetter) : "");
NDKDefine = RevisionParts[0] + string.Format("{0:00}", RevisionMinor + 1) + string.Format("{0:00}", RevisionBeta);
}
}
else
{
string ReleaseFilename = Path.Combine(NDKPath, "RELEASE.TXT");
if (File.Exists(ReleaseFilename))
{
string[] PropertyContents = File.ReadAllLines(SourcePropFilename);
NDKToolchainVersion = PropertyContents[0];
}
}
// PLATFORM_ANDROID_NDK_VERSION is in the form 150100, where 15 is major version, 01 is the letter (1 is 'a'), 00 indicates beta revision if letter is 00
Log.TraceInformation("PLATFORM_ANDROID_NDK_VERSION = {0}", NDKDefine);
CompileEnvironment.Definitions.Add("PLATFORM_ANDROID_NDK_VERSION=" + NDKDefine);
string GccVersion = "4.6";
int NDKVersionInt = ToolChain.GetNdkApiLevelInt();
if (Directory.Exists(Path.Combine(NDKPath, @"sources/cxx-stl/gnu-libstdc++/4.9")))
{
GccVersion = "4.9";
}
else
if (Directory.Exists(Path.Combine(NDKPath, @"sources/cxx-stl/gnu-libstdc++/4.8")))
{
GccVersion = "4.8";
}
Log.TraceInformation("NDK toolchain: {0}, NDK version: {1}, GccVersion: {2}, ClangVersion: {3}", NDKToolchainVersion, NDKVersionInt.ToString(), GccVersion, ToolChain.GetClangVersionString());
CompileEnvironment.Definitions.Add("PLATFORM_DESKTOP=0");
CompileEnvironment.Definitions.Add("PLATFORM_CAN_SUPPORT_EDITORONLY_DATA=0");
CompileEnvironment.Definitions.Add("WITH_OGGVORBIS=1");
CompileEnvironment.Definitions.Add("UNICODE");
CompileEnvironment.Definitions.Add("_UNICODE");
CompileEnvironment.Definitions.Add("PLATFORM_ANDROID=1");
CompileEnvironment.Definitions.Add("ANDROID=1");
CompileEnvironment.Definitions.Add("WITH_DATABASE_SUPPORT=0");
CompileEnvironment.Definitions.Add("WITH_EDITOR=0");
CompileEnvironment.Definitions.Add("USE_NULL_RHI=0");
CompileEnvironment.Definitions.Add("REQUIRES_ALIGNED_INT_ACCESS");
CompileEnvironment.IncludePaths.SystemIncludePaths.Add("$(NDKROOT)/sources/cxx-stl/gnu-libstdc++/" + GccVersion + "/include");
// the toolchain will actually filter these out
CompileEnvironment.IncludePaths.SystemIncludePaths.Add("$(NDKROOT)/sources/cxx-stl/gnu-libstdc++/" + GccVersion + "/libs/armeabi-v7a/include");
CompileEnvironment.IncludePaths.SystemIncludePaths.Add("$(NDKROOT)/sources/cxx-stl/gnu-libstdc++/" + GccVersion + "/libs/arm64-v8a/include");
CompileEnvironment.IncludePaths.SystemIncludePaths.Add("$(NDKROOT)/sources/cxx-stl/gnu-libstdc++/" + GccVersion + "/libs/x86/include");
CompileEnvironment.IncludePaths.SystemIncludePaths.Add("$(NDKROOT)/sources/cxx-stl/gnu-libstdc++/" + GccVersion + "/libs/x86_64/include");
LinkEnvironment.LibraryPaths.Add("$(NDKROOT)/sources/cxx-stl/gnu-libstdc++/" + GccVersion + "/libs/armeabi-v7a");
LinkEnvironment.LibraryPaths.Add("$(NDKROOT)/sources/cxx-stl/gnu-libstdc++/" + GccVersion + "/libs/arm64-v8a");
LinkEnvironment.LibraryPaths.Add("$(NDKROOT)/sources/cxx-stl/gnu-libstdc++/" + GccVersion + "/libs/x86");
LinkEnvironment.LibraryPaths.Add("$(NDKROOT)/sources/cxx-stl/gnu-libstdc++/" + GccVersion + "/libs/x86_64");
CompileEnvironment.IncludePaths.SystemIncludePaths.Add("$(NDKROOT)/sources/android/native_app_glue");
CompileEnvironment.IncludePaths.SystemIncludePaths.Add("$(NDKROOT)/sources/android/cpufeatures");
//@TODO: Tegra Gfx Debugger - standardize locations - for now, change the hardcoded paths and force this to return true to test
if (UseTegraGraphicsDebugger(Target))
{
//LinkEnvironment.LibraryPaths.Add("ThirdParty/NVIDIA/TegraGfxDebugger");
//LinkEnvironment.LibraryPaths.Add("F:/NVPACK/android-kk-egl-t124-a32/stub");
//LinkEnvironment.AdditionalLibraries.Add("Nvidia_gfx_debugger_stub");
}
SetupGraphicsDebugger(Target, CompileEnvironment, LinkEnvironment);
LinkEnvironment.AdditionalLibraries.Add("gnustl_shared");
LinkEnvironment.AdditionalLibraries.Add("gcc");
LinkEnvironment.AdditionalLibraries.Add("z");
LinkEnvironment.AdditionalLibraries.Add("c");
LinkEnvironment.AdditionalLibraries.Add("m");
LinkEnvironment.AdditionalLibraries.Add("log");
LinkEnvironment.AdditionalLibraries.Add("dl");
if (!UseTegraGraphicsDebugger(Target))
{
LinkEnvironment.AdditionalLibraries.Add("GLESv2");
LinkEnvironment.AdditionalLibraries.Add("EGL");
}
LinkEnvironment.AdditionalLibraries.Add("OpenSLES");
LinkEnvironment.AdditionalLibraries.Add("android");
}
public PropertyLine(PropertyLine original)
: this(original.Name, original.Value)
{
}
public PropertyLine(PropertyLine original)
: this(original.Name, original.Value)
{
}
public override void dataReveiced(List <string> receivedLines)
{
for (int i = 0; i < receivedLines.Count; i++)
{
String line = receivedLines[i];
if (line == "SETUP_VALIDATION_SESSION")
{
setIsActive(true);
}
else if (line == "TEARDOWN_VALIDATION_SESSION")
{
setIsActive(false);
foreach (PropertyEntry entry in errorCountToPropertyLine.Values)
{
Main.consistencyModule.RuleControl.handleRuleResult(Consistency.ConsistencyModule.propertyEntryToRuleResult(entry), sqlRep);
}
Main.consistencyModule.refreshOutputs(sqlRep);
}
else if (isActive())
{
PropertyLine propLine = ValidationPropertyUtil.readPropertyLine(receivedLines[i]);
PropertyEntry propertyEntry = null;
if (!errorCountToPropertyLine.ContainsKey(propLine.Count))
{
propertyEntry = new PropertyEntry();
errorCountToPropertyLine.Add(propLine.Count, propertyEntry);
}
else
{
propertyEntry = errorCountToPropertyLine[propLine.Count];
}
if (propLine.Type == "message")
{
propertyEntry.MessageLine = propLine;
}
else
{
propertyEntry.PathLine = propLine;
if (propertyEntry.PathLine.Value != "")
{
try
{
propertyEntry.MoflonObject = ValidationPropertyUtil.computeObjectFromPath(sqlRep, propertyEntry.PathLine.Value);
}
catch (NullReferenceException)
{
//something went wrong while computing the path
errorCountToPropertyLine.Remove(propLine.Count);
Main.tcpServerFunctions.addStatusMessage("An error occured while parsing the validation results from Eclipse: " + propertyEntry.PathLine.Value);
}
}
}
}
}
stream.WriteByte((byte)10);
}
private static IEnumerable <AssemblyLine> ParseInputFile(string inputFile)
{
var currentLineCount = 0;
var typeLines = new List <TypeLine>();
var assemblyLines = new List <AssemblyLine>();
using (var reader = new StreamReader(inputFile))
{
while (!reader.EndOfStream)
{
currentLineCount++;
var currentLine = reader.ReadLine();
if (string.IsNullOrEmpty(currentLine))
{
continue;
}
if (currentLine.Trim() == "")
{
continue;
}
if (currentLine.ToLower().Trim().Equals("break;"))
{
break;
}
if (currentLine.ToLower().Trim().Equals("return;"))
{
return(assemblyLines);
}
if (!currentLine.ToLower().Trim().StartsWith("//"))
{
if (AssemblyLine.IsAssembly(currentLine))
{
var assemblyLine = new AssemblyLine(currentLineCount, currentLine);
assemblyLines.Add(assemblyLine);
}
else if (TypeLine.IsType(currentLine))
{
if (assemblyLines.Count == 0)
{
"CryoAOP -> Error:{0}! Could not find matching assembly tag for type ... ".Error(
currentLineCount.ToString());
"CryoAOP -> '{0}'".Error(currentLine.Trim());
WriteUsage();
return(assemblyLines);
}
var typeLine = new TypeLine(currentLineCount, currentLine);
assemblyLines.Last().Types.Add(typeLine);
typeLines.Add(typeLine);
}
else if (MethodLine.IsMethod(currentLine))
{
if (assemblyLines.Count == 0 && typeLines.Count == 0)
{
"CryoAOP -> Error:{0}! Could not find matching type tag for method ... ".Error(
currentLineCount.ToString());
"CryoAOP -> '{0}'".Error(currentLine.Trim());
WriteUsage();
return(assemblyLines);
}
var methodLine = new MethodLine(currentLineCount, currentLine);
typeLines.Last().Methods.Add(methodLine);
}
else if (PropertyLine.IsProperty(currentLine))
{
if (assemblyLines.Count == 0 && typeLines.Count == 0)
{
"CryoAOP -> Error:{0}! Could not find matching type tag for property ... ".Error(
currentLineCount.ToString());
"CryoAOP -> '{0}'".Error(currentLine.Trim());
WriteUsage();
return(assemblyLines);
}
var propertyLine = new PropertyLine(currentLineCount, currentLine);
typeLines.Last().Properties.Add(propertyLine);
}
else
{
"CryoAOP -> Warning:{0}! Ignoring line because entry appears to be invalid ... ".Warn(
currentLineCount);
"CryoAOP -> '{0}'".Warn(currentLine.Trim());
}
}
}
}
return(assemblyLines);
}
