public Parameter AddParameter(Result result, CircuitMap circuitMap, Jam jam, int bitNumber) { Tracer.Assert(CircuitMap.IsPrimitive(jam.CircuitSymbol.Circuit)); SymbolMap map = this.AddSymbol(circuitMap, (CircuitSymbol)jam.CircuitSymbol); return(map.AddParameter(result, circuitMap, jam, bitNumber)); }
public Result AddResult(CircuitMap circuitMap, Jam jam, int bitNumber) { Tracer.Assert(CircuitMap.IsPrimitive(jam.CircuitSymbol.Circuit)); SymbolMap map = this.AddSymbol(circuitMap, (CircuitSymbol)jam.CircuitSymbol); return(map.AddResult(circuitMap, jam, bitNumber)); }
private static SymbolicTransform GenerateOneTimesXToXTransform() { var constraint = new BasicSymbolicConstraint( s => s.Type == SymbolType.Multiplication, new BasicSymbolicConstraint[] { new BasicSymbolicConstraint( s => s.Type == SymbolType.Number && (Number)s == Numbers.One), new BasicSymbolicConstraint() } ); var varName = "value"; var inputMap = new SymbolMap( new SymbolMap[] { new SymbolMap(), // placeholder for left part new SymbolMap(new SymbolName(varName)) } ); var context = inputMap.GenerateContext(); var outputExpression = new Variable(varName); var outputFunction = new Function(outputExpression, context); return(SymbolicTransform.New(constraint, inputMap, outputFunction)); }
private static SymbolicTransform GenerateAdditionForceValuesLeftTransform() { // constraint where value is on the right, and // some non-left subtree is on the left var constraint = new BasicSymbolicConstraint( s => s.Type == SymbolType.Addition, new BasicSymbolicConstraint[] { new BasicSymbolicConstraint( s => !s.Type.IsValue() ), new BasicSymbolicConstraint( s => s.Type.IsValue() ) } ); var leftName = "left"; var rightName = "right"; var inputMap = new SymbolMap(new SymbolMap[] { new SymbolMap(new SymbolName(leftName)), new SymbolMap(new SymbolName(rightName)) }); var context = inputMap.GenerateContext(); var outputExpression = new Addition( new Variable(rightName), new Variable(leftName) ); var outputFunction = new Function(outputExpression, context); return(SymbolicTransform.New(constraint, inputMap, outputFunction)); }
private Quotation ToQuotation(string message) { var c = message.Split('|'); var time = Convert.ToInt32(c[0]); var quotationInfo = c[1].Split(','); var symbolIndex = quotationInfo[0]; if (!SymbolMap.ContainsKey(symbolIndex)) { return(null); } var symbol = SymbolMap[symbolIndex]; var sclare = Convert.ToDecimal(Math.Pow(10, symbol.Scale)); var quotation = new Quotation(symbol, time) { Bid = Convert.ToDecimal(quotationInfo[1]) / sclare, Direction = (Direction)Enum.ToObject(typeof(Direction), Convert.ToInt32(quotationInfo[2])) }; //方向 if (quotationInfo.Length >= 4) { quotation.Spread = Convert.ToInt32(quotationInfo[3]); } return(quotation); ; }
private static int GetAttributeDescriptorsCount(SymbolMap symbols) { const int SizeOfAttributeDescriptor = 40; var maxPlus1 = symbols.BestMatch("AttributeDescriptors.MaxName++"); var first = symbols.BestMatch("AttributeDescriptors.FirstName"); if (first == 0 || maxPlus1 == 0) { return(0); } return((int)(maxPlus1 - first) / SizeOfAttributeDescriptor); }
public SymbolMap AddSymbol(CircuitMap circuitMap, CircuitSymbol circuitSymbol) { SymbolMapKey key = new SymbolMapKey(circuitMap, circuitSymbol); SymbolMap map; if (!this.symbols.TryGetValue(key, out map)) { map = new SymbolMap(key); this.symbols.Add(key, map); } return(map); }
public Score Calculate(SymbolMap map) { var score = 0; var winLinesBuilder = new WinLinesBuilder(map); score += new CherryRules(ref winLinesBuilder).GetScore(); score += new SevenRules(ref winLinesBuilder).GetScore(); score += new BarRules(ref winLinesBuilder).GetScore(); score += new CombinationRules(ref winLinesBuilder).GetScore(); return(new Score { Value = score }); }
private static uint GetStatic_LevelArea(byte[] data, SymbolMap symbols) { const string key = "LevelArea"; var match = symbols.BestMatch(key); if (match != 0) { return(match); } if (Engine.Current == null) { return(0); } try { var pe = new PEHeaderReader(data); var rdata = pe.ImageSectionHeaders.FirstOrDefault(h => h.Section.TrimEnd('\0') == ".rdata"); var text = pe.ImageSectionHeaders.FirstOrDefault(h => h.Section.TrimEnd('\0') == ".text"); uint offset = rdata.VirtualAddress - rdata.PointerToRawData + pe.OptionalHeader32.ImageBase; var pName = (uint)(offset + new BinaryPattern(Encoding.ASCII.GetBytes("UIMinimapToggle")).NextMatch(data, (int)rdata.PointerToRawData, (int)rdata.SizeOfRawData)); var pMethod = BitConverter.ToUInt32(data, BinaryPattern.Parse( $"68{pName.ToPattern()}" + "A3........" + "C705................" + "C705................" + "E8........" + "68........" + "A3........" + "C705........|........|").NextMatch(data, (int)text.PointerToRawData, (int)text.SizeOfRawData) + 51); if (Engine.Current.Memory.Reader.Read <byte>(pMethod + 0x00) == 0x8B && Engine.Current.Memory.Reader.Read <byte>(pMethod + 0x01) == 0x0D) { var address = Engine.Current.Memory.Reader.Read <uint>(pMethod + 0x02); symbols.Override(key, address); return(address); } } catch { } return(0); }
private static uint GetStatic_LevelArea(byte[] data, SymbolMap symbols) { const string key = "LevelArea"; var match = symbols.BestMatch(key); if (match != 0) { return(match); } if (Engine.Current == null) { return(0); } try { // TODO: Calculate offset from PE info. const uint offset = 0x801600; // TODO: Search in .rdata segment only. var pName = (uint)(offset + new BinaryPattern(Encoding.ASCII.GetBytes("UIMinimapToggle")).NextMatch(data, 0)); // TODO: Search in .text segment only var pMethod = BitConverter.ToUInt32(data, BinaryPattern.Parse( $"68{pName.ToPattern()}" + "A3........" + "C705................" + "C705................" + "E8........" + "68........" + "A3........" + "C705........|........|").NextMatch(data, 0) + 51); if (Engine.Current.Memory.Reader.Read <byte>(pMethod + 0x00) == 0x8B && Engine.Current.Memory.Reader.Read <byte>(pMethod + 0x01) == 0x0D) { var address = Engine.Current.Memory.Reader.Read <uint>(pMethod + 0x02); symbols.Override(key, address); return(address); } } catch { } return(0); }
public WinLinesBuilder(SymbolMap symbolMap) { TopLine = new List <Symbol>(); TopLine.Add(symbolMap.TopLine.LeftSymbol); TopLine.Add(symbolMap.TopLine.CenterSymbol); TopLine.Add(symbolMap.TopLine.RightSymbol); CenterLine = new List <Symbol>(); CenterLine.Add(symbolMap.CenterLine.LeftSymbol); CenterLine.Add(symbolMap.CenterLine.CenterSymbol); CenterLine.Add(symbolMap.CenterLine.RightSymbol); BottomLine = new List <Symbol>(); BottomLine.Add(symbolMap.BottomLine.LeftSymbol); BottomLine.Add(symbolMap.BottomLine.CenterSymbol); BottomLine.Add(symbolMap.BottomLine.RightSymbol); }
private static uint GetStatic_LevelAreaName(byte[] data, SymbolMap symbols) { const string key = "LevelAreaName"; var match = symbols.BestMatch(key); if (match != 0) { return(match); } var levelarea = symbols.BestMatch("LevelArea"); if (levelarea != 0) { return(levelarea + 0x30); } return(0); }
private MainDeclaration() { LimFactory = new Factory(new StrTable()); ClassStack = new Stack <ClassInfo>(); MethodStack = new Stack <MethodInfo>(); NamespaceStack = new Stack <uint>(); LocalMap = new SymbolMap <uint>(); FileMap = new Dictionary <uint, uint>(); TypeMap = new SymbolMap <Columbus.Lim.Asg.Nodes.Type.Type>(); CgiMap = new Dictionary <string, ClassGenericInstance>(); UsesStack = new Stack <HashSet <uint> >(); MgiMap = new Dictionary <string, MethodGenericInstance>(); LLOCMap = new LLOCMapType(); ComponentTLOCMap = new Dictionary <uint, Dictionary <uint, ulong> >(); LimOrigin = new LimOrigin(); MainWatch = new Stopwatch(); RoslynWatch = new Stopwatch(); CSSIWatch = new Stopwatch(); LIMWatch = new Stopwatch(); Statistics = new Statistic[1]; Statistics[0] = new Statistic(); OverrideRelations = new OverrideRelations(LimFactory); FxCopTasks = new LinkedList <Task>(); }
public void Remove(SymbolMap map) { this.symbols.Remove(new SymbolMapKey(map.CircuitMap, map.CircuitSymbol)); }
public ActionResult <Score> Start(SymbolMap symbolMap) { return(_scoreRepo.Calculate(symbolMap)); }
private void ProcessJavaScript(IList <InputGroup> inputGroups, SwitchParser switchParser, string outputPath, SymbolMap symbolMap, Encoding outputEncoding) { var settings = switchParser.JSSettings; TextWriter mapWriter = null; ISourceMap sourceMap = null; try { // if we want a symbols map, we need to set it up now if (symbolMap != null && !settings.PreprocessOnly) { // if we specified the path, use it. Otherwise just use the output path with // ".map" appended to the end. Eg: output.js => output.js.map var symbolMapPath = symbolMap.Path.IsNullOrWhiteSpace() ? outputPath + ".map" : symbolMap.Path; // create the map writer and the source map implementation. // look at the Name attribute and implement the proper one. // the encoding needs to be UTF-8 WITHOUT a BOM or it won't work. if (!FileWriteOperation(symbolMapPath, switchParser.Clobber, () => { mapWriter = new StreamWriter(symbolMapPath, false, new UTF8Encoding(false)); sourceMap = SourceMapFactory.Create(mapWriter, symbolMap.Name); if (sourceMap != null) { // if we get here, the symbol map now owns the stream and we can null it out so // we don't double-close it mapWriter = null; settings.SymbolsMap = sourceMap; // copy some property values sourceMap.SourceRoot = symbolMap.SourceRoot.IfNullOrWhiteSpace(null); sourceMap.SafeHeader = symbolMap.SafeHeader.GetValueOrDefault(false); // start the package sourceMap.StartPackage(outputPath, symbolMapPath); } return(true); })) { // could not write file Log.LogError(Strings.CouldNotWriteOutputFile, symbolMapPath); } } // save the original term settings. We'll make sure to set this back again // for the last item in the group, but we'll make sure it's TRUE for all the others. var originalTermSetting = settings.TermSemicolons; var currentSourceOrigin = SourceOrigin.Project; var parser = new JSParser(); parser.CompilerError += (sender, ea) => { // if the input group isn't project, then we only want to report sev-0 errors. // regardless, don't show any errors that have a severity lower (greater numeric value) // than the warning level specified. if ((currentSourceOrigin == SourceOrigin.Project || ea.Error.Severity == 0) && ea.Error.Severity <= switchParser.WarningLevel) { LogContextError(ea.Error); } }; var outputBuilder = new StringBuilder(8192); using (var writer = new StringWriter(outputBuilder, CultureInfo.InvariantCulture)) { for (var inputGroupIndex = 0; inputGroupIndex < inputGroups.Count; ++inputGroupIndex) { var inputGroup = inputGroups[inputGroupIndex]; currentSourceOrigin = inputGroup.Origin; // for all but the last item, we want the term-semicolons setting to be true. // but for the last entry, set it back to its original value settings.TermSemicolons = inputGroupIndex < inputGroups.Count - 1 ? true : originalTermSetting; if (settings.PreprocessOnly) { parser.EchoWriter = writer; if (inputGroupIndex > 0) { // not the first group, so output the appropriate newline // sequence before we output the group. writer.Write(settings.LineTerminator); } } else { // not preprocess-only, so make sure the echo writer is null parser.EchoWriter = null; } // parse the input var block = parser.Parse(inputGroup.Source, settings); if (block != null && !settings.PreprocessOnly) { if (inputGroupIndex > 0) { // not the first group, so output the appropriate newline // sequence before we output the group. writer.Write(settings.LineTerminator); } // minify the AST to the output if (settings.Format == JavaScriptFormat.JSON) { if (!JSONOutputVisitor.Apply(writer, block, settings)) { Log.LogError(Strings.InvalidJSONOutput); } } else { OutputVisitor.Apply(writer, block, settings); } } } } // write output if (!Log.HasLoggedErrors) { if (!FileWriteOperation(outputPath, switchParser.Clobber, () => { using (var writer = new StreamWriter(outputPath, false, outputEncoding)) { // write the combined minified code writer.Write(outputBuilder.ToString()); if (!settings.PreprocessOnly) { // give the map (if any) a chance to add something settings.SymbolsMap.IfNotNull(m => m.EndFile( writer, settings.LineTerminator)); } } return(true); })) { // could not write file Log.LogError(Strings.CouldNotWriteOutputFile, outputPath); } } else { Log.LogWarning(Strings.DidNotMinify, outputPath, Strings.ThereWereErrors); if (File.Exists(outputPath)) { File.Delete(outputPath); } } } finally { if (sourceMap != null) { mapWriter = null; settings.SymbolsMap = null; sourceMap.EndPackage(); sourceMap.Dispose(); } if (mapWriter != null) { mapWriter.Close(); } } }
/// <summary> /// Main method for transliteration. /// </summary> /// <param name="input">The Unicode text to translate.</param> /// <param name="lang">Optional. If a language specific transliterates are available it will be used.</param> public static string Translate(string input, string lang = "en") { //setup defaults. if (!LangCharMap.TryGetValue(lang, out var langChar)) { langChar = EmptyDictionary; } if (!SymbolMap.TryGetValue(lang, out var symbols)) { symbols = SymbolMap["en"]; } var sb = new StringBuilder(input.Length); //Loop though each character in the input string. for (var i = 0; i < input.Length; i++) { //Try direct langChar translation var ch = input.Substring(i, 1); if (langChar.TryGetValue(ch, out var foundLangChar)) { sb.Append(foundLangChar); continue; } //Try using Char Map var used = 0; var chCharMap = WalkTrie(i, input, CharMap, ref used); if (chCharMap is not null) { //After walking the trie, we found a match, //use what we found instead. sb.Append(chCharMap); //then update the number of characters //we consumed in the input for this //match to take place i += used - 1; continue; } //Try Diatric Map used = 0; var chDiatric = WalkTrie(i, input, DiatricMap, ref used); if (chDiatric is not null) { sb.Append(chDiatric); i += used - 1; continue; } //Try symbol map if (symbols.TryGetValue(ch, out var foundSymbol)) { sb.Append(foundSymbol); continue; } //otherwise, there's no mapping translation from the //current character to US-ASCII sb.Append(ch); } return(sb.ToString()); }