|
111
|
1 /* { dg-do compile { target arm*-*-* } } */
|
|
|
2 /* { dg-require-effective-target arm_arch_v5te_ok } */
|
|
|
3 /* { dg-require-effective-target arm_arm_ok } */
|
|
|
4 /* { dg-skip-if "do not override -mfloat-abi" { *-*-* } { "-mfloat-abi=*" } {"-mfloat-abi=soft" } } */
|
|
131
|
5 /* { dg-options "-march=armv5te -marm -mtune=xscale -mfloat-abi=soft -O1 -Wno-return-type" } */
|
|
111
|
6
|
|
|
7 typedef unsigned int size_t;
|
|
|
8 __extension__
|
|
|
9 typedef long long int int64_t;
|
|
|
10 namespace WTF {
|
|
|
11 template<typename T> class RefPtr {
|
|
|
12 public:
|
|
|
13 inline T* operator->() const { return m_ptr; }
|
|
|
14 T* m_ptr;
|
|
|
15 };
|
|
|
16 }
|
|
|
17 using WTF::RefPtr;
|
|
|
18 namespace JSC {
|
|
|
19 class ExecState;
|
|
|
20 class JSString;
|
|
|
21 typedef int64_t EncodedJSValue;
|
|
|
22 class JSValue {
|
|
|
23 public:
|
|
|
24 static EncodedJSValue encode(JSValue);
|
|
|
25 JSString* toString(ExecState*) const;
|
|
|
26 };
|
|
|
27 }
|
|
|
28 typedef unsigned char LChar;
|
|
|
29 typedef short unsigned int UChar;
|
|
|
30 namespace WTF {
|
|
|
31 template<typename T, size_t inlineCapacity = 0>
|
|
|
32 class Vector {
|
|
|
33 public:
|
|
|
34 template<typename U> bool tryAppend(const U*, size_t);
|
|
|
35 };
|
|
|
36 }
|
|
|
37 using WTF::Vector;
|
|
|
38 namespace WTF {
|
|
|
39 template<typename CharType> inline bool isASCIIDigit(CharType c)
|
|
|
40 {
|
|
|
41 }
|
|
|
42 template<typename CharType> inline bool isASCIIHexDigit(CharType c)
|
|
|
43 {
|
|
|
44 return isASCIIDigit(c) || ((c | 0x20) >= 'a' && (c | 0x20) <= 'f');
|
|
|
45 }
|
|
|
46 class StringImpl;
|
|
|
47 }
|
|
|
48 using WTF::StringImpl;
|
|
|
49 namespace WTF {
|
|
|
50 class StringImpl {
|
|
|
51 public:
|
|
|
52 unsigned length() const { return m_length; }
|
|
|
53 unsigned m_length;
|
|
|
54 };
|
|
|
55 }
|
|
|
56 namespace JSC {
|
|
|
57 class Register {
|
|
|
58 };
|
|
|
59 class UString {
|
|
|
60 public:
|
|
|
61 unsigned length() const
|
|
|
62 {
|
|
|
63 return m_impl->length();
|
|
|
64 }
|
|
|
65 const LChar* characters8() const
|
|
|
66 {
|
|
|
67 }
|
|
|
68 RefPtr<StringImpl> m_impl;
|
|
|
69 };
|
|
|
70 class ExecState : private Register {
|
|
|
71 public:
|
|
|
72 JSValue argument(size_t argument)
|
|
|
73 {
|
|
|
74 }
|
|
|
75 };
|
|
|
76 class JSCell {
|
|
|
77 };
|
|
|
78 class JSString : public JSCell {
|
|
|
79 public:
|
|
|
80 const UString& value(ExecState*) const;
|
|
|
81 };
|
|
|
82 class JSStringBuilder {
|
|
|
83 public:
|
|
|
84 void append(const UChar u)
|
|
|
85 {
|
|
|
86 m_okay &= buffer16.tryAppend(&u, 1);
|
|
|
87 }
|
|
|
88 Vector<UChar, 64> buffer16;
|
|
|
89 bool m_okay;
|
|
|
90 };
|
|
|
91 template <typename T>
|
|
|
92 class Lexer {
|
|
|
93 public:
|
|
|
94 static unsigned char convertHex(int c1, int c2);
|
|
|
95 };
|
|
|
96 }
|
|
|
97 namespace WTF {
|
|
|
98 namespace Unicode {
|
|
|
99 int UTF8SequenceLength(char);
|
|
|
100 int decodeUTF8Sequence(const char*);
|
|
|
101 }
|
|
|
102 }
|
|
|
103 using namespace WTF;
|
|
|
104 using namespace Unicode;
|
|
|
105 namespace JSC {
|
|
|
106 template <typename CharType>
|
|
|
107 static JSValue decode(ExecState* exec, const CharType* characters, int length, const char* doNotUnescape, bool strict)
|
|
|
108 {
|
|
|
109 JSStringBuilder builder;
|
|
|
110 int k = 0;
|
|
|
111 UChar u = 0;
|
|
|
112 while (k < length) {
|
|
|
113 const CharType* p = characters + k;
|
|
|
114 CharType c = *p;
|
|
|
115 if (c == '%') {
|
|
|
116 int charLen = 0;
|
|
|
117 if (k <= length - 3 && isASCIIHexDigit(p[1]) && isASCIIHexDigit(p[2])) {
|
|
|
118 const char b0 = Lexer<CharType>::convertHex(p[1], p[2]);
|
|
|
119 const int sequenceLen = UTF8SequenceLength(b0);
|
|
|
120 if (sequenceLen && k <= length - sequenceLen * 3) {
|
|
|
121 charLen = sequenceLen * 3;
|
|
|
122 char sequence[5];
|
|
|
123 if (charLen != 0) {
|
|
|
124 const int character = decodeUTF8Sequence(sequence);
|
|
|
125 if (character < 0 || character >= 0x110000)
|
|
|
126 charLen = 0;
|
|
|
127 else if (character >= 0x10000) {
|
|
|
128 builder.append(static_cast<UChar>(0xD800 | ((character - 0x10000) >> 10)));
|
|
|
129 } else
|
|
|
130 u = static_cast<UChar>(character);
|
|
|
131 }
|
|
|
132 }
|
|
|
133 }
|
|
|
134 }
|
|
|
135 }
|
|
|
136 }
|
|
|
137 static JSValue decode(ExecState* exec, const char* doNotUnescape, bool strict)
|
|
|
138 {
|
|
|
139 UString str = exec->argument(0).toString(exec)->value(exec);
|
|
|
140 return decode(exec, str.characters8(), str.length(), doNotUnescape, strict);
|
|
|
141 }
|
|
|
142 EncodedJSValue globalFuncDecodeURI(ExecState* exec)
|
|
|
143 {
|
|
|
144 static const char do_not_unescape_when_decoding_URI[] =
|
|
|
145 "#$&+,/:;=?@";
|
|
|
146 return JSValue::encode(decode(exec, do_not_unescape_when_decoding_URI, true));
|
|
|
147 }
|
|
|
148 }
|
