/* Write a constant expression in binary form to a buffer. */ int gfc_target_encode_expr (gfc_expr *source, unsigned char *buffer, size_t buffer_size) { if (source == NULL) return 0; if (source->expr_type == EXPR_ARRAY) return encode_array (source, buffer, buffer_size); gcc_assert (source->expr_type == EXPR_CONSTANT || source->expr_type == EXPR_STRUCTURE || source->expr_type == EXPR_SUBSTRING); /* If we already have a target-memory representation, we use that rather than recreating one. */ if (source->representation.string) { memcpy (buffer, source->representation.string, source->representation.length); return source->representation.length; } switch (source->ts.type) { case BT_INTEGER: return encode_integer (source->ts.kind, source->value.integer, buffer, buffer_size); case BT_REAL: return encode_float (source->ts.kind, source->value.real, buffer, buffer_size); case BT_COMPLEX: return encode_complex (source->ts.kind, source->value.complex.r, source->value.complex.i, buffer, buffer_size); case BT_LOGICAL: return encode_logical (source->ts.kind, source->value.logical, buffer, buffer_size); case BT_CHARACTER: if (source->expr_type == EXPR_CONSTANT || source->ref == NULL) return encode_character (source->value.character.length, source->value.character.string, buffer, buffer_size); else { int start, end; gcc_assert (source->expr_type == EXPR_SUBSTRING); gfc_extract_int (source->ref->u.ss.start, &start); gfc_extract_int (source->ref->u.ss.end, &end); return encode_character (MAX(end - start + 1, 0), &source->value.character.string[start-1], buffer, buffer_size); } case BT_DERIVED: return encode_derived (source, buffer, buffer_size); default: gfc_internal_error ("Invalid expression in gfc_target_encode_expr."); return 0; } }
// static std::string LLURI::escape( const std::string& str, const std::string& allowed, bool is_allowed_sorted) { // *NOTE: This size determination feels like a good value to // me. If someone wante to come up with a more precise heuristic // with some data to back up the assertion that 'sort is good' // then feel free to change this test a bit. if(!is_allowed_sorted && (str.size() > 2 * allowed.size())) { // if it's already sorted, or if the url is quite long, we // want to optimize this process. std::string sorted_allowed(allowed); std::sort(sorted_allowed.begin(), sorted_allowed.end()); return escape(str, sorted_allowed, true); } std::ostringstream ostr; std::string::const_iterator it = str.begin(); std::string::const_iterator end = str.end(); std::string::value_type c; if(is_allowed_sorted) { std::string::const_iterator allowed_begin(allowed.begin()); std::string::const_iterator allowed_end(allowed.end()); for(; it != end; ++it) { c = *it; if(std::binary_search(allowed_begin, allowed_end, c)) { ostr << c; } else { encode_character(ostr, c); } } } else { for(; it != end; ++it) { c = *it; if(allowed.find(c) == std::string::npos) { encode_character(ostr, c); } else { ostr << c; } } } return ostr.str(); }