/// <summary> /// Converts a label to displayable form by stripping the uniquification tag (if any), /// inserting the non-unique label prefix if appropriate, and appending the optional /// annotation character. /// </summary> /// <remarks> /// There's generally two ways to display a label: /// (1) When displaying labels on-screen, we get a label with the uniquification tag, /// and we want to show the non-unique label prefix ('@' or ':') and annotation. /// (2) When generating assembly source, we get a remapped label with no uniquification /// tag, and we don't want to show the prefix or annotation. /// For case #2, there's no reason to call here. (We're currently doing so because /// remapping isn't happening yet, but that should change soon. When that happens, we /// should be able to eliminate the showNonUnique arg.) /// </remarks> /// <param name="label">Base label string. Has the uniquification tag, but no /// annotation char or non-unique prefix.</param> /// <param name="anno">Annotation; may be None.</param> /// <param name="showNonUnique">Set true if the returned label should show the /// non-unique label prefix.</param> /// <param name="formatter">Format object that holds the non-unique label prefix /// string.</param> /// <returns>Formatted label.</returns> public static string ConvertLabelForDisplay(string label, LabelAnnotation anno, bool showNonUnique, Asm65.Formatter formatter) { StringBuilder sb = new StringBuilder(label.Length + 2); if (label.Length > NON_UNIQUE_LEN && label[label.Length - NON_UNIQUE_LEN] == UNIQUE_TAG_CHAR) { // showNonUnique may be false if generating assembly code (but by this // point the unique tag should be remapped away) if (showNonUnique) { sb.Append(formatter.NonUniqueLabelPrefix); } sb.Append(label.Substring(0, label.Length - NON_UNIQUE_LEN)); } else { sb.Append(label); } char annoChar = GetLabelAnnoChar(anno); if (annoChar != NO_ANNO_CHAR) { sb.Append(annoChar); } return(sb.ToString()); }
private MaterialType GetMaterialType(LabelAnnotation labelAnnotation) { var desc = labelAnnotation.Description.ToUpper(); if (desc.Contains("FOOD") || desc.Contains("DISHES")) { return(MaterialType.BIO); } if (desc.Contains("GLASS")) { return(MaterialType.GLASS); } if (desc.Contains("PAPER")) { return(MaterialType.PAPER); } if (desc.Contains("PLASTIC")) { return(MaterialType.PLASTIC); } if (desc.Contains("METAL")) { return(MaterialType.METAL); } if (desc.Contains("ELECTRONIC")) { return(MaterialType.ELECTRONIC); } return(MaterialType.OTHER); }
/// <summary> /// Internal base-object (Symbol) constructor, called by other constructors. /// </summary> private DefSymbol(string label, int value, Source source, Type type, LabelAnnotation labelAnno) : base(label, value, source, type, labelAnno) { Debug.Assert(source == Source.Platform || source == Source.Project || source == Source.Variable); Debug.Assert(type == Type.ExternalAddr || type == Type.Constant); Xrefs = new XrefSet(); }
/// <summary> /// Constructor for non-unique labels. /// </summary> /// <param name="label">Label string. Syntax assumed valid.</param> /// <param name="value">Symbol value.</param> /// <param name="labelAnno">Optional annotation.</param> /// <param name="uniqueTag">Tag that makes a non-unique label unique, e.g. the /// offset for which a user label has been created.</param> public Symbol(string label, int value, LabelAnnotation labelAnno, int uniqueTag) : this(label, 0xdead, Source.User, Type.NonUniqueLocalAddr, labelAnno) { Debug.Assert(uniqueTag >= 0 && uniqueTag < 0x01000000); // fit in 6 hex digits Debug.Assert(label.IndexOf(UNIQUE_TAG_CHAR) < 0); // already extended? Value = value; // passed a bogus value to base ctor for assert // Add tag to label to make it unique. Label = label + UNIQUE_TAG_CHAR + uniqueTag.ToString("x6"); }
/// <summary> /// Returns the annotation suffix character, or NO_ANNO_CHAR if nothing appropriate. /// </summary> private static char GetLabelAnnoChar(LabelAnnotation anno) { char ch = NO_ANNO_CHAR; if (anno == LabelAnnotation.Uncertain) { ch = UNCERTAIN_CHAR; } else if (anno == LabelAnnotation.Generated) { //ch = '\u00a4'; // CURRENCY SIGN '¤' } return(ch); }
/// <summary> /// Basic constructor. /// </summary> /// <param name="label">Label string. Syntax assumed valid.</param> /// <param name="value">Symbol value.</param> /// <param name="source">User-defined, auto-generated, ?</param> /// <param name="type">Type of symbol this is.</param> /// <param name="labelAnno">Optional annotation.</param> public Symbol(string label, int value, Source source, Type type, LabelAnnotation labelAnno) { Debug.Assert(Asm65.Label.ValidateLabel(label)); Debug.Assert(type != Type.NonUniqueLocalAddr || value == 0xdead); // use other ctor Label = label; Value = value; SymbolType = type; SymbolSource = source; LabelAnno = labelAnno; // Generate SourceTypeString. char sc, tc; switch (SymbolSource) { case Source.Auto: sc = 'A'; break; case Source.User: sc = 'U'; break; case Source.AddrPreLabel: sc = 'R'; break; case Source.Platform: sc = 'P'; break; case Source.Project: sc = 'J'; break; case Source.Variable: sc = 'V'; break; default: sc = '?'; break; } switch (SymbolType) { case Type.NonUniqueLocalAddr: tc = 'N'; break; case Type.LocalOrGlobalAddr: tc = 'L'; break; case Type.GlobalAddr: tc = 'G'; break; case Type.GlobalAddrExport: tc = 'X'; break; case Type.ExternalAddr: tc = 'E'; break; case Type.Constant: tc = 'C'; break; default: tc = '?'; break; } SourceTypeString = "" + sc + tc; }
/// <summary> /// Performs a detailed validation of a symbol label, breaking out different failure /// causes for the benefit of code that reports errors to the user. The label may /// have additional characters, such as annotations, which are trimmed away. The /// trimmed version of the string is returned. /// </summary> /// <param name="label">Label to examine.</param> /// <param name="nonUniquePrefix">For address symbols, the prefix string for /// non-unique labels (e.g. '@' or ':'). May be null if not validating a user /// label.</param> /// <param name="isValid">True if the entire label is valid.</param> /// <param name="isLenValid">True if the label has a valid length.</param> /// <param name="isFirstCharValid">True if the first character is valid.</param> /// <param name="hasNonUniquePrefix">True if the first character indicates that this is /// a non-unique label.</param> /// <param name="anno">Annotation found, or None if none found.</param> /// <returns>Trimmed version of the string, or the original string if an error /// is encountered.</returns> public static string TrimAndValidateLabel(string label, string nonUniquePrefix, out bool isValid, out bool isLenValid, out bool isFirstCharValid, out bool hasNonUniquePrefix, out LabelAnnotation anno) { anno = LabelAnnotation.None; hasNonUniquePrefix = false; // Do we have at least one char? if (string.IsNullOrEmpty(label)) { isValid = isLenValid = isFirstCharValid = false; return(label); } string trimLabel = label; // Check for an annotation char, remove it if found. if (trimLabel[trimLabel.Length - 1] == UNCERTAIN_CHAR) { anno = LabelAnnotation.Uncertain; trimLabel = trimLabel.Substring(0, trimLabel.Length - 1); } // Check for leading non-unique ident char. if (trimLabel.Length > 0 && !string.IsNullOrEmpty(nonUniquePrefix)) { if (trimLabel[0] == nonUniquePrefix[0]) { hasNonUniquePrefix = true; trimLabel = trimLabel.Substring(1); } } // Now that we're down to the base string, do the full validation test. If it // passes, we don't need to dig any deeper. isValid = Asm65.Label.ValidateLabelDetail(trimLabel, out isLenValid, out isFirstCharValid); return(trimLabel); }
public LabelAnnotation[] DetectLabels(params string[] path) { var type = Enumerable.Repeat(new string[] { "LABEL_DETECTION" }, path.Length).ToArray(); var response = PostRequests(path, type); var responseLength = response["responses"].ToArray().Length; string[][] descriptions = new string[responseLength][]; double[][] scores = new double[responseLength][]; response["responses"].Select((value, index) => new { value, index }) .ToList() .ForEach(x => { descriptions[x.index] = x.value["labelAnnotations"].Select(y => y["description"].ToString()).ToArray(); scores[x.index] = x.value["labelAnnotations"].Select(y => y["score"].ToObject <double>()).ToArray(); }); var labelAnnotations = new LabelAnnotation[responseLength]; for (var i = 0; i < responseLength; i++) { labelAnnotations[i] = new LabelAnnotation(descriptions[i], scores[i]); } return(labelAnnotations); }
/// <summary> /// Constructor. General form. /// </summary> /// <param name="label">Symbol's label.</param> /// <param name="value">Symbol's value.</param> /// <param name="source">Symbol source (general point of origin).</param> /// <param name="type">Symbol type.</param> /// <param name="formatSubType">Format descriptor sub-type, so we know how the /// user wants the value to be displayed.</param> /// <param name="width">Variable width.</param> /// <param name="widthSpecified">True if width was explicitly specified. If this is /// <param name="comment">End-of-line comment.</param> /// <param name="direction">I/O direction.</param> /// <param name="multiMask">Bit mask to apply before comparisons.</param> /// <param name="tag">Symbol tag, used for grouping platform symbols.</param> /// false, the value of the "width" argument is ignored.</param> public DefSymbol(string label, int value, Source source, Type type, LabelAnnotation labelAnno, FormatDescriptor.SubType formatSubType, int width, bool widthSpecified, string comment, DirectionFlags direction, MultiAddressMask multiMask, string tag) : this(label, value, source, type, labelAnno) { Debug.Assert(comment != null); Debug.Assert(tag != null); if (widthSpecified && type == Type.Constant && source != Source.Variable) { // non-variable constants don't have a width; override arg Debug.WriteLine("Overriding constant DefSymbol width"); widthSpecified = false; } HasWidth = widthSpecified; if (!widthSpecified) { width = DEFAULT_WIDTH; } Debug.Assert(width >= MIN_WIDTH && width <= MAX_WIDTH); DataDescriptor = FormatDescriptor.Create(width, FormatDescriptor.Type.NumericLE, formatSubType); Comment = comment; Debug.Assert(((int)direction & ~(int)DirectionFlags.ReadWrite) == 0); Direction = direction; // constants don't have masks if (type != Type.Constant) { MultiMask = multiMask; } Tag = tag; }