Returns a character to indicate the type of an argument.
'$' for String, '@' for other objects, and the binary name character for
the primitives.
17282
private char getStringConcatenationTypeCharacter(Expression operand) {
    TypeMirror operandType = operand.getTypeMirror();
    if (operandType.getKind().isPrimitive()) {
      return TypeUtil.getBinaryName(operandType).charAt(0);
    } else if (typeUtil.isString(operandType)) {
      return '$';
    } else {
      return '@';
    }
  }
676479
public final TypeInfo innerClass(String simpleName) {
    checkArgument(
        simpleName.indexOf('$') == -1, "Simple names shouldn't contain '$': %s", simpleName);
    String className = className() + '$' + simpleName;
    String internalName = internalName() + '$' + simpleName;
    Type type = Type.getObjectType(internalName);
    return new AutoValue_TypeInfo(className, simpleName, internalName, type);
  }
458064
function getType(obj) {
  if (obj === null) return 'null';
  if (typeof obj === undefined) return 'undefined';

  return Object.prototype.toString.call(obj)
          .match(/\s([a-zA-Z]+)/)[1]
          .toLowerCase();
}
1049349
public static String simpleTypeName(Object obj) {
        if (obj == null) {
            return "null";
        }

        return simpleTypeName(obj.getClass(), false);
    }
141325
def symbol_leading_char(self):
        
        if not self._ptr:
            raise BfdException("BFD not initialized")

        return _bfd.get_bfd_attribute(
            self._ptr, BfdAttributes.SYMBOL_LEADING_CHAR)
809704
def type_string(self):
        """"""
        if self.is_tuple:
            subtypes = [item.type_string for item in self.children]
            return '{}({})'.format(
                '' if self.val_guaranteed else '*',
                ', '.join(subtypes))
        elif self.is_list:
            return '{}[{}]'.format(
                '' if self.val_guaranteed else '*',
                self.children[0].type_string)
        else:
            return '{}{}'.format(
                '' if self.val_guaranteed else '*',
                self.type_.__name__)
1185712
def get_char(self, offset=0):
        """"""
        if not self.has_space(offset=offset):
            return ''

        return self.string[self.pos + offset]
325487
function getStringType(str) {
  if (null == str) {
    return -1;
  }

  if (typeof(str) != 'string') {
    return -1;
  }

  if (str.length == 0 || str == "") {
    return -1;
  }

  var i = 0;
  if (str.length == 40) {
    for (; i < 40; i++) {
      var c = str.charAt(i);
      if (!isHexChar(c)) {
        break;
      }
    }
  }
  if (i == 40) {
    return 1;  //40 Hex, Address
  }

  for (i = 0; i < str.length; i++) {
    var c = str.charAt(i);
    if (!isNumber(c)) {
      break;
    }
  }
  if (i == str.length) {
    return 2;  //Alll Decimal number, BlockNumber
  }

  for (i = 0; i < str.length; i++) {
    var c = str.charAt(i);
    if (c > ' ') {
      return 3;   //At least one visible character
    }
  }

  return -1;
}
422709
private TokenType retrieveType(final char paramInput) {

        TokenType type;
        switch (paramInput) {
        case ',':
            type = TokenType.COMMA;
            break;
        case '(':
            type = TokenType.OPEN_BR;
            break;
        case ')':
            type = TokenType.CLOSE_BR;
            break;
        case '[':
            type = TokenType.OPEN_SQP;
            break;
        case ']':
            type = TokenType.CLOSE_SQP;
            break;
        case '@':
            type = TokenType.AT;
            break;
        case '=':
            type = TokenType.EQ;
            break;
        case '<':
        case '>':
            type = TokenType.COMP;
            break;
        case '!':
            type = TokenType.N_EQ;
            break;
        case '/':
            type = TokenType.SLASH;
            break;
        case ':':
            type = TokenType.COLON;
            break;
        case '.':
            type = TokenType.POINT;
            break;
        case '+':
            type = TokenType.PLUS;
            break;
        case '-':
            type = TokenType.MINUS;
            break;
        case '\'':
            type = TokenType.SINGLE_QUOTE;
            break;
        case '"':
            type = TokenType.DBL_QUOTE;
            break;
        case '$':
            type = TokenType.DOLLAR;
            break;
        case '?':
            type = TokenType.INTERROGATION;
            break;
        case '*':
            type = TokenType.STAR;
            break;
        case '|':
            type = TokenType.OR;
            break;
        default:
            type = TokenType.INVALID;
        }
        return type;

    }
685445
def get_op_symbol(obj, fmt='%s', symbol_data=symbol_data, type=type):
    
    return fmt % symbol_data[type(obj)]
