--- /dev/null
+/* { dg-do compile { target arm*-*-* } } */
+/* { dg-options "-march=armv5te -marm -mtune=xscale -mfloat-abi=soft -O1" } */
+
+typedef unsigned int size_t;
+__extension__
+typedef long long int int64_t;
+namespace WTF {
+ template<typename T> class RefPtr {
+ public:
+ inline T* operator->() const { return m_ptr; }
+ T* m_ptr;
+ };
+}
+using WTF::RefPtr;
+namespace JSC {
+ class ExecState;
+ class JSString;
+ typedef int64_t EncodedJSValue;
+ class JSValue {
+ public:
+ static EncodedJSValue encode(JSValue);
+ JSString* toString(ExecState*) const;
+ };
+}
+typedef unsigned char LChar;
+ typedef short unsigned int UChar;
+namespace WTF {
+ template<typename T, size_t inlineCapacity = 0>
+ class Vector {
+ public:
+ template<typename U> bool tryAppend(const U*, size_t);
+ };
+}
+using WTF::Vector;
+namespace WTF {
+template<typename CharType> inline bool isASCIIDigit(CharType c)
+{
+}
+template<typename CharType> inline bool isASCIIHexDigit(CharType c)
+{
+ return isASCIIDigit(c) || ((c | 0x20) >= 'a' && (c | 0x20) <= 'f');
+}
+ class StringImpl;
+}
+using WTF::StringImpl;
+namespace WTF {
+class StringImpl {
+public:
+ unsigned length() const { return m_length; }
+ unsigned m_length;
+};
+}
+namespace JSC {
+ class Register {
+ };
+class UString {
+public:
+ unsigned length() const
+ {
+ return m_impl->length();
+ }
+ const LChar* characters8() const
+ {
+ }
+ RefPtr<StringImpl> m_impl;
+};
+ class ExecState : private Register {
+ public:
+ JSValue argument(size_t argument)
+ {
+ }
+ };
+ class JSCell {
+ };
+ class JSString : public JSCell {
+ public:
+ const UString& value(ExecState*) const;
+ };
+class JSStringBuilder {
+public:
+ void append(const UChar u)
+ {
+ m_okay &= buffer16.tryAppend(&u, 1);
+ }
+ Vector<UChar, 64> buffer16;
+ bool m_okay;
+};
+template <typename T>
+class Lexer {
+public:
+ static unsigned char convertHex(int c1, int c2);
+};
+}
+namespace WTF {
+namespace Unicode {
+ int UTF8SequenceLength(char);
+ int decodeUTF8Sequence(const char*);
+}
+}
+using namespace WTF;
+using namespace Unicode;
+namespace JSC {
+template <typename CharType>
+static JSValue decode(ExecState* exec, const CharType* characters, int length, const char* doNotUnescape, bool strict)
+{
+ JSStringBuilder builder;
+ int k = 0;
+ UChar u = 0;
+ while (k < length) {
+ const CharType* p = characters + k;
+ CharType c = *p;
+ if (c == '%') {
+ int charLen = 0;
+ if (k <= length - 3 && isASCIIHexDigit(p[1]) && isASCIIHexDigit(p[2])) {
+ const char b0 = Lexer<CharType>::convertHex(p[1], p[2]);
+ const int sequenceLen = UTF8SequenceLength(b0);
+ if (sequenceLen && k <= length - sequenceLen * 3) {
+ charLen = sequenceLen * 3;
+ char sequence[5];
+ if (charLen != 0) {
+ const int character = decodeUTF8Sequence(sequence);
+ if (character < 0 || character >= 0x110000)
+ charLen = 0;
+ else if (character >= 0x10000) {
+ builder.append(static_cast<UChar>(0xD800 | ((character - 0x10000) >> 10)));
+ } else
+ u = static_cast<UChar>(character);
+ }
+ }
+ }
+ }
+ }
+}
+static JSValue decode(ExecState* exec, const char* doNotUnescape, bool strict)
+{
+ UString str = exec->argument(0).toString(exec)->value(exec);
+ return decode(exec, str.characters8(), str.length(), doNotUnescape, strict);
+}
+EncodedJSValue globalFuncDecodeURI(ExecState* exec)
+{
+ static const char do_not_unescape_when_decoding_URI[] =
+ "#$&+,/:;=?@";
+ return JSValue::encode(decode(exec, do_not_unescape_when_decoding_URI, true));
+}
+}