This is a raw dump with no character set conversion.
963308
def dump
      out = "\n"
      out += "Type            : #{@bs['desc_type']}\n"
      out += "Record ID       : #{@bs['id']}\n"
      out += "Version         : #{@bs['version']}\n"
      out += "System ID       : #{@bs['system_id'].strip}\n"
      out += "Volume ID       : #{@volName}\n"
      out += "Vol space size  : #{@bs["vol_space_size#{@suff}"]} (sectors)\n"
      out += "Vol set size    : #{@bs["vol_set_size#{@suff}"]}\n"
      out += "Vol sequence num: #{@bs["vol_seq_number#{@suff}"]}\n"
      out += "Logical blk size: #{@bs["log_block_size#{@suff}"]} (sector size)\n"
      out += "Path table size : #{@bs["path_table_size#{@suff}"]}\n"
      out += "Type 1 path tbl : #{@bs["type_1_path_table#{@suff}"]}\n"
      out += "Opt type 1 pth  : #{@bs["opt_type_1_path_table#{@suff}"]}\n"
      out += "Type M path tbl : #{@bs["type_m_path_table#{@suff}"]}\n"
      out += "Opt type M pth  : #{@bs["opt_type_m_path_table#{@suff}"]}\n"
      out += "Vol set ID      : #{@bs['vol_set_id'].strip}\n"
      out += "Publisher ID    : #{@bs['publisher_id'].strip}\n"
      out += "Preparer ID     : #{@bs['preparer_id'].strip}\n"
      out += "Application ID  : #{@bs['application_id'].strip}\n"
      out += "Copyright       : #{@bs['copyright_file_id'].strip}\n"
      out += "Abstract        : #{@bs['abstract_file_id'].strip}\n"
      out += "Biblographic    : #{@bs['biblographic_file_id'].strip}\n"
      out += "Creation date   : #{@bs['creation_date'].strip} (#{@cTime}, tz = #{Util.GetTimezone(@bs['creation_date'])})\n"
      out += "Mod date        : #{@bs['modification_date'].strip} (#{@mTime}, tz = #{Util.GetTimezone(@bs['modification_date'])})\n"
      out += "Expiration date : #{@bs['experation_date'].strip} (#{@expirationDate}, tz = #{Util.GetTimezone(@bs['experation_date'])})\n"
      out += "Effective date  : #{@bs['effective_date'].strip} (#{@effectiveDate}, tz = #{Util.GetTimezone(@bs['effective_date'])})\n"
      out += "File strct ver  : #{@bs['file_structure_version']}\n"
      out += "Application data: #{@bs['application_data'].strip}\n"
    end
423026
public static SoyMsgRawTextPart of(String rawText) {
    int utf8Length = Utf8.encodedLength(rawText);

    // Determine whether UTF8 or UTF16 uses less memory, and choose between one of the two internal
    // implementations. char[] is preferred if the sizes are equal because it is faster to turn
    // back into a String. In a realistic application with 1 million messages in memory, using
    // UTF-8 saves about 35M, and dynamicaly switching encodings saves another 10M.

    // IMPORTANT! This choice is deterministic, so that for any particular input string the choice
    // of implementation class is the same. This ensures operations like equals() and hashCode()
    // do not have to decode the contents.

    if (utf8Length < rawText.length() * BYTES_PER_CHAR) {
      return new Utf8SoyMsgRawTextPart(rawText);
    } else {
      return new CharArraySoyMsgRawTextPart(rawText);
    }
  }
250730
def unescape_unreserved(input)
      input.gsub(/%([a-f\d]{2})/i) do |encoded|
        decoded = $1.hex.chr

        if decoded =~ UNRESERVED_OR_UTF8
          decoded
        else
          encoded
        end
      end
    end
90537
def dump_rawdata(self):
        """"""
        if hasattr(self, 'transport'):
            attrs = vars(self.transport)
            return ', '.join("%s: %s" % item for item in attrs.items())
224420
def dump(self, indentation=0):
        """"""
        
        dump = []
        
        dump.append('[%s]' % self.name)
        
        # Refer to the __set_format__ method for an explanation
        # of the following construct.
        for keys in self.__keys__:
            for key in keys:
                
                val = getattr(self, key)
                if isinstance(val, int) or isinstance(val, long):
                    val_str = '0x%-8X' % (val)
                    if key == 'TimeDateStamp' or key == 'dwTimeStamp':
                        try:
                            val_str += ' [%s UTC]' % time.asctime(time.gmtime(val))
                        except exceptions.ValueError, e:
                            val_str += ' [INVALID TIME]'
                else:
                    val_str = ''.join(filter(lambda c:c != '\0', str(val)))
                
                dump.append('0x%-8X 0x%-3X %-30s %s' % (
                    self.__field_offsets__[key] + self.__file_offset__, 
                    self.__field_offsets__[key], key+':', val_str))
        
        return dump
