]> git.saurik.com Git - wxWidgets.git/blob - src/common/uri.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Unicode fixes
[wxWidgets.git] / src / common / uri.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: uri.cpp
3 // Purpose: Implementation of a uri parser
4 // Author: Ryan Norton
5 // Created: 10/26/04
6 // RCS-ID: $Id$
7 // Copyright: (c) 2004 Ryan Norton
8 // Licence: wxWindows
9 /////////////////////////////////////////////////////////////////////////////
10
11 // ===========================================================================
12 // declarations
13 // ===========================================================================
14
15 // ---------------------------------------------------------------------------
16 // headers
17 // ---------------------------------------------------------------------------
18
19 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
20 #pragma implementation "uri.h"
21 #endif
22
23 // For compilers that support precompilation, includes "wx.h".
24 #include "wx/wxprec.h"
25
26 #ifdef __BORLANDC__
27 #pragma hdrstop
28 #endif
29
30 #include "wx/uri.h"
31
32 // ---------------------------------------------------------------------------
33 // definitions
34 // ---------------------------------------------------------------------------
35
36 IMPLEMENT_CLASS(wxURI, wxObject);
37
38 // ===========================================================================
39 // implementation
40 // ===========================================================================
41
42 // ---------------------------------------------------------------------------
43 // utilities
44 // ---------------------------------------------------------------------------
45
46 // ---------------------------------------------------------------------------
47 //
48 // wxURI
49 //
50 // ---------------------------------------------------------------------------
51
52 // ---------------------------------------------------------------------------
53 // Constructors
54 // ---------------------------------------------------------------------------
55
56 wxURI::wxURI() : m_hostType(wxURI_REGNAME), m_fields(0)
57 {
58 }
59
60 wxURI::wxURI(const wxString& uri) : m_hostType(wxURI_REGNAME), m_fields(0)
61 {
62 Create(uri);
63 }
64
65 wxURI::wxURI(const wxURI& uri) : wxObject(), m_hostType(wxURI_REGNAME), m_fields(0)
66 {
67 Assign(uri);
68 }
69
70 // ---------------------------------------------------------------------------
71 // Destructor and cleanup
72 // ---------------------------------------------------------------------------
73
74 wxURI::~wxURI()
75 {
76 Clear();
77 }
78
79 void wxURI::Clear()
80 {
81 m_scheme = m_userinfo = m_server = m_port = m_path =
82 m_query = m_fragment = wxEmptyString;
83
84 m_hostType = wxURI_REGNAME;
85
86 m_fields = 0;
87 }
88
89 // ---------------------------------------------------------------------------
90 // Create
91 //
92 // This creates the URI - all we do here is call the main parsing method
93 // ---------------------------------------------------------------------------
94
95 const wxChar* wxURI::Create(const wxString& uri)
96 {
97 if (m_fields)
98 Clear();
99
100 return Parse(uri);
101 }
102
103 // ---------------------------------------------------------------------------
104 // Escape Methods
105 //
106 // TranslateEscape unencodes a 3 character URL escape sequence
107 //
108 // Escape encodes an invalid URI character into a 3 character sequence
109 //
110 // IsEscape determines if the input string contains an escape sequence,
111 // if it does, then it moves the input string past the escape sequence
112 //
113 // Unescape unencodes all 3 character URL escape sequences in a wxString
114 // ---------------------------------------------------------------------------
115
116 wxChar wxURI::TranslateEscape(const wxChar* s)
117 {
118 wxASSERT_MSG( IsHex(s[0]) && IsHex(s[1]), wxT("Invalid escape sequence!"));
119
120 return (wxChar)( CharToHex(s[0]) << 4 ) | CharToHex(s[1]);
121 }
122
123 wxString wxURI::Unescape(const wxString& uri)
124 {
125 wxString new_uri;
126
127 for(size_t i = 0; i < uri.length(); ++i)
128 {
129 if (uri[i] == wxT('%'))
130 {
131 new_uri += wxURI::TranslateEscape( &(uri.c_str()[i+1]) );
132 i += 2;
133 }
134 else
135 new_uri += uri[i];
136 }
137
138 return new_uri;
139 }
140
141 void wxURI::Escape(wxString& s, const wxChar& c)
142 {
143 const wxChar* hdig = wxT("0123456789abcdef");
144 s += wxT('%');
145 s += hdig[(c >> 4) & 15];
146 s += hdig[c & 15];
147 }
148
149 bool wxURI::IsEscape(const wxChar*& uri)
150 {
151 // pct-encoded = "%" HEXDIG HEXDIG
152 if(*uri == wxT('%') && IsHex(*(uri+1)) && IsHex(*(uri+2)))
153 {
154 uri += 3;
155 return true;
156 }
157 else
158 return false;
159 }
160
161 // ---------------------------------------------------------------------------
162 // GetUser
163 // GetPassword
164 //
165 // Gets the username and password via the old URL method.
166 // ---------------------------------------------------------------------------
167 wxString wxURI::GetUser() const
168 {
169 size_t dwPasswordPos = m_userinfo.find(':');
170
171 if (dwPasswordPos == wxString::npos)
172 dwPasswordPos = 0;
173
174 return m_userinfo(0, dwPasswordPos);
175 }
176
177 wxString wxURI::GetPassword() const
178 {
179 size_t dwPasswordPos = m_userinfo.find(':');
180
181 if (dwPasswordPos == wxString::npos)
182 return wxT("");
183 else
184 return m_userinfo(dwPasswordPos+1, m_userinfo.length() + 1);
185 }
186
187 // ---------------------------------------------------------------------------
188 // BuildURI
189 //
190 // BuildURI() builds the entire URI into a useable
191 // representation, including proper identification characters such as slashes
192 //
193 // BuildUnescapedURI() does the same thing as BuildURI(), only it unescapes
194 // the components that accept escape sequences
195 // ---------------------------------------------------------------------------
196
197 wxString wxURI::BuildURI() const
198 {
199 wxString ret;
200
201 if (HasScheme())
202 ret = ret + m_scheme + wxT(":");
203
204 if (HasServer())
205 {
206 ret += wxT("//");
207
208 if (HasUserInfo())
209 ret = ret + m_userinfo + wxT("@");
210
211 ret += m_server;
212
213 if (HasPort())
214 ret = ret + wxT(":") + m_port;
215 }
216
217 ret += m_path;
218
219 if (HasQuery())
220 ret = ret + wxT("?") + m_query;
221
222 if (HasFragment())
223 ret = ret + wxT("#") + m_fragment;
224
225 return ret;
226 }
227
228 wxString wxURI::BuildUnescapedURI() const
229 {
230 wxString ret;
231
232 if (HasScheme())
233 ret = ret + m_scheme + wxT(":");
234
235 if (HasServer())
236 {
237 ret += wxT("//");
238
239 if (HasUserInfo())
240 ret = ret + wxURI::Unescape(m_userinfo) + wxT("@");
241
242 if (m_hostType == wxURI_REGNAME)
243 ret += wxURI::Unescape(m_server);
244 else
245 ret += m_server;
246
247 if (HasPort())
248 ret = ret + wxT(":") + m_port;
249 }
250
251 ret += wxURI::Unescape(m_path);
252
253 if (HasQuery())
254 ret = ret + wxT("?") + wxURI::Unescape(m_query);
255
256 if (HasFragment())
257 ret = ret + wxT("#") + wxURI::Unescape(m_fragment);
258
259 return ret;
260 }
261
262 // ---------------------------------------------------------------------------
263 // Assignment
264 // ---------------------------------------------------------------------------
265
266 wxURI& wxURI::Assign(const wxURI& uri)
267 {
268 //assign fields
269 m_fields = uri.m_fields;
270
271 //ref over components
272 m_scheme = uri.m_scheme;
273 m_userinfo = uri.m_userinfo;
274 m_server = uri.m_server;
275 m_hostType = uri.m_hostType;
276 m_port = uri.m_port;
277 m_path = uri.m_path;
278 m_query = uri.m_query;
279 m_fragment = uri.m_fragment;
280
281 return *this;
282 }
283
284 wxURI& wxURI::operator = (const wxURI& uri)
285 {
286 return Assign(uri);
287 }
288
289 wxURI& wxURI::operator = (const wxString& string)
290 {
291 Create(string);
292 return *this;
293 }
294
295 // ---------------------------------------------------------------------------
296 // Comparison
297 // ---------------------------------------------------------------------------
298
299 bool wxURI::operator == (const wxURI& uri) const
300 {
301 if (HasScheme())
302 {
303 if(m_scheme != uri.m_scheme)
304 return false;
305 }
306 else if (uri.HasScheme())
307 return false;
308
309
310 if (HasServer())
311 {
312 if (HasUserInfo())
313 {
314 if (m_userinfo != uri.m_userinfo)
315 return false;
316 }
317 else if (uri.HasUserInfo())
318 return false;
319
320 if (m_server != uri.m_server ||
321 m_hostType != uri.m_hostType)
322 return false;
323
324 if (HasPort())
325 {
326 if(m_port != uri.m_port)
327 return false;
328 }
329 else if (uri.HasPort())
330 return false;
331 }
332 else if (uri.HasServer())
333 return false;
334
335
336 if (HasPath())
337 {
338 if(m_path != uri.m_path)
339 return false;
340 }
341 else if (uri.HasPath())
342 return false;
343
344 if (HasQuery())
345 {
346 if (m_query != uri.m_query)
347 return false;
348 }
349 else if (uri.HasQuery())
350 return false;
351
352 if (HasFragment())
353 {
354 if (m_fragment != uri.m_fragment)
355 return false;
356 }
357 else if (uri.HasFragment())
358 return false;
359
360 return true;
361 }
362
363 // ---------------------------------------------------------------------------
364 // IsReference
365 //
366 // if there is no authority or scheme, it is a reference
367 // ---------------------------------------------------------------------------
368
369 bool wxURI::IsReference() const
370 { return !HasScheme() || !HasServer(); }
371
372 // ---------------------------------------------------------------------------
373 // Parse
374 //
375 // Master URI parsing method. Just calls the individual parsing methods
376 //
377 // URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
378 // URI-reference = URI / relative
379 // ---------------------------------------------------------------------------
380
381 const wxChar* wxURI::Parse(const wxChar* uri)
382 {
383 uri = ParseScheme(uri);
384 uri = ParseAuthority(uri);
385 uri = ParsePath(uri);
386 uri = ParseQuery(uri);
387 return ParseFragment(uri);
388 }
389
390 // ---------------------------------------------------------------------------
391 // ParseXXX
392 //
393 // Individual parsers for each URI component
394 // ---------------------------------------------------------------------------
395
396 const wxChar* wxURI::ParseScheme(const wxChar* uri)
397 {
398 wxASSERT(uri != NULL);
399
400 //copy of the uri - used for figuring out
401 //length of each component
402 const wxChar* uricopy = uri;
403
404 //Does the uri have a scheme (first character alpha)?
405 if (IsAlpha(*uri))
406 {
407 m_scheme += *uri++;
408
409 //scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
410 while (IsAlpha(*uri) || IsDigit(*uri) ||
411 *uri == wxT('+') ||
412 *uri == wxT('-') ||
413 *uri == wxT('.'))
414 {
415 m_scheme += *uri++;
416 }
417
418 //valid scheme?
419 if (*uri == wxT(':'))
420 {
421 //mark the scheme as valid
422 m_fields |= wxURI_SCHEME;
423
424 //move reference point up to input buffer
425 uricopy = ++uri;
426 }
427 else
428 //relative uri with relative path reference
429 m_scheme = wxEmptyString;
430 }
431 // else
432 //relative uri with _possible_ relative path reference
433
434 return uricopy;
435 }
436
437 const wxChar* wxURI::ParseAuthority(const wxChar* uri)
438 {
439 // authority = [ userinfo "@" ] host [ ":" port ]
440 if (*uri == wxT('/') && *(uri+1) == wxT('/'))
441 {
442 uri += 2;
443
444 uri = ParseUserInfo(uri);
445 uri = ParseServer(uri);
446 return ParsePort(uri);
447 }
448
449 return uri;
450 }
451
452 const wxChar* wxURI::ParseUserInfo(const wxChar* uri)
453 {
454 wxASSERT(uri != NULL);
455
456 //copy of the uri - used for figuring out
457 //length of each component
458 const wxChar* uricopy = uri;
459
460 // userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
461 while(*uri && *uri != wxT('@') && *uri != wxT('/') && *uri != wxT('#') && *uri != wxT('?'))
462 {
463 if(IsUnreserved(*uri) || IsEscape(uri) ||
464 IsSubDelim(*uri) || *uri == wxT(':'))
465 m_userinfo += *uri++;
466 else
467 Escape(m_userinfo, *uri++);
468 }
469
470 if(*uri == wxT('@'))
471 {
472 //valid userinfo
473 m_fields |= wxURI_USERINFO;
474
475 uricopy = ++uri;
476 }
477 else
478 m_userinfo = wxEmptyString;
479
480 return uricopy;
481 }
482
483 const wxChar* wxURI::ParseServer(const wxChar* uri)
484 {
485 wxASSERT(uri != NULL);
486
487 //copy of the uri - used for figuring out
488 //length of each component
489 const wxChar* uricopy = uri;
490
491 // host = IP-literal / IPv4address / reg-name
492 // IP-literal = "[" ( IPv6address / IPvFuture ) "]"
493 if (*uri == wxT('['))
494 {
495 ++uri; //some compilers don't support *&ing a ++*
496 if (ParseIPv6address(uri) && *uri == wxT(']'))
497 {
498 ++uri;
499 m_hostType = wxURI_IPV6ADDRESS;
500
501 wxStringBufferLength theBuffer(m_server, uri - uricopy);
502 wxTmemcpy(theBuffer, uricopy, uri-uricopy);
503 theBuffer.SetLength(uri-uricopy);
504 }
505 else
506 {
507 uri = uricopy;
508
509 ++uri; //some compilers don't support *&ing a ++*
510 if (ParseIPvFuture(uri) && *uri == wxT(']'))
511 {
512 ++uri;
513 m_hostType = wxURI_IPVFUTURE;
514
515 wxStringBufferLength theBuffer(m_server, uri - uricopy);
516 wxTmemcpy(theBuffer, uricopy, uri-uricopy);
517 theBuffer.SetLength(uri-uricopy);
518 }
519 else
520 uri = uricopy;
521 }
522 }
523 else
524 {
525 if (ParseIPv4address(uri))
526 {
527 m_hostType = wxURI_IPV4ADDRESS;
528
529 wxStringBufferLength theBuffer(m_server, uri - uricopy);
530 wxTmemcpy(theBuffer, uricopy, uri-uricopy);
531 theBuffer.SetLength(uri-uricopy);
532 }
533 else
534 uri = uricopy;
535 }
536
537 if(m_hostType == wxURI_REGNAME)
538 {
539 uri = uricopy;
540 // reg-name = *( unreserved / pct-encoded / sub-delims )
541 while(*uri && *uri != wxT('/') && *uri != wxT(':') && *uri != wxT('#') && *uri != wxT('?'))
542 {
543 if(IsUnreserved(*uri) || IsEscape(uri) || IsSubDelim(*uri))
544 m_server += *uri++;
545 else
546 Escape(m_server, *uri++);
547 }
548 }
549
550 //mark the server as valid
551 m_fields |= wxURI_SERVER;
552
553 return uri;
554 }
555
556
557 const wxChar* wxURI::ParsePort(const wxChar* uri)
558 {
559 wxASSERT(uri != NULL);
560
561 // port = *DIGIT
562 if(*uri == wxT(':'))
563 {
564 ++uri;
565 while(IsDigit(*uri))
566 {
567 m_port += *uri++;
568 }
569
570 //mark the port as valid
571 m_fields |= wxURI_PORT;
572 }
573
574 return uri;
575 }
576
577 const wxChar* wxURI::ParsePath(const wxChar* uri, bool bReference, bool bNormalize)
578 {
579 wxASSERT(uri != NULL);
580
581 //copy of the uri - used for figuring out
582 //length of each component
583 const wxChar* uricopy = uri;
584
585 /// hier-part = "//" authority path-abempty
586 /// / path-absolute
587 /// / path-rootless
588 /// / path-empty
589 ///
590 /// relative-part = "//" authority path-abempty
591 /// / path-absolute
592 /// / path-noscheme
593 /// / path-empty
594 ///
595 /// path-abempty = *( "/" segment )
596 /// path-absolute = "/" [ segment-nz *( "/" segment ) ]
597 /// path-noscheme = segment-nz-nc *( "/" segment )
598 /// path-rootless = segment-nz *( "/" segment )
599 /// path-empty = 0<pchar>
600 ///
601 /// segment = *pchar
602 /// segment-nz = 1*pchar
603 /// segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" )
604 /// ; non-zero-length segment without any colon ":"
605 ///
606 /// pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
607 if (*uri == wxT('/'))
608 {
609 m_path += *uri++;
610
611 while(*uri && *uri != wxT('#') && *uri != wxT('?'))
612 {
613 if( IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) ||
614 *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/'))
615 m_path += *uri++;
616 else
617 Escape(m_path, *uri++);
618 }
619
620 if (bNormalize)
621 {
622 wxStringBufferLength theBuffer(m_path, m_path.length() + 1);
623 #if wxUSE_STL
624 wxTmemcpy(theBuffer, m_path.c_str(), m_path.length()+1);
625 #endif
626 Normalize(theBuffer, true);
627 theBuffer.SetLength(wxStrlen(theBuffer));
628 }
629 //mark the path as valid
630 m_fields |= wxURI_PATH;
631 }
632 else if(*uri) //Relative path
633 {
634 if (bReference)
635 {
636 //no colon allowed
637 while(*uri && *uri != wxT('#') && *uri != wxT('?'))
638 {
639 if(IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) ||
640 *uri == wxT('@') || *uri == wxT('/'))
641 m_path += *uri++;
642 else
643 Escape(m_path, *uri++);
644 }
645 }
646 else
647 {
648 while(*uri && *uri != wxT('#') && *uri != wxT('?'))
649 {
650 if(IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) ||
651 *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/'))
652 m_path += *uri++;
653 else
654 Escape(m_path, *uri++);
655 }
656 }
657
658 if (uri != uricopy)
659 {
660 if (bNormalize)
661 {
662 wxStringBufferLength theBuffer(m_path, m_path.length() + 1);
663 #if wxUSE_STL
664 wxTmemcpy(theBuffer, m_path.c_str(), m_path.length()+1);
665 #endif
666 Normalize(theBuffer);
667 theBuffer.SetLength(wxStrlen(theBuffer));
668 }
669
670 //mark the path as valid
671 m_fields |= wxURI_PATH;
672 }
673 }
674
675 return uri;
676 }
677
678
679 const wxChar* wxURI::ParseQuery(const wxChar* uri)
680 {
681 wxASSERT(uri != NULL);
682
683 // query = *( pchar / "/" / "?" )
684 if (*uri == wxT('?'))
685 {
686 ++uri;
687 while(*uri && *uri != wxT('#'))
688 {
689 if (IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) ||
690 *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/') || *uri == wxT('?'))
691 m_query += *uri++;
692 else
693 Escape(m_query, *uri++);
694 }
695
696 //mark the server as valid
697 m_fields |= wxURI_QUERY;
698 }
699
700 return uri;
701 }
702
703
704 const wxChar* wxURI::ParseFragment(const wxChar* uri)
705 {
706 wxASSERT(uri != NULL);
707
708 // fragment = *( pchar / "/" / "?" )
709 if (*uri == wxT('#'))
710 {
711 ++uri;
712 while(*uri)
713 {
714 if (IsUnreserved(*uri) || IsSubDelim(*uri) || IsEscape(uri) ||
715 *uri == wxT(':') || *uri == wxT('@') || *uri == wxT('/') || *uri == wxT('?'))
716 m_fragment += *uri++;
717 else
718 Escape(m_fragment, *uri++);
719 }
720
721 //mark the server as valid
722 m_fields |= wxURI_FRAGMENT;
723 }
724
725 return uri;
726 }
727
728 // ---------------------------------------------------------------------------
729 // Resolve
730 //
731 // Builds missing components of this uri from a base uri
732 //
733 // A version of the algorithm outlined in the RFC is used here
734 // (it is shown in comments)
735 //
736 // Note that an empty URI inherits all components
737 // ---------------------------------------------------------------------------
738
739 void wxURI::Resolve(const wxURI& base, int flags)
740 {
741 wxASSERT_MSG(!base.IsReference(),
742 wxT("wxURI to inherit from must not be a reference!"));
743
744 // If we arn't being strict, enable the older (pre-RFC2396)
745 // loophole that allows this uri to inherit other
746 // properties from the base uri - even if the scheme
747 // is defined
748 if ( !(flags & wxURI_STRICT) &&
749 HasScheme() && base.HasScheme() &&
750 m_scheme == base.m_scheme )
751 {
752 m_fields -= wxURI_SCHEME;
753 }
754
755
756 // Do nothing if this is an absolute wxURI
757 // if defined(R.scheme) then
758 // T.scheme = R.scheme;
759 // T.authority = R.authority;
760 // T.path = remove_dot_segments(R.path);
761 // T.query = R.query;
762 if (HasScheme())
763 {
764 return;
765 }
766
767 //No scheme - inherit
768 m_scheme = base.m_scheme;
769 m_fields |= wxURI_SCHEME;
770
771 // All we need to do for relative URIs with an
772 // authority component is just inherit the scheme
773 // if defined(R.authority) then
774 // T.authority = R.authority;
775 // T.path = remove_dot_segments(R.path);
776 // T.query = R.query;
777 if (HasServer())
778 {
779 return;
780 }
781
782 //No authority - inherit
783 if (base.HasUserInfo())
784 {
785 m_userinfo = base.m_userinfo;
786 m_fields |= wxURI_USERINFO;
787 }
788
789 m_server = base.m_server;
790 m_hostType = base.m_hostType;
791 m_fields |= wxURI_SERVER;
792
793 if (base.HasPort())
794 {
795 m_port = base.m_port;
796 m_fields |= wxURI_PORT;
797 }
798
799
800 // Simple path inheritance from base
801 if (!HasPath())
802 {
803 // T.path = Base.path;
804 m_path = base.m_path;
805 m_fields |= wxURI_PATH;
806
807
808 // if defined(R.query) then
809 // T.query = R.query;
810 // else
811 // T.query = Base.query;
812 // endif;
813 if (!HasQuery())
814 {
815 m_query = base.m_query;
816 m_fields |= wxURI_QUERY;
817 }
818 }
819 else
820 {
821 // if (R.path starts-with "/") then
822 // T.path = remove_dot_segments(R.path);
823 // else
824 // T.path = merge(Base.path, R.path);
825 // T.path = remove_dot_segments(T.path);
826 // endif;
827 // T.query = R.query;
828 if (m_path[0u] != wxT('/'))
829 {
830 //Merge paths
831 const wxChar* op = m_path.c_str();
832 const wxChar* bp = base.m_path.c_str() + base.m_path.Length();
833
834 //not a ending directory? move up
835 if (base.m_path[0] && *(bp-1) != wxT('/'))
836 UpTree(base.m_path, bp);
837
838 //normalize directories
839 while(*op == wxT('.') && *(op+1) == wxT('.') &&
840 (*(op+2) == '\0' || *(op+2) == wxT('/')) )
841 {
842 UpTree(base.m_path, bp);
843
844 if (*(op+2) == '\0')
845 op += 2;
846 else
847 op += 3;
848 }
849
850 m_path = base.m_path.substr(0, bp - base.m_path.c_str()) +
851 m_path.substr((op - m_path.c_str()), m_path.Length());
852 }
853 }
854
855 //T.fragment = R.fragment;
856 }
857
858 // ---------------------------------------------------------------------------
859 // UpTree
860 //
861 // Moves a URI path up a directory
862 // ---------------------------------------------------------------------------
863
864 //static
865 void wxURI::UpTree(const wxChar* uristart, const wxChar*& uri)
866 {
867 if (uri != uristart && *(uri-1) == wxT('/'))
868 {
869 uri -= 2;
870 }
871
872 for(;uri != uristart; --uri)
873 {
874 if (*uri == wxT('/'))
875 {
876 ++uri;
877 break;
878 }
879 }
880
881 //!!!TODO:HACK!!!//
882 if (uri == uristart && *uri == wxT('/'))
883 ++uri;
884 //!!!//
885 }
886
887 // ---------------------------------------------------------------------------
888 // Normalize
889 //
890 // Normalizes directories in-place
891 //
892 // I.E. ./ and . are ignored
893 //
894 // ../ and .. are removed if a directory is before it, along
895 // with that directory (leading .. and ../ are kept)
896 // ---------------------------------------------------------------------------
897
898 //static
899 void wxURI::Normalize(wxChar* s, bool bIgnoreLeads)
900 {
901 wxChar* cp = s;
902 wxChar* bp = s;
903
904 if(s[0] == wxT('/'))
905 ++bp;
906
907 while(*cp)
908 {
909 if (*cp == wxT('.') && (*(cp+1) == wxT('/') || *(cp+1) == '\0')
910 && (bp == cp || *(cp-1) == wxT('/')))
911 {
912 //. _or_ ./ - ignore
913 if (*(cp+1) == '\0')
914 cp += 1;
915 else
916 cp += 2;
917 }
918 else if (*cp == wxT('.') && *(cp+1) == wxT('.') &&
919 (*(cp+2) == wxT('/') || *(cp+2) == '\0')
920 && (bp == cp || *(cp-1) == wxT('/')))
921 {
922 //.. _or_ ../ - go up the tree
923 if (s != bp)
924 {
925 UpTree((const wxChar*)bp, (const wxChar*&)s);
926
927 if (*(cp+2) == '\0')
928 cp += 2;
929 else
930 cp += 3;
931 }
932 else if (!bIgnoreLeads)
933
934 {
935 *bp++ = *cp++;
936 *bp++ = *cp++;
937 if (*cp)
938 *bp++ = *cp++;
939
940 s = bp;
941 }
942 else
943 {
944 if (*(cp+2) == '\0')
945 cp += 2;
946 else
947 cp += 3;
948 }
949 }
950 else
951 *s++ = *cp++;
952 }
953
954 *s = '\0';
955 }
956
957 // ---------------------------------------------------------------------------
958 // ParseH16
959 //
960 // Parses 1 to 4 hex values. Returns true if the first character of the input
961 // string is a valid hex character. It is the caller's responsability to move
962 // the input string back to its original position on failure.
963 // ---------------------------------------------------------------------------
964
965 bool wxURI::ParseH16(const wxChar*& uri)
966 {
967 // h16 = 1*4HEXDIG
968 if(!IsHex(*++uri))
969 return false;
970
971 if(IsHex(*++uri) && IsHex(*++uri) && IsHex(*++uri))
972 ++uri;
973
974 return true;
975 }
976
977 // ---------------------------------------------------------------------------
978 // ParseIPXXX
979 //
980 // Parses a certain version of an IP address and moves the input string past
981 // it. Returns true if the input string contains the proper version of an ip
982 // address. It is the caller's responsability to move the input string back
983 // to its original position on failure.
984 // ---------------------------------------------------------------------------
985
986 bool wxURI::ParseIPv4address(const wxChar*& uri)
987 {
988 //IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
989 //
990 //dec-octet = DIGIT ; 0-9
991 // / %x31-39 DIGIT ; 10-99
992 // / "1" 2DIGIT ; 100-199
993 // / "2" %x30-34 DIGIT ; 200-249
994 // / "25" %x30-35 ; 250-255
995 size_t iIPv4 = 0;
996 if (IsDigit(*uri))
997 {
998 ++iIPv4;
999
1000
1001 //each ip part must be between 0-255 (dupe of version in for loop)
1002 if( IsDigit(*++uri) && IsDigit(*++uri) &&
1003 //100 or less (note !)
1004 !( (*(uri-2) < wxT('2')) ||
1005 //240 or less
1006 (*(uri-2) == wxT('2') &&
1007 (*(uri-1) < wxT('5') || (*(uri-1) == wxT('5') && *uri <= wxT('5')))
1008 )
1009 )
1010 )
1011 {
1012 return false;
1013 }
1014
1015 if(IsDigit(*uri))++uri;
1016
1017 //compilers should unroll this loop
1018 for(; iIPv4 < 4; ++iIPv4)
1019 {
1020 if (*uri != wxT('.') || !IsDigit(*++uri))
1021 break;
1022
1023 //each ip part must be between 0-255
1024 if( IsDigit(*++uri) && IsDigit(*++uri) &&
1025 //100 or less (note !)
1026 !( (*(uri-2) < wxT('2')) ||
1027 //240 or less
1028 (*(uri-2) == wxT('2') &&
1029 (*(uri-1) < wxT('5') || (*(uri-1) == wxT('5') && *uri <= wxT('5')))
1030 )
1031 )
1032 )
1033 {
1034 return false;
1035 }
1036 if(IsDigit(*uri))++uri;
1037 }
1038 }
1039 return iIPv4 == 4;
1040 }
1041
1042 bool wxURI::ParseIPv6address(const wxChar*& uri)
1043 {
1044 // IPv6address = 6( h16 ":" ) ls32
1045 // / "::" 5( h16 ":" ) ls32
1046 // / [ h16 ] "::" 4( h16 ":" ) ls32
1047 // / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
1048 // / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
1049 // / [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32
1050 // / [ *4( h16 ":" ) h16 ] "::" ls32
1051 // / [ *5( h16 ":" ) h16 ] "::" h16
1052 // / [ *6( h16 ":" ) h16 ] "::"
1053
1054 size_t numPrefix = 0,
1055 maxPostfix;
1056
1057 bool bEndHex = false;
1058
1059 for( ; numPrefix < 6; ++numPrefix)
1060 {
1061 if(!ParseH16(uri))
1062 {
1063 --uri;
1064 bEndHex = true;
1065 break;
1066 }
1067
1068 if(*uri != wxT(':'))
1069 {
1070 break;
1071 }
1072 }
1073
1074 if(!bEndHex && !ParseH16(uri))
1075 {
1076 --uri;
1077
1078 if (numPrefix)
1079 return false;
1080
1081 if (*uri == wxT(':'))
1082 {
1083 if (*++uri != wxT(':'))
1084 return false;
1085
1086 maxPostfix = 5;
1087 }
1088 else
1089 maxPostfix = 6;
1090 }
1091 else
1092 {
1093 if (*uri != wxT(':') || *(uri+1) != wxT(':'))
1094 {
1095 if (numPrefix != 6)
1096 return false;
1097
1098 while (*--uri != wxT(':')) {}
1099 ++uri;
1100
1101 const wxChar* uristart = uri;
1102 //parse ls32
1103 // ls32 = ( h16 ":" h16 ) / IPv4address
1104 if (ParseH16(uri) && *uri == wxT(':') && ParseH16(uri))
1105 return true;
1106
1107 uri = uristart;
1108
1109 if (ParseIPv4address(uri))
1110 return true;
1111 else
1112 return false;
1113 }
1114 else
1115 {
1116 uri += 2;
1117
1118 if (numPrefix > 3)
1119 maxPostfix = 0;
1120 else
1121 maxPostfix = 4 - numPrefix;
1122 }
1123 }
1124
1125 bool bAllowAltEnding = maxPostfix == 0;
1126
1127 for(; maxPostfix != 0; --maxPostfix)
1128 {
1129 if(!ParseH16(uri) || *uri != wxT(':'))
1130 return false;
1131 }
1132
1133 if(numPrefix <= 4)
1134 {
1135 const wxChar* uristart = uri;
1136 //parse ls32
1137 // ls32 = ( h16 ":" h16 ) / IPv4address
1138 if (ParseH16(uri) && *uri == wxT(':') && ParseH16(uri))
1139 return true;
1140
1141 uri = uristart;
1142
1143 if (ParseIPv4address(uri))
1144 return true;
1145
1146 uri = uristart;
1147
1148 if (!bAllowAltEnding)
1149 return false;
1150 }
1151
1152 if(numPrefix <= 5 && ParseH16(uri))
1153 return true;
1154
1155 return true;
1156 }
1157
1158 bool wxURI::ParseIPvFuture(const wxChar*& uri)
1159 {
1160 // IPvFuture = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
1161 if (*++uri != wxT('v') || !IsHex(*++uri))
1162 return false;
1163
1164 while (IsHex(*++uri)) {}
1165
1166 if (*uri != wxT('.') || !(IsUnreserved(*++uri) || IsSubDelim(*uri) || *uri == wxT(':')))
1167 return false;
1168
1169 while(IsUnreserved(*++uri) || IsSubDelim(*uri) || *uri == wxT(':')) {}
1170
1171 return true;
1172 }
1173
1174
1175 // ---------------------------------------------------------------------------
1176 // CharToHex
1177 //
1178 // Converts a character into a numeric hexidecimal value, or 0 if the
1179 // passed in character is not a valid hex character
1180 // ---------------------------------------------------------------------------
1181
1182 //static
1183 wxChar wxURI::CharToHex(const wxChar& c)
1184 {
1185 if ((c >= wxT('A')) && (c <= wxT('Z'))) return wxChar(c - wxT('A') + 0x0A);
1186 if ((c >= wxT('a')) && (c <= wxT('z'))) return wxChar(c - wxT('a') + 0x0a);
1187 if ((c >= wxT('0')) && (c <= wxT('9'))) return wxChar(c - wxT('0') + 0x00);
1188
1189 return 0;
1190 }
1191
1192 // ---------------------------------------------------------------------------
1193 // IsXXX
1194 //
1195 // Returns true if the passed in character meets the criteria of the method
1196 // ---------------------------------------------------------------------------
1197
1198 //! unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
1199 bool wxURI::IsUnreserved (const wxChar& c)
1200 { return IsAlpha(c) || IsDigit(c) ||
1201 c == wxT('-') ||
1202 c == wxT('.') ||
1203 c == wxT('_') ||
1204 c == wxT('~') //tilde
1205 ;
1206 }
1207
1208 bool wxURI::IsReserved (const wxChar& c)
1209 {
1210 return IsGenDelim(c) || IsSubDelim(c);
1211 }
1212
1213 //! gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
1214 bool wxURI::IsGenDelim (const wxChar& c)
1215 {
1216 return c == wxT(':') ||
1217 c == wxT('/') ||
1218 c == wxT('?') ||
1219 c == wxT('#') ||
1220 c == wxT('[') ||
1221 c == wxT(']') ||
1222 c == wxT('@');
1223 }
1224
1225 //! sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
1226 //! / "*" / "+" / "," / ";" / "="
1227 bool wxURI::IsSubDelim (const wxChar& c)
1228 {
1229 return c == wxT('!') ||
1230 c == wxT('$') ||
1231 c == wxT('&') ||
1232 c == wxT('\'') ||
1233 c == wxT('(') ||
1234 c == wxT(')') ||
1235 c == wxT('*') ||
1236 c == wxT('+') ||
1237 c == wxT(',') ||
1238 c == wxT(';') ||
1239 c == wxT('=')
1240 ;
1241 }
1242
1243 bool wxURI::IsHex(const wxChar& c)
1244 { return IsDigit(c) || (c >= wxT('a') && c <= wxT('f')) || (c >= wxT('A') && c <= wxT('F')); }
1245
1246 bool wxURI::IsAlpha(const wxChar& c)
1247 { return (c >= wxT('a') && c <= wxT('z')) || (c >= wxT('A') && c <= wxT('Z')); }
1248
1249 bool wxURI::IsDigit(const wxChar& c)
1250 { return c >= wxT('0') && c <= wxT('9'); }
1251
1252
1253 // ---------------------------------------------------------------------------
1254 //
1255 // wxURL Compatibility
1256 //
1257 // ---------------------------------------------------------------------------
1258
1259 #if wxUSE_URL
1260
1261 #if WXWIN_COMPATIBILITY_2_4
1262
1263 #include "wx/url.h"
1264
1265 wxString wxURL::GetProtocolName() const
1266 {
1267 return m_scheme;
1268 }
1269
1270 wxString wxURL::GetHostName() const
1271 {
1272 return m_server;
1273 }
1274
1275 wxString wxURL::GetPath() const
1276 {
1277 return m_path;
1278 }
1279
1280 //Note that this old code really doesn't convert to a URI that well and looks
1281 //more like a dirty hack than anything else...
1282
1283 wxString wxURL::ConvertToValidURI(const wxString& uri, const wxChar* delims)
1284 {
1285 wxString out_str;
1286 wxString hexa_code;
1287 size_t i;
1288
1289 for (i = 0; i < uri.Len(); i++)
1290 {
1291 wxChar c = uri.GetChar(i);
1292
1293 if (c == wxT(' '))
1294 {
1295 // GRG, Apr/2000: changed to "%20" instead of '+'
1296
1297 out_str += wxT("%20");
1298 }
1299 else
1300 {
1301 // GRG, Apr/2000: modified according to the URI definition (RFC 2396)
1302 //
1303 // - Alphanumeric characters are never escaped
1304 // - Unreserved marks are never escaped
1305 // - Delimiters must be escaped if they appear within a component
1306 // but not if they are used to separate components. Here we have
1307 // no clear way to distinguish between these two cases, so they
1308 // are escaped unless they are passed in the 'delims' parameter
1309 // (allowed delimiters).
1310
1311 static const wxChar marks[] = wxT("-_.!~*()'");
1312
1313 if ( !wxIsalnum(c) && !wxStrchr(marks, c) && !wxStrchr(delims, c) )
1314 {
1315 hexa_code.Printf(wxT("%%%02X"), c);
1316 out_str += hexa_code;
1317 }
1318 else
1319 {
1320 out_str += c;
1321 }
1322 }
1323 }
1324
1325 return out_str;
1326 }
1327
1328 wxString wxURL::ConvertFromURI(const wxString& uri)
1329 {
1330 return wxURI::Unescape(uri);
1331 }
1332
1333 #endif //WXWIN_COMPATIBILITY_2_4
1334
1335 #endif //wxUSE_URL
1336
1337 //end of uri.cpp
1338
1339
1340
wxWidgets (Impactor)