895279
function determineType(obj) {
    var type;
    var typeValue;
    var name;

    if (value(obj).typeOf(Object)) {
        type = obj.type || "Object";
    } else {
        type = obj;
    }

    typeValue = value(type);

    if (typeValue.typeOf(String)) {
        name = type.charAt(0).toUpperCase() + type.substring(1);
        return supportedTypes.indexOf(name) === -1 ? "String" : name;
    } else if (typeValue.typeOf(Function)) {
        name = type.toString().match(fnName)[1];
    } else if (typeValue.typeOf(Object)) {
        if (type.type) {
            name = type.type;
        } else {
            return "Object";
        }
    } else {
        name = type.constructor.toString().match(fnName)[1];
    }

    if (supportedTypes.indexOf(name) === -1) {
        throw new TypeError("Type '" + name + "' is not supported");
    }

    return name;
}
821446
public static String getBinaryName(TypeMirror t) {
    switch (t.getKind()) {
      case BOOLEAN: return "Z";
      case BYTE: return "B";
      case CHAR: return "C";
      case DOUBLE: return "D";
      case FLOAT: return "F";
      case INT: return "I";
      case LONG: return "J";
      case SHORT: return "S";
      case VOID: return "V";
      default:
        throw new AssertionError("Cannot resolve binary name for type: " + t);
    }
  }
225484
def as_symbols(self):
        
        out = set()
        for name in self.types:
            out.add(('type', name))
        for name in self.enums:
            out.add(('enum', name))
        for name in self.commands:
            out.add(('command', name))
        return out
145923
public static String unboxArgument (Type type, String name)
    {
        if (Boolean.TYPE.equals(type)) {
            return "((Boolean)" + name + ").booleanValue()";
        } else if (Byte.TYPE.equals(type)) {
            return "((Byte)" + name + ").byteValue()";
        } else if (Character.TYPE.equals(type)) {
            return "((Character)" + name + ").charValue()";
        } else if (Short.TYPE.equals(type)) {
            return "((Short)" + name + ").shortValue()";
        } else if (Integer.TYPE.equals(type)) {
            return "((Integer)" + name + ").intValue()";
        } else if (Long.TYPE.equals(type)) {
            return "((Long)" + name + ").longValue()";
        } else if (Float.TYPE.equals(type)) {
            return "((Float)" + name + ").floatValue()";
        } else if (Double.TYPE.equals(type)) {
            return "((Double)" + name + ").doubleValue()";
        } else if (Object.class.equals(type)) {
            return name; // no need to cast object
        } else if (type instanceof Class<?>) {
            return "(" + simpleName(type) + ")" + name;
        } else {
            return "this.<" + simpleName(type) + ">cast(" + name + ")";
        }
    }
923443
private TypeArgSignature parseTypeArg() {
		int ch = peekChar();
		switch (ch) {
		case '*':
			return new TypeArgSignature(
					(char) nextChar(TypeArgSignature.UNBOUNDED_WILDCARD), null);
		case '+':
			return new TypeArgSignature(
					(char) nextChar(TypeArgSignature.UPPERBOUND_WILDCARD),
					parseFieldTypeSignature());
		case '-':
			return new TypeArgSignature(
					(char) nextChar(TypeArgSignature.LOWERBOUND_WILDCARD),
					parseFieldTypeSignature());
		default:
			return new TypeArgSignature(TypeArgSignature.NO_WILDCARD,
					parseFieldTypeSignature());
		}
	}
327089
private static String getSignature(IMethod mtd) {
    String classType =
        mtd.getDeclaringClass().getName().toString().replaceAll("/", "\\.").substring(1);
    classType = classType.replaceAll("\\$", "\\."); // handle inner class
    String returnType = mtd.isInit() ? null : getSimpleTypeName(mtd.getReturnType());
    String strArgTypes = "";
    int argi = mtd.isStatic() ? 0 : 1; // Skip 'this' parameter
    for (; argi < mtd.getNumberOfParameters(); argi++) {
      strArgTypes += getSimpleTypeName(mtd.getParameterType(argi));
      if (argi < mtd.getNumberOfParameters() - 1) strArgTypes += ", ";
    }
    return classType
        + ":"
        + (returnType == null ? "void " : returnType + " ")
        + mtd.getName().toString()
        + "("
        + strArgTypes
        + ")";
  }
96577
def bin_hex_type(arg):
	""""""
	if re.match(r'^[a-f0-9]{2}(:[a-f0-9]{2})+$', arg, re.I):
		arg = arg.replace(':', '')
	elif re.match(r'^(\\x[a-f0-9]{2})+$', arg, re.I):
		arg = arg.replace('\\x', '')
	try:
		arg = binascii.a2b_hex(arg)
	except (binascii.Error, TypeError):
		raise argparse.ArgumentTypeError("{0} is invalid hex data".format(repr(arg)))
	return arg