1296230
public StringBuffer dumpAll() {
		WComponent root = WebUtilities.getTop(this);

		Map<String, GroupData> compTallyByClass = new TreeMap<>();

		GroupData compDataOverall = new GroupData();

		StringBuffer out = new StringBuffer();

		String className = root.getClass().getName();

		out.append("<strong>The root of the WComponent tree is:</strong><br/>").append(className).append(
				"<br/>");

		tally(root, compTallyByClass, compDataOverall, out);

		out.append("<strong>WComponent usage overall:</strong><br/> ");
		out.append(compDataOverall.total).append(" WComponent(s) in the WComponent tree.<br/>");

		if (compDataOverall.total > 0) {
			out.append("<strong>WComponent usage by class:</strong><br/>");

			for (Map.Entry<String, GroupData> entry : compTallyByClass.entrySet()) {
				className = entry.getKey();
				GroupData dataForClass = entry.getValue();
				out.append(' ').append(dataForClass.total).append("  ").append(className).append(
						"<br/>");
			}

			out.append("<br/><hr/>");
		}

		processUic(out);

		return out;
	}
86379
@SuppressWarnings("unused")
    private static final void dump(IoBuffer data) {
        log.debug("Hex: {}", data.getHexDump());
        int pos = data.position();
        byte[] bar = new byte[data.limit() - data.position()];
        data.get(bar);
        log.debug("Str {}", new String(bar));
        bar = null;
        data.position(pos);
    }
644358
def RawBytesToScriptHash(raw):
        
        rawh = binascii.unhexlify(raw)
        rawhashstr = binascii.unhexlify(bytes(Crypto.Hash160(rawh), encoding='utf-8'))
        return UInt160(data=rawhashstr)
583009
private static String unescape( String str, String encoding )
    {
        //We cannot unescape '+' to space because '+' is allowed in the file name
        //str = str.replace('+', ' ');
        
        //if the str does not contain "%", we don't need to do anything
        if ( str.indexOf( '%' ) < 0 )
        {
            return str;
        }

        if ( encoding == null || encoding.length() == 0 )
        {
            encoding = WLS_DEFAULT_ENCODING;
        }
        
        // Do not assume String only contains ascii.  str.length() <= str.getBytes().length
        int out = 0;

        byte[] strbytes = str.getBytes();
        int len = strbytes.length;

        boolean foundNonAscii = false;
        for ( int in = 0; in < len; in++, out++ )
        {
            if ( strbytes[in] == '%' && ( in + 2 < len ) )
            {
                if ( Hex.isHexChar( strbytes[in + 1] ) &&
                     Hex.isHexChar( strbytes[in + 2] ) )
                {
                    strbytes[out] =
                    ( byte ) ( ( Hex.hexValueOf( strbytes[in + 1] ) << 4 ) +
                               ( Hex.hexValueOf( strbytes[in + 2] ) << 0 ) );
                    in += 2;
                    continue;
                }
            }
            // IE takes non-ASCII URLs. We use the default encoding
            // if non-ASCII characters are contained in URLs.
            if ( !foundNonAscii &&
                 ( strbytes[in] <= 0x1f || strbytes[in] == 0x7f ) )
            {
                encoding = System.getProperty( "file.encoding" );
                foundNonAscii = true;
            }
            strbytes[out] = strbytes[in];
        }

        return newString( strbytes, 0, out, encoding );  // was:  BytesToString.newString(...)
    }
156346
def hexdump(src, length=8):
    
    if not src:
        return str(src)
    src = input_validate_str(src, 'src')
    offset = 0
    result = ''
    for this in group(src, length):
        hex_s = ' '.join(["%02x" % ord(x) for x in this])
        result += "%04X   %s\n" % (offset, hex_s)
        offset += length
    return result
506544
public String dump()
   {
      StringBuilder vals = new StringBuilder("Property ");
      try
      {
         vals = new StringBuilder(getPath()).append(" values: ");
         for (int i = 0; i < getValueArray().length; i++)
         {
            vals.append(ValueDataUtil.getString(((BaseValue)getValueArray()[i]).getInternalData())).append(";");
         }
      }
      catch (Exception e)
      {
         LOG.error(e.getLocalizedMessage(), e);
      }
      return vals.toString();
   }
1186500
def dump(self, value):
        
        value = self.__convert__(value)
        self.__validate__(value)
        return self.__serialize__(value)
