public void Visit(BinaryType type) { Flatbuf.Binary.StartBinary(Builder); Result = FieldType.Build( Flatbuf.Type.Binary, Flatbuf.Binary.EndBinary(Builder)); }
public AdditionalTypeInfo(DeserializeReader reader, BinaryType binaryType) { switch (binaryType) { case BinaryType.Primitive: Info = new AdditionalInfoPrimitiveType(reader); break; case BinaryType.SystemClass: Info = new AdditionalInfoSystemClass(reader); break; case BinaryType.Class: Info = new AdditionalInfoClassTypeInfo(reader); break; case BinaryType.PrimitiveArray: Info = new AdditionalInfoPrimitiveType(reader); break; case BinaryType.String: case BinaryType.Object: case BinaryType.ObjectArray: case BinaryType.StringArray: break; default: throw new InvalidStructureException("Unknown member type"); } }
/// <summary> /// The visit binary. /// </summary> /// <param name="b"> /// The b. /// </param> /// <returns> /// The <see cref="Expression" />. /// </returns> protected override Expression VisitBinary(BinaryExpression expression) { BinaryType op; if (!BinaryType.TryParse(expression.NodeType.ToString(), out op)) { if (expression.NodeType == ExpressionType.OrElse) { op = BinaryType.Or; } else if (expression.NodeType == ExpressionType.AndAlso) { op = BinaryType.And; } else { throw new Exception(expression.NodeType.ToString()); } } var node = new QNode() { Type = NodeType.Binary, Value = op }; this.Visit(expression.Left); node.Left = this.Context.Pop(); this.Visit(expression.Right); node.Right = this.Context.Pop(); this.Context.Push(node); return(expression); }
// Copy constructor for debugger proxy private MessagePackString( MessagePackString other ) { this._encoded = other._encoded; this._decoded = other._decoded; this._decodingError = other._decodingError; this._type = other._type; }
public static String BinaryTypeToString(this BinaryType binaryType) { switch (binaryType) { case BinaryType.SCS_32BIT_BINARY: return("32-bit Windows-based application"); case BinaryType.SCS_64BIT_BINARY: return("64-bit Windows-based application"); case BinaryType.SCS_DOS_BINARY: return("MS-DOS-based application"); case BinaryType.SCS_OS216_BINARY: return("16-bit OS/2-based application"); case BinaryType.SCS_POSIX_BINARY: return("POSIX-based application"); case BinaryType.SCS_WOW_BINARY: return("16-bit Windows-based application"); default: return("Unknown"); } }
private StatementList GetBinaryTestStructure(BinaryType binaryType) { return(new StatementList() { Statements = new List <Statement>() { new SelectStatement() { SelectElements = new List <Expressions.SelectExpression>() { new SelectScalarExpression() { Expression = new BinaryExpression() { Left = new ColumnReference() { Identifiers = new List <string>() { "c1" } }, Right = new StringLiteral() { Value = "a" }, Type = binaryType } } } } } }); }
public MessagePackString( string decoded ) { Contract.Assert( decoded != null, "decoded != null" ); this._decoded = decoded; this._type = BinaryType.String; }
// Copy constructor for debugger proxy private MessagePackString(MessagePackString other) { this._encoded = other._encoded; this._decoded = other._decoded; this._decodingError = other._decodingError; this._type = other._type; }
/// <summary> /// Saves metadata for this session. /// </summary> /// <param name="typeId">Type ID.</param> /// <param name="typeName">Type name.</param> /// <param name="affKeyFieldName">Affinity key field name.</param> /// <param name="fields">Fields metadata.</param> internal void SaveMetadata(int typeId, string typeName, string affKeyFieldName, IDictionary <string, int> fields) { if (_metas == null) { BinaryType meta = new BinaryType(typeId, typeName, fields, affKeyFieldName); _metas = new Dictionary <int, IBinaryType>(1); _metas[typeId] = meta; } else { IBinaryType meta; if (_metas.TryGetValue(typeId, out meta)) { IDictionary <string, int> existingFields = ((BinaryType)meta).FieldsMap(); foreach (KeyValuePair <string, int> field in fields) { if (!existingFields.ContainsKey(field.Key)) { existingFields[field.Key] = field.Value; } } } else { _metas[typeId] = new BinaryType(typeId, typeName, fields, affKeyFieldName); } } }
public MessagePackString(string decoded) { Contract.Assert(decoded != null, "decoded != null"); this._decoded = decoded; this._type = BinaryType.String; }
public BinaryExpression(SourceRange range, BinaryType type, Expression left, Expression right) : base(range) { Type = type; Left = left; Right = right; }
public static string ToStringRepresentation(this BinaryType binaryType) { switch (binaryType) { case BinaryType.Add: return("+"); case BinaryType.Subtract: return("-"); case BinaryType.Multiply: return("*"); case BinaryType.ImpliedMultiply: return("*"); case BinaryType.Divide: return("/"); case BinaryType.Power: return("^"); default: return(""); } }
/// <summary> /// Updates or creates cached binary type holder. /// </summary> private void UpdateOrCreateBinaryTypeHolder(BinaryType meta) { BinaryTypeHolder holder; if (_metas.TryGetValue(meta.TypeId, out holder)) { holder.Merge(meta); return; } lock (this) { if (_metas.TryGetValue(meta.TypeId, out holder)) { holder.Merge(meta); return; } var metas0 = new Dictionary <int, BinaryTypeHolder>(_metas); holder = new BinaryTypeHolder(meta.TypeId, meta.TypeName, meta.AffinityKeyFieldName, meta.IsEnum, this); holder.Merge(meta); metas0[meta.TypeId] = holder; _metas = metas0; } }
public void Visit(BinaryType type) { BinaryArray.Builder resultBuilder = new BinaryArray.Builder().Reserve(_baseDataTotalElementCount); for (int i = 0; i < _baseDataListCount; i++) { List <int?> dataList = _baseData[i]; BinaryArray.Builder builder = new BinaryArray.Builder().Reserve(dataList.Count); foreach (byte?value in dataList) { if (value.HasValue) { builder.Append(value.Value); resultBuilder.Append(value.Value); } else { builder.AppendNull(); resultBuilder.AppendNull(); } } TestTargetArrayList.Add(builder.Build()); } ExpectedArray = resultBuilder.Build(); }
private void DecodeIfNeeded() { if (this._decoded != null) { return; } if (this._encoded == null) { return; } if (this._type != BinaryType.Unknwon) { return; } try { this._decoded = MessagePackConvert.DecodeStringStrict(this._encoded); this._type = BinaryType.String; } catch (DecoderFallbackException ex) { this._decodingError = ex; this._type = BinaryType.Blob; } }
/// <summary> /// Put binary types to Grid. /// </summary> /// <param name="types">Binary types.</param> internal void PutBinaryTypes(ICollection <BinaryType> types) { DoOutOp(OpMeta, stream => { BinaryWriter metaWriter = _marsh.StartMarshal(stream); metaWriter.WriteInt(types.Count); foreach (var meta in types) { BinaryType meta0 = meta; metaWriter.WriteInt(meta0.TypeId); metaWriter.WriteString(meta0.TypeName); metaWriter.WriteString(meta0.AffinityKeyFieldName); IDictionary <string, int> fields = meta0.GetFieldsMap(); metaWriter.WriteInt(fields.Count); foreach (var field in fields) { metaWriter.WriteString(field.Key); metaWriter.WriteInt(field.Value); } metaWriter.WriteBoolean(meta.IsEnum); } _marsh.FinishMarshal(metaWriter); }); _marsh.OnBinaryTypesSent(types); }
public static object ReadType(this System.IO.BinaryReader reader, out BinaryType type) { type = (BinaryType)reader.ReadInt32(); if (type == BinaryType.String) { return(reader.ReadString()); } else if (type == BinaryType.Int) { return(reader.ReadInt32()); } else if (type == BinaryType.Double) { return(reader.ReadDouble()); } else if (type == BinaryType.Bool) { return(reader.ReadBoolean()); } else if (type == BinaryType.Enum) { return(reader.ReadString()); } return(null); }
public MessagePackString(string decoded) { #if !UNITY Contract.Assert(decoded != null, "decoded != null"); #endif // !UNITY this._decoded = decoded; this._type = BinaryType.String; }
public MessagePackString( string decoded ) { #if !UNITY_ANDROID && !UNITY_IPHONE Contract.Assert( decoded != null ); #endif // !UNITY_ANDROID && !UNITY_IPHONE this._decoded = decoded; this._type = BinaryType.String; }
public MessagePackString( string decoded ) { #if !UNITY Contract.Assert( decoded != null, "decoded != null" ); #endif // !UNITY this._decoded = decoded; this._type = BinaryType.String; }
public MessagePackString(byte[] encoded, bool isBinary) { this._encoded = encoded; this._type = isBinary ? BinaryType.Blob : BinaryType.Unknwon; if (isBinary) { this._decodingError = IsBinary; } }
public static string ToBinary(this string text, BinaryType type, bool fullTranslate) { switch (type) { case BinaryType.ascii: default: return text.ToAscii(fullTranslate); } }
public MessagePackString( byte[] encoded, bool isBinary ) { Contract.Assert( encoded != null, "encoded != null" ); this._encoded = encoded; this._type = isBinary ? BinaryType.Blob : BinaryType.Unknwon; if ( isBinary ) { this._decodingError = IsBinary; } }
public void Equals() { BinaryType type = (BinaryType)NHibernateUtil.Binary; byte[] expected = Encoding.UTF8.GetBytes("ghij1`23%$"); byte[] expectedClone = Encoding.UTF8.GetBytes("ghij1`23%$"); Assert.IsTrue(type.IsEqual(expected, expected)); Assert.IsTrue(type.IsEqual(expected, expectedClone)); Assert.IsFalse(type.IsEqual(expected, GetByteArray(15))); }
public MessagePackString(byte[] encoded, bool isBinary) { Contract.Assert(encoded != null, "encoded != null"); this._encoded = encoded; this._type = isBinary ? BinaryType.Blob : BinaryType.Unknwon; if (isBinary) { this._decodingError = IsBinary; } }
public MessagePackString(byte[] encoded, bool isBinary) { #if !UNITY Contract.Assert(encoded != null); #endif // !UNITY this._encoded = encoded; this._type = isBinary ? BinaryType.Blob : BinaryType.Unknwon; if (isBinary) { this._decodingError = IsBinary; } }
public MessagePackString( byte[] encoded, bool isBinary ) { #if !UNITY Contract.Assert( encoded != null ); #endif // !UNITY this._encoded = encoded; this._type = isBinary ? BinaryType.Blob : BinaryType.Unknwon; if ( isBinary ) { this._decodingError = IsBinary; } }
public BinaryExpression(Expression left, Expression right, BinaryType type) : base(NodeType.Binary) { Left = left; Right = right; OperatorType = type; if (Left.ContainVariable || Right.ContainVariable) { ContainVariable = true; } Simplified = false; }
/// <summary> /// 判断EXE是否为64位程序 /// </summary> /// <param name="exePath"></param> /// <returns></returns> public static bool IsExe64Bit(string exePath) { BinaryType exeType = BinaryType.SCS_32BIT_BINARY; if (GetBinaryType(exePath, out exeType)) { if (exeType == BinaryType.SCS_64BIT_BINARY) { return(true); } } return(false); }
public static PropertyValue ToPropertyUnion(this BinaryType binType, object value) { switch (binType) { case BinaryType.Bool: return(new PropertyValue((bool)value)); case BinaryType.Double: return(new PropertyValue((double)value)); case BinaryType.Int: return(new PropertyValue((int)value)); default: return(new PropertyValue((string)value)); } }
public static bool IsLeftAssociative(this BinaryType operatorType) { switch (operatorType) { case BinaryType.Add: case BinaryType.Subtract: case BinaryType.Multiply: case BinaryType.Divide: case BinaryType.ImpliedMultiply: return(true); case BinaryType.Power: return(false); default: return(true); } }
/// <summary> /// Callback invoked when metadata has been sent to the server and acknowledged by it. /// </summary> /// <param name="newMetas">Binary types.</param> public void OnBinaryTypesSent(IDictionary <int, IBinaryType> newMetas) { foreach (KeyValuePair <int, IBinaryType> metaEntry in newMetas) { BinaryType meta = (BinaryType)metaEntry.Value; IDictionary <int, Tuple <string, int> > mergeInfo = new Dictionary <int, Tuple <string, int> >(meta.FieldsMap().Count); foreach (KeyValuePair <string, int> fieldMeta in meta.FieldsMap()) { int fieldId = BinaryUtils.FieldId(metaEntry.Key, fieldMeta.Key, null, null); mergeInfo[fieldId] = new Tuple <string, int>(fieldMeta.Key, fieldMeta.Value); } _metas[metaEntry.Key].Merge(mergeInfo); } }
public static PropertyType BinaryTypeToPropertyType(BinaryType type) { switch (type) { case BinaryType.Int: return(PropertyType.Integer); case BinaryType.Double: return(PropertyType.Decimal); case BinaryType.Bool: return(PropertyType.Boolean); case BinaryType.Enum: return(PropertyType.Enum); default: return(PropertyType.String); } }
public static string LoadFile(string filePath) { string file = ""; if (File.Exists(filePath)) { using (BinaryReader reader = new BinaryReader(File.Open(filePath, FileMode.Open))) { BinaryType type = (BinaryType)reader.ReadInt32(); if (type == BinaryType.String) { file = reader.ReadString(); } else { file = "Error IncorrectFormat: File Formate"; } } } return(file); }
public static int GetPrecedence(this BinaryType operatorType) { switch (operatorType) { case BinaryType.Add: case BinaryType.Subtract: return(1); case BinaryType.Multiply: case BinaryType.Divide: return(2); case BinaryType.ImpliedMultiply: return(3); case BinaryType.Power: return(4); default: return(1); } }
// Adapted from http://stackoverflow.com/a/4696857/2055880 public PEInfo(string path) { uint size; LOADED_IMAGE image; if (MapAndLoad(path, null, out image, true, true) && image.MappedAddress != IntPtr.Zero) { var imports = (IMAGE_IMPORT_DESCRIPTOR *)ImageDirectoryEntryToData((void *)image.MappedAddress, false, 1, out size); if (imports != null) { while (imports->OriginalFirstThunk != 0) { _modules.Add(Marshal.PtrToStringAnsi(ImageRvaToVa(image.FileHeader, image.MappedAddress, imports->Name, IntPtr.Zero))); ++imports; } } _binaryType = ((IMAGE_NT_HEADERS *)image.FileHeader)->FileHeader.Machine; } }
// Called by Settings.SelectBinaries to get: // * The required and optional binaries for the current build target and logging state; // these get enabled. // * All binaries; any that weren't enabled in the previous step get disabled. public virtual IEnumerable <string> GetBinaryAssetPaths(BuildTarget buildTarget, BinaryType binaryType) { return(GetBinaryPaths(buildTarget, binaryType, "Assets")); }
public static string ToBinary(this string text, BinaryType type) { return ToBinary(text, type, true); }
/// <summary> /// Creates a new BinaryRegister /// </summary> /// <param name="type">the type of the operator</param> /// <param name="left">the left register (must be less than 16)</param> /// <param name="right">the right register (must be less than 16)</param> public BinaryRegister(BinaryType type, byte left, byte right) : base(type, left, right) { }
/// <summary> /// Parses a binary instruction (register and constant) /// </summary> /// <param name="op">The BinaryType for this instruction</param> /// <param name="indirectRight">True if the right argument is indirect (surrounded by brakets)</param> private void ParseBinary(BinaryType op, bool indirectRight = false) { // Parse left side byte left; ParseSmallSymbol(SymbolType.Register, out left); tokenizer.ConsumeToken(AssemblyTokenType.Comma); // Parse right side byte right; SymbolType type; if (indirectRight) { // Force register / constant depending on whether there are brakets if (tokenizer.Current.Type == AssemblyTokenType.BraketOpen) { // Register tokenizer.ConsumeToken(); type = ParseSmallSymbol(SymbolType.Register, out right); tokenizer.ConsumeToken(AssemblyTokenType.BraketClose); } else { //Constant type = ParseSmallSymbol(SymbolType.Constant, out right); } } else { // Allow any token type type = ParseSmallSymbol(SymbolType.Constant | SymbolType.Register, out right); } // Add final statement if (type == SymbolType.Constant) AddInstruction(new BinaryConstant(op, left, right)); else AddInstruction(new BinaryRegister(op, left, right)); }
public TuningAction() { WizType = TuneWizardType.None; WizName = string.Empty; WizIdOrFilename = string.Empty; WizBinType = BinaryType.None; WizWhitelist = new string [] {}; WizBlacklist = new string[] { }; WizCode = string.Empty; WizAuth = string.Empty; }
/// <summary> /// Initializes a new instance of the <see cref="DBBinary"/> class. /// </summary> /// <param name="type">The type.</param> /// <param name="data">A buffer of byte data.</param> public DBBinary(BinaryType type, byte[] data) { Type = type; Buffer = data; }
/// <summary> /// Processes the Binary and Icon tables. /// </summary> /// <param name="writer">XmlWriter where the Intermediate should persist itself as XML.</param> /// <param name="binaryType">type of binary to process.</param> /// <param name="binaryName">Name of binary to process.</param> private void ProcessBinaryTable(XmlWriter writer, BinaryType binaryType, string binaryName) { if (!this.inputDatabase.TableExists(binaryType.ToString())) { return; } string query = String.Concat("SELECT * FROM `", binaryType.ToString(), "`"); if (0 < binaryName.Length) { if (this.binariesProcessed.ContainsKey(binaryName)) { return; // not an error because multiple controls can reference a binary/icon } query = String.Concat(query, " WHERE `Name`='", binaryName, "'"); } using (View view = this.inputDatabase.OpenExecuteView(query)) { if (this.exportBinaries) { if ((BinaryType.Binary == binaryType && !this.binariesExported) || (BinaryType.Icon == binaryType && !this.iconsExported)) { string binaryFileName = String.Concat(binaryType.ToString(), ".idt"); this.inputDatabase.Export(binaryType.ToString(), this.exportBasePath, binaryFileName); File.Delete(Path.Combine(this.exportBasePath, binaryFileName)); if (BinaryType.Binary == binaryType) { this.binariesExported = true; } else if (BinaryType.Icon == binaryType) { this.iconsExported = true; } } } Record record; while (view.Fetch(out record)) { string name = record[(int)MsiInterop.Binary.Name]; if (this.binariesProcessed.ContainsKey(name)) { continue; // not an error because multiple controls can reference a property } else { this.binariesProcessed[name] = true; } string id = this.StripModuleId(name); if (this.skipVSI && ("dirca_checkfx" == id.ToLower() || "vsdca_vsdlaunchconditions" == id.ToLower())) { this.core.OnMessage(WixWarnings.FilteringVSIStuff(null, WarningLevel.Major, "Binary", id.ToLower())); continue; } if (null == writer) { writer = this.InitializeXmlTextWriter(Path.GetFullPath(Path.Combine(Path.Combine(this.outputFolder, "BaseLibrary"), String.Concat(binaryType.ToString(), ".wxs")))); if (this.generateFragments) { // initalize the fragment writer.WriteStartElement("Fragment"); } } writer.WriteStartElement(binaryType.ToString()); this.core.WriteAttributeString(writer, "Id", id); this.core.WriteAttributeString(writer, "SourceFile", Path.Combine(binaryType.ToString(), String.Concat(id, ".ibd"))); writer.WriteEndElement(); } if (this.generateFragments && null != writer) { writer.WriteEndElement(); } } }
/// <summary> /// Parses a binary or icon element. /// </summary> /// <param name="node">Element to parse.</param> /// <param name="binaryType">"Binary" or "Icon" table type enum.</param> /// <returns>Identifier for the new row.</returns> private string ParseBinaryOrIconElement(XmlNode node, BinaryType binaryType) { SourceLineNumberCollection sourceLineNumbers = this.core.GetSourceLineNumbers(node); string id = null; string sourceFile = null; foreach (XmlAttribute attrib in node.Attributes) { switch (attrib.LocalName) { case "Id": id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib); break; case "SourceFile": case "src": if (null != sourceFile) { this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name, "SourceFile", "src")); } sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib); break; default: this.core.UnexpectedAttribute(sourceLineNumbers, attrib); break; } } if (null == id) { this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name, "Id")); id = CompilerCore.IllegalIdentifier; } else if (CompilerCore.IllegalIdentifier != id) // only check legal values { if (55 < id.Length) { this.core.OnMessage(WixErrors.BinaryOrIconIdentifierTooLong(sourceLineNumbers, node.Name, "Id", id)); } else if (!this.compilingProduct && 18 < id.Length) // if we're not doing a product then we can't be sure that a binary identifier over 18 characters will fit { this.core.OnMessage(WixWarnings.BinaryOrIconIdentifierCannotBeModularized(sourceLineNumbers, node.Name, "Id", id)); } } if (null == sourceFile) { this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name, "SourceFile")); } // find unexpected child elements foreach (XmlNode child in node.ChildNodes) { if (XmlNodeType.Element == child.NodeType) { this.core.UnexpectedElement(node, child); } } Debug.Assert("Binary" == binaryType.ToString() || "Icon" == binaryType.ToString()); Row row = this.core.CreateRow(sourceLineNumbers, binaryType.ToString()); row[0] = id; row[1] = sourceFile; return id; }
private static extern bool GetBinaryType(string lpApplicationName, out BinaryType lpBinaryType);
public FileTuningAction(string name, string filename, BinaryType type, string [] whitelist, string [] blacklist, string code, string author, string msg) { WizName = name; WizIdOrFilename = filename; WizType = TuneWizardType.TuningFile; WizBinType = type; WizWhitelist = whitelist; WizBlacklist = blacklist; WizCode = code; WizAuth = author; WizMsg = msg; }
/// <summary> /// Creates a new Binary instruction /// </summary> /// <param name="type">the type of the instruction</param> /// <param name="left">the left register (must be less than 16)</param> /// <param name="right">the right register / constant</param> protected Binary(BinaryType type, byte left, byte right) { this.Type = type; this.Left = left; this.Right = right; }
private void DecodeIfNeeded() { if ( this._decoded != null ) { return; } if ( this._encoded == null ) { return; } if ( this._type != BinaryType.Unknwon ) { return; } try { this._decoded = MessagePackConvert.DecodeStringStrict( this._encoded ); this._type = BinaryType.String; } catch ( DecoderFallbackException ex ) { this._decodingError = ex; this._type = BinaryType.Blob; } }
/// <summary> /// Makes a BinaryConstant instruction /// </summary> /// <param name="instruction">instruction to make from</param> /// <param name="type">the type of instruction</param> /// <returns>the new BinaryConstant</returns> /// <remarks> /// Assumes the constant is stored in the lower 8 bits /// </remarks> protected BinaryConstant MakeBinaryConstant(int instruction, BinaryType type) { return new BinaryConstant(type, GetRegister1(instruction), (byte) instruction); }
/// <summary> /// Creates a new BinaryConstant /// </summary> /// <param name="type">the type of the operator</param> /// <param name="left">the left register (must be less than 16)</param> /// <param name="right">the right constant</param> public BinaryConstant(BinaryType type, byte left, byte right) : base(type, left, right) { }
/// <summary> /// Makes a BinaryRegister instruction /// </summary> /// <param name="instruction">instruction to make from</param> /// <param name="type">the type of instruction</param> /// <returns>the new BinaryRegister</returns> protected BinaryRegister MakeBinaryRegister(int instruction, BinaryType type) { return new BinaryRegister(type, GetRegister1(instruction), GetRegister2(instruction)); }