637214
def dump(self,indent='',depth=0):
        """"""
        out = []
        out.append( indent+_ustr(self.asList()) )
        keys = self.items()
        keys.sort()
        for k,v in keys:
            if out:
                out.append('\n')
            out.append( "%s%s- %s: " % (indent,('  '*depth), k) )
            if isinstance(v,ParseResults):
                if v.keys():
                    out.append( v.dump(indent,depth+1) )
                else:
                    out.append(_ustr(v))
            else:
                out.append(_ustr(v))
        return "".join(out)
577681
public static function dump() {
         global $DEBUG_STRING;
         $retval = '';
         $sess = (strlen(session_id()) > 0 );
         if ( $sess ) {
             // echo("<br/>=== DUMP ====<br/>".$_SESSION['__zzz_debug']."<br/>\n");flush();
             if (strlen($_SESSION['__zzz_debug']) > 0) {
                 $retval = $_SESSION['__zzz_debug'];
                 unset($_SESSION['__zzz_debug']);
             }
         }
         if ( strlen($retval) > 0 && strlen($DEBUG_STRING) > 0) {
             $retval .= "\n";
         }
         if (strlen($DEBUG_STRING) > 0) {
             $retval .= $DEBUG_STRING;
             $DEBUG_STRING = '';
         }
         return $retval;
     }
1096965
def dumps(obj, preserve=False):
    
    f = StringIO()
    dump(obj, f, preserve)
    return f.getvalue()
1363113
public static String encode(byte[] rawData) {
        StringBuilder buffer = new StringBuilder(4 * rawData.length / 3);

        int pos = 0;
        int iterations = rawData.length / 3;
        for (int i = 0; i < iterations; i++) {
            int value = ((rawData[pos++] & 0xFF) << 16) |
                    ((rawData[pos++] & 0xFF) << 8) | (rawData[pos++] & 0xFF);

            buffer.append(BASE64_ALPHABET[(value >>> 18) & 0x3F]);
            buffer.append(BASE64_ALPHABET[(value >>> 12) & 0x3F]);
            buffer.append(BASE64_ALPHABET[(value >>> 6) & 0x3F]);
            buffer.append(BASE64_ALPHABET[value & 0x3F]);
        }

        switch (rawData.length % 3) {
            case 1:
                buffer.append(BASE64_ALPHABET[(rawData[pos] >>> 2) & 0x3F]);
                buffer.append(BASE64_ALPHABET[(rawData[pos] << 4) & 0x3F]);
                buffer.append("==");
                break;
            case 2:
                int value = ((rawData[pos++] & 0xFF) << 8) | (rawData[pos] & 0xFF);
                buffer.append(BASE64_ALPHABET[(value >>> 10) & 0x3F]);
                buffer.append(BASE64_ALPHABET[(value >>> 4) & 0x3F]);
                buffer.append(BASE64_ALPHABET[(value << 2) & 0x3F]);
                buffer.append("=");
                break;
        }

        return buffer.toString();
    }
254373
private String string() {
    char quote = peek(0);
    int start = ++_x;
    boolean has_escapes = false;
    while (_x < _str.length()) {
      char c = peek(0);
      if (c == '\\') {
        has_escapes = true;
        char cc = peek(1);
        if (simpleEscapeSequences.containsKey(cc)) {
          _x += 2;
        } else if (cc == 'x') {
          _x += 4;   // e.g: \x5A
        } else if (cc == 'u') {
          _x += 6;   // e.g: \u1234
        } else if (cc == 'U') {
          _x += 10;  // e.g: \U0010FFFF
        } else
          throw new IllegalASTException("Invalid escape sequence \\" + cc);
      } else if (c == quote) {
        _x++;
        if (has_escapes) {
          StringBuilder sb = new StringBuilder();
          for (int i = start; i < _x - 1; i++) {
            char ch = _str.charAt(i);
            if (ch == '\\') {
              char cc = _str.charAt(++i);
              if (simpleEscapeSequences.containsKey(cc)) {
                sb.append(simpleEscapeSequences.get(cc));
              } else {
                int n = (cc == 'x')? 2 : (cc == 'u')? 4 : (cc == 'U')? 8 : -1;
                int hex = -1;
                try {
                  hex = StringUtils.unhex(_str.substring(i + 1, i + 1 + n));
                } catch (NumberFormatException e) {
                  throw new IllegalASTException(e.toString());
                }
                if (hex > 0x10FFFF)
                  throw new IllegalASTException("Illegal unicode codepoint " + hex);
                sb.append(Character.toChars(hex));
                i += n;
              }
            } else {
              sb.append(ch);
            }
          }
          return sb.toString();
        } else {
          return _str.substring(start, _x - 1);
        }
      } else {
        _x++;
      }
    }
    throw new IllegalASTException("Unterminated string at " + start);
  }