0024275: Cppcheck warnings on uninitialized class members
[occt.git] / src / OSD / OSD_Path.cxx
1 // Copyright (c) 1998-1999 Matra Datavision
2 // Copyright (c) 1999-2012 OPEN CASCADE SAS
3 //
4 // The content of this file is subject to the Open CASCADE Technology Public
5 // License Version 6.5 (the "License"). You may not use the content of this file
6 // except in compliance with the License. Please obtain a copy of the License
7 // at http://www.opencascade.org and read it completely before using this file.
8 //
9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
11 //
12 // The Original Code and all software distributed under the License is
13 // distributed on an "AS IS" basis, without warranty of any kind, and the
14 // Initial Developer hereby disclaims all such warranties, including without
15 // limitation, any warranties of merchantability, fitness for a particular
16 // purpose or non-infringement. Please see the License for the specific terms
17 // and conditions governing the rights and limitations under the License.
18
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #ifndef WNT
24
25 #include <Standard_NumericError.hxx>
26 #include <Standard_NullObject.hxx>
27 #include <Standard_ProgramError.hxx>
28 #include <Standard_ConstructionError.hxx>
29 #include <OSD_Path.ixx>
30 #include <OSD_WhoAmI.hxx>
31
32 #ifdef HAVE_SYS_UTSNAME_H
33 //# include <sys/utsname.h>
34 #endif
35
36 static OSD_SysType whereAmI(){
37 #if defined(__digital__) || defined(__FreeBSD__) || defined(SUNOS) || defined(__APPLE__)
38   return OSD_UnixBSD;
39 }
40 #elif defined(sgi)  || defined(IRIX) || defined(__sun)  || defined(SOLARIS) ||  defined(__sco__) || defined(__hpux) || defined(HPUX)
41   return OSD_UnixSystemV;
42 }
43 #elif defined(__osf__) || defined(DECOSF1)
44   return OSD_OSF;
45 }
46 #elif defined(OS2)
47   return OSD_WindowsNT;
48 }
49 #elif defined(WIN32)
50   return OSD_WindowsNT;
51 }
52 #elif defined(__CYGWIN32_) || defined(__MINGW32__)
53   return OSD_WindowsNT;
54 }
55 #elif defined(vax) || defined(__vms)
56   return OSD_VMS;
57 }
58 #elif defined(__linux__) || defined(LIN)
59   return OSD_LinuxREDHAT;
60 }
61 #elif defined(_AIX) || defined(AIX)
62   return OSD_Aix;
63 }
64 #else
65   struct utsname info;
66   uname(&info);
67   cout << info.sysname << endl;
68   cout << info.nodename << endl;
69   cout << info.release << endl;
70   cout << info.version << endl;
71   cout << info.machine << endl;
72   return OSD_Default;
73 }
74 #endif
75
76
77
78 OSD_Path::OSD_Path(){
79  SysDep = whereAmI();
80 }
81
82 static void VmsExtract(const TCollection_AsciiString& what,
83                 TCollection_AsciiString& node,
84                 TCollection_AsciiString& username,
85                 TCollection_AsciiString& password,
86                 TCollection_AsciiString& disk,
87                 TCollection_AsciiString& trek,
88                 TCollection_AsciiString& name,
89                 TCollection_AsciiString& ext){
90
91  TCollection_AsciiString buffer;
92  Standard_Integer pos;
93
94  buffer = what;
95
96  if (buffer.Search("\"") != -1){  // a username to extract
97
98    if (buffer.Value(1) != '"') { // Begins with Node
99     node = buffer.Token("\"");
100     buffer.Remove(1,node.Length());
101    }
102    else node = "";
103
104    username = buffer.Token("\" ");
105    buffer.Remove(1,username.Length()+2); // Removes <<"username ' ' or '"' >>
106
107    if (buffer.Search("\"") != -1){ // a password to extract
108     password = buffer.Token("\"");
109     buffer.Remove(1,password.Length()+1);  // removes <<password">>
110    }
111
112    // If we found a node then we must find "::"
113    if (buffer.Search("::") != -1)
114     buffer.Remove(1,2);            // Removes <<::>>
115  }
116  else  // No name or password
117  if (buffer.Search("::") != -1){ // a node to extract
118   node = buffer.Token(":");
119   buffer.Remove(1,node.Length()+2); // Removes <<node::>
120  }
121
122  if (buffer.Search(":") != -1){ // a disk to extract
123    disk = buffer.Token(":");
124    buffer.Remove(1,disk.Length()+1);  // Removes <<disk:>>
125  }
126  else disk = "";
127
128  // Analyse trek
129
130  if (buffer.Search("[") != -1){  // There is atrek to extract
131   trek = buffer.Token("[]");
132
133   if (trek.Value(1) == '.') trek.Remove(1,1);  // Removes first '.'
134     else trek.Insert(1,'|');                   // Add root
135
136   trek.ChangeAll('.','|');   // Translates to portable syntax
137   trek.ChangeAll('-','^');  
138
139   pos = trek.Search("000000");
140   if (pos != -1) {
141    trek.Remove(pos,6); // on VMS [000000] is the root
142    if (trek.Search("||") != -1) trek.Remove(1,1); // When [000000.xxx] -> ||xxx
143   }
144
145   name = buffer.Token("]",2);
146  }
147  else name = buffer;
148
149  if (name.Search(".") != -1){
150   ext = name.Token(".",2);
151   ext.Insert(1,'.');
152   name.Remove(name.Search("."),ext.Length());
153  }
154  else ext = "";
155   
156 }
157
158
159 //=======================================================================
160 //function : UnixExtract
161 //purpose  : 
162 //=======================================================================
163 static void UnixExtract(const TCollection_AsciiString& what,
164                         TCollection_AsciiString& node,
165                         TCollection_AsciiString& username,
166                         TCollection_AsciiString& password,
167                         TCollection_AsciiString& trek,
168                         TCollection_AsciiString& name,
169                         TCollection_AsciiString& ext){
170
171  Standard_Integer pos;
172  TCollection_AsciiString buffer;   // To manipulate 'what' without modifying it
173
174  Standard_PCharacter p;
175  buffer = what;
176
177 #ifdef TOTO  // Username, password and node are no longer given in the string (LD)
178
179  if (buffer.Search("@") != -1){  // There is a name to extract
180   username = buffer.Token("\"@");
181   buffer.Remove(1,username.Length()+1);   // Removes << user@ >>
182
183   if (buffer.Search("\"") != -1){       // There is a password to extract
184    password = buffer.Token("\"");
185    buffer.Remove(1,password.Length()+2);  // Removes << "password" >>
186   }
187
188  }
189  else {
190   username = "";
191   password = "";
192  }
193
194 #endif  // node must be given (for DBT, DM) (ADN 29/8/96)
195
196  if (buffer.Search(":/") != -1){      // There is a node to extract
197   node = buffer.Token(":/");
198   buffer.Remove(1,node.Length()+1);  // Removes << node: >>
199  }
200  else node = ""; 
201
202   username = "";
203   password = "";
204 //  node = ""; 
205  
206  trek = buffer;
207
208  trek.ChangeAll('/','|');  // Translates to portable syntax
209
210  pos = trek.SearchFromEnd("|");  // Extract name
211  if (pos != -1) {
212   p = (Standard_PCharacter)trek.ToCString();
213   name = &p[pos];
214   if(name.Length()) trek.Remove(pos+1,name.Length());
215  }
216  else {   // No '|' means no trek but a name
217   name = buffer;
218   trek = "";
219  }
220
221  pos = trek.Search("..");
222  while (pos != -1){        // Changes every ".." by '^'
223   trek.SetValue(pos,'^');
224   trek.Remove(pos+1,1);
225   pos = trek.Search("..");
226  }
227
228   pos = name.SearchFromEnd(".") ;   // LD : debug
229   if (pos != -1)      // There is an extension to extract
230     ext = name.Split(pos - 1) ;  
231
232
233 // if (name.Search(".") != -1){ // There is an extension to extract
234 //   if ( name.Value(1) == '.' ) {
235 //     ext = name;
236 //     name.Clear();
237 //   }
238 //   else {
239 //     ext = name.Token(".",2); 
240 //     ext.Insert(1,'.');            // Prepends 'dot'
241 //     pos = name.Search(".");     // Removes extension from buffer
242 //     if (pos != -1)
243 //       name.Remove(pos,ext.Length());
244 //   }
245 // }
246
247 }
248
249
250 //=======================================================================
251 //function : DosExtract
252 //purpose  : 
253 //=======================================================================
254 static void DosExtract(const TCollection_AsciiString& what,
255                 TCollection_AsciiString& disk,
256                 TCollection_AsciiString& trek,
257                 TCollection_AsciiString& name,
258                 TCollection_AsciiString& ext){
259
260  TCollection_AsciiString buffer;
261  Standard_Integer pos;
262  Standard_PCharacter p;
263
264  buffer = what;
265
266  if (buffer.Search(":") != -1){ // There is a disk to extract
267   disk = buffer.Token(":");
268   disk += ":";
269   buffer.Remove(1,disk.Length());  // Removes <<disk:>>
270  }
271
272  if (buffer.Search(".") != -1){ // There is an extension to extract
273   ext = buffer.Token(".",2); 
274   ext.Insert(1,'.');            // Prepends 'dot'
275   pos = buffer.Search(".");     // Removes extension from buffer
276   if (pos != -1)
277    buffer.Remove(pos,ext.Length());
278  }
279
280  trek = buffer;
281
282  trek.ChangeAll('\\','|');  
283
284  pos = trek.Search("..");
285  while (pos != -1){        // Changes every ".." by '^'
286   trek.SetValue(pos,'^');
287   trek.Remove(pos+1,1);
288   pos = trek.Search("..");
289  }
290
291  pos = trek.SearchFromEnd("|");  // Extract name
292  if (pos != -1) {
293   p = (Standard_PCharacter)trek.ToCString();
294   name = &p[pos];
295   trek.Remove(trek.Search(name),name.Length());
296  }
297  else {   // No '|' means no trek but a name
298   name = buffer;
299   trek = "";
300  }
301 }
302
303
304 //=======================================================================
305 //function : MacExtract
306 //purpose  : 
307 //=======================================================================
308 static void MacExtract(const TCollection_AsciiString& what,
309                 TCollection_AsciiString& ,
310                 TCollection_AsciiString& trek,
311                 TCollection_AsciiString& name,
312                 TCollection_AsciiString& ){
313
314   Standard_Integer pos;
315   Standard_PCharacter p;
316   
317   // I don't know how to distingish a disk from a trek !
318   
319   trek = what;
320   
321   pos = trek.Search("::");
322   while (pos != -1){        // Changes every "::" by '^'
323     trek.SetValue(pos,'^');
324     trek.Remove(pos+1,1);
325     pos = trek.Search("::");
326   }
327
328   trek.ChangeAll(':','|');  // Translates to portable syntax
329
330   pos = trek.SearchFromEnd("|");  // Extract name
331   if (pos != -1) {
332     p = (Standard_PCharacter)trek.ToCString();
333     name = &p[pos+1];
334     trek.Remove(trek.Search(name),name.Length());
335   }
336   else {   // No '|' means no trek but a name
337     name = what;
338     trek = "";
339   }
340 }
341
342
343 OSD_Path::OSD_Path(const TCollection_AsciiString& aDependentName,
344                    const OSD_SysType aSysType){
345
346  SysDep = whereAmI();
347
348  if (!IsValid(aDependentName,aSysType))
349   Standard_ProgramError::Raise("OSD_Path::OSD_Path : Invalid dependent name");
350
351  OSD_SysType todo;
352 //  Standard_Integer i,l;
353
354   if (aSysType == OSD_Default) {
355     todo = SysDep;
356   } else {
357     todo = aSysType;
358   }
359
360  switch (todo){
361   case OSD_VMS:
362      VmsExtract(aDependentName,myNode,myUserName,myPassword,myDisk,myTrek,myName,myExtension);
363      break;
364   case OSD_LinuxREDHAT:
365   case OSD_UnixBSD:
366   case OSD_UnixSystemV:
367   case OSD_Aix:
368   case OSD_OSF:
369      UnixExtract(aDependentName,myNode,myUserName,myPassword,myTrek,myName,myExtension);
370      break;
371   case OSD_OS2:
372   case OSD_WindowsNT:
373      DosExtract(aDependentName,myDisk,myTrek,myName,myExtension);
374      break;
375   case OSD_MacOs:
376      MacExtract(aDependentName,myDisk,myTrek,myName,myExtension);
377      break;
378   default:
379 #ifdef DEB
380        cout << " WARNING WARNING : OSD Path for an Unknown SYSTEM : " << (Standard_Integer)todo << endl;
381 #endif 
382      break ;
383  } 
384 }
385
386
387
388 OSD_Path::OSD_Path(const TCollection_AsciiString& Nod,
389                    const TCollection_AsciiString& UsrNm,
390                    const TCollection_AsciiString& Passwd,
391                    const TCollection_AsciiString& Dsk,
392                    const TCollection_AsciiString& Trk,
393                    const TCollection_AsciiString& Nam,
394                    const TCollection_AsciiString& ext){
395
396  SysDep = whereAmI();
397
398  SetValues ( Nod, UsrNm, Passwd, Dsk, Trk, Nam, ext);
399
400
401 }
402
403
404 void OSD_Path::Values(TCollection_AsciiString& Nod, 
405                       TCollection_AsciiString& UsrNm, 
406                       TCollection_AsciiString& Passwd, 
407                       TCollection_AsciiString& Dsk, 
408                       TCollection_AsciiString& Trk,
409                       TCollection_AsciiString& Nam,
410                       TCollection_AsciiString& ext)const{
411
412  Nod = myNode;
413  UsrNm = myUserName;
414  Passwd = myPassword;
415  Dsk = myDisk;
416  Trk = myTrek;
417  Nam = myName;
418  ext = myExtension;
419 }
420
421
422 void OSD_Path::SetValues(const TCollection_AsciiString& Nod, 
423                          const TCollection_AsciiString& UsrNm, 
424                          const TCollection_AsciiString& Passwd,
425                          const TCollection_AsciiString& Dsk,
426                          const TCollection_AsciiString& Trk,
427                          const TCollection_AsciiString& Nam,
428                          const TCollection_AsciiString& ext){
429
430  if (!Nod.IsAscii())
431   Standard_ConstructionError::Raise("OSD_Path::SetValues argument : Node");
432  if (!UsrNm.IsAscii())
433   Standard_ConstructionError::Raise("OSD_Path::SetValues argument : User Name");
434  if (!Dsk.IsAscii())
435   Standard_ConstructionError::Raise("OSD_Path::SetValues argument : Disk");
436  if (!Trk.IsAscii())
437   Standard_ConstructionError::Raise("OSD_Path::SetValues argument : Trek");
438  if (!Nam.IsAscii())
439   Standard_ConstructionError::Raise("OSD_Path::SetValues argument : Name");
440  if (!ext.IsAscii())
441   Standard_ConstructionError::Raise("OSD_Path::SetValues argument : Extension");
442
443  myNode = Nod;
444  myUserName = UsrNm;
445  myPassword = Passwd;
446  myDisk = Dsk;
447  myTrek = Trk;
448  myName = Nam;
449  myExtension = ext;
450 }
451
452
453 static Standard_Boolean Analyse_VMS(const TCollection_AsciiString& name){
454  if (name.Search("/") != -1)
455   return(Standard_False);
456  if (name.Search("@") != -1)
457   return(Standard_False);
458  if (name.Search("\\") != -1)
459   return(Standard_False);
460
461
462  return Standard_True;
463 }
464
465 static Standard_Boolean Analyse_DOS(const TCollection_AsciiString& name){
466
467 // if (name.Search("$") != -1)
468 //  return(Standard_False);
469 // if (name.Search(" ") != -1)
470 //  return(Standard_False);
471
472  if (name.Search("/") != -1)
473   return(Standard_False);
474  if (name.Search(":") != -1)
475   return(Standard_False);
476   if (name.Search("*") != -1)
477   return(Standard_False);
478  if (name.Search("?") != -1)
479   return(Standard_False);
480  if (name.Search(".") != name.SearchFromEnd("."))
481   return(Standard_False);
482  if (name.Search("\"") != -1)
483   return(Standard_False);
484  if (name.Search("<") != -1)
485   return(Standard_False);
486  if (name.Search(">") != -1)
487   return(Standard_False);
488  if (name.Search("|") != -1)
489   return(Standard_False);
490    
491  return Standard_True;
492  // Rajouter les tests sur les noms de 8 caracteres au maximum et
493  // l'extension de 3 caracteres.
494 }
495
496 static Standard_Boolean Analyse_MACOS(const TCollection_AsciiString& name){
497  Standard_Integer i = name.Search(":");
498  Standard_Integer l = name.Length();
499
500  if (i == -1)
501   if (l > 31)
502     return(Standard_False);
503   else 
504     return(Standard_True);
505  else
506    return(Standard_True);
507 }
508
509 static Standard_Boolean Analyse_UNIX(const TCollection_AsciiString& /*name*/)
510 {
511 // if (name.Search("$") != -1)  Unix filename can have a "$" (LD)
512 //  return(Standard_False);
513
514 // all characters are allowed in UNIX file name, except null '\0' and slash '/'
515
516 // if (name.Search("[") != -1)
517 //  return(Standard_False);
518 // if (name.Search("]") != -1)
519 //  return(Standard_False);
520 // if (name.Search("\\") != -1)
521 //  return(Standard_False);
522 // if (name.Search(" ") != -1) 
523 //  return(Standard_False);
524
525   return(Standard_True);
526
527 }
528
529
530
531
532
533 Standard_Boolean OSD_Path::IsValid(const TCollection_AsciiString& aDependentName,
534                                    const OSD_SysType aSysType)const{
535  if (aDependentName.Length()==0) return(Standard_True);
536  if (!aDependentName.IsAscii()) return(Standard_False);
537
538  OSD_SysType provSys;
539  if (aSysType == OSD_Default) provSys = SysDep;
540                       else provSys = aSysType; 
541
542  switch (provSys){
543   case OSD_VMS:
544             return(Analyse_VMS(aDependentName));
545   case OSD_OS2:
546   case OSD_WindowsNT:
547             return(Analyse_DOS(aDependentName));
548   case OSD_MacOs:
549             return(Analyse_MACOS(aDependentName));
550   default:
551             return(Analyse_UNIX(aDependentName));
552
553  }
554 }
555
556
557 void OSD_Path::UpTrek(){
558  Standard_Integer length=TrekLength();
559
560  if (length == 0) return;
561
562  Standard_Integer awhere,aHowmany;
563  TCollection_AsciiString tok;
564
565  tok = myTrek.Token("|",length);
566  awhere = myTrek.SearchFromEnd(tok);
567  aHowmany = tok.Length();
568  myTrek.Remove(awhere,aHowmany);
569
570  awhere = myTrek.Search("||");   // Searches leaving "||"
571  if (awhere != -1)
572   myTrek.Remove(awhere);
573 }
574
575
576 void OSD_Path::DownTrek(const TCollection_AsciiString& aName){
577  myTrek += aName;
578 // Pb signale par GG : pour ne pas avoir "||" ;
579  if ( aName.ToCString()[ aName.Length() - 1 ] != '|' )
580    myTrek += "|";
581 }
582
583
584 Standard_Integer OSD_Path::TrekLength()const{
585  Standard_Integer cpt=0;
586
587  while (myTrek.Token("|",cpt+1) != "")  // Counts token separated by '|'
588   cpt++;
589
590  return(cpt);
591 }
592
593
594 void OSD_Path::RemoveATrek(const Standard_Integer thewhere){
595  Standard_Integer length=TrekLength();
596
597  if (length <= 0 || thewhere > length)
598   Standard_NumericError::Raise("OSD_Path::RemoveATrek : where has an invalid value");
599
600  Standard_Integer posit,aHowmany;
601  TCollection_AsciiString tok;
602
603  tok = myTrek.Token("|",thewhere);
604  posit = myTrek.Search(tok);
605  aHowmany = tok.Length();
606  myTrek.Remove(posit,aHowmany);
607
608  posit = myTrek.Search("||");   // Searches leaving "||"
609  if (posit != -1)
610   myTrek.Remove(posit);
611 }
612
613
614 void OSD_Path::RemoveATrek(const TCollection_AsciiString& aName){
615  Standard_Integer length=TrekLength();
616
617  if (length == 0) return;
618
619  Standard_Integer awhere;
620
621  awhere = myTrek.Search(aName);
622  if (awhere != -1){
623   myTrek.Remove(awhere,aName.Length());
624
625   awhere = myTrek.Search("||");   // Searches leaving "||"
626   if (awhere != -1)
627    myTrek.Remove(awhere); 
628  } 
629 }
630
631
632 TCollection_AsciiString OSD_Path::TrekValue(const Standard_Integer thewhere)const{
633  TCollection_AsciiString result=myTrek.Token("|",thewhere);
634
635  if (result == "")
636   Standard_NumericError::Raise("OSD_Path::TrekValue : where is invalid");
637
638  return(result);
639 }
640
641 void OSD_Path::InsertATrek(const TCollection_AsciiString& aName,
642                            const Standard_Integer thewhere){
643  Standard_Integer length=TrekLength();
644
645  if (thewhere <= 0 || thewhere > length)
646   Standard_NumericError::Raise("OSD_Path::InsertATrek : where has an invalid value");
647
648  TCollection_AsciiString tok=myTrek.Token("|",thewhere);
649  Standard_Integer wwhere = myTrek.Search(tok);
650  TCollection_AsciiString what = aName;
651  what += "|";
652
653  myTrek.Insert(wwhere,what);
654 }
655
656
657 // The 4 following methods will be PUBLIC in the future
658
659 // Converts a VMS disk to other system syntax
660
661 static void VMSDisk2Other(TCollection_AsciiString & Disk){
662  Disk.RemoveAll('$');
663 }
664
665
666 // Convert a Trek to VMS syntax
667
668 static void P2VMS (TCollection_AsciiString & Way){
669  Standard_Integer length = Way.Length();
670
671  if (length == 0) return;
672
673  if (Way.Value(1) == '|')             // If begin with '|' remove '|'
674   if (Way.Value(1) != '\0')
675    Way.Remove(1,1);
676   else Way = "000000";             // Si uniquement la racine -> [000000]
677  else
678   if (Way.Length()!=0)
679    Way.Insert(1,'|');          // Else insert '|' at beginning if not empty;
680
681  Way.ChangeAll('|','.');
682  Way.ChangeAll('^','-');
683
684 }
685
686 // Convert a Trek to MAC syntax
687
688 static void P2MAC (TCollection_AsciiString & Way){
689  int i,l;
690  Way.ChangeAll('|',':');
691
692  l = (int)Way.Length();
693  for (i=1; i <= l; i++)             // Replace '^' by "::"
694   if (Way.Value(i) == '^'){
695    Way.SetValue(i,':');
696    Way.Insert(i,':');
697    i++; l++;
698   } 
699 }
700
701
702 // Convert a Trek to UNIX syntax
703
704 static void P2UNIX (TCollection_AsciiString & Way){
705  int i,l;
706  Standard_Integer length = Way.Length();
707
708  if (length == 0) return;
709
710  // if (Way.Value(length) == '|') // If Finishes with "|" removes it
711  // Way.Trunc(length-1);
712
713  Way.ChangeAll('|','/');
714  
715  l = (int)Way.Length();
716  for (i=1; i <= l; i++)             // Replace '^' by "../"
717   if (Way.Value(i) == '^'){
718    Way.SetValue(i,'.');
719    Way.Insert(i+1,'.');
720    //Way.Insert(i+2,'/');
721    i +=1; l +=1;
722   } 
723 }
724
725
726 // Convert a Trek to DOS like syntax
727
728 static void P2DOS (TCollection_AsciiString & Way){
729  int i,l;
730  Standard_Integer len = Way.Length();
731
732  if (len == 0) return;
733
734  if (Way.Value(len) == '|')   // If Finishes with "|" removes it
735   Way.Trunc(len-1);
736
737  Way.ChangeAll('|','\\');
738  
739  l = (int)Way.Length();
740  for (i=1; i <= l; i++)             // Replace '^' by ".."
741   if (Way.Value(i) == '^'){
742    Way.SetValue(i,'.');
743    Way.Insert(i,'.');
744    i++; l++;
745   } 
746
747 }
748
749
750
751
752 // Convert a path to system dependant syntax
753
754 void OSD_Path::SystemName (TCollection_AsciiString& FullName,
755                            const OSD_SysType aType)const{
756 TCollection_AsciiString Way;
757 TCollection_AsciiString pNode;
758 TCollection_AsciiString pDisk;
759 OSD_SysType pType;
760
761  if (aType == OSD_Default) {
762    pType = SysDep;
763  } else {
764    pType = aType;
765  }
766
767  Way = myTrek;
768  FullName.Clear();
769
770  switch (pType){
771   case OSD_VMS :
772    pNode = myNode;
773
774    P2VMS (Way);    // Convert path
775
776    if (myNode.Length()!=0) FullName += myNode;      // Append Node
777
778    if (myUserName.Length()!=0){   // Append User name
779
780     if (pNode.Length()==0) {    // If a user name but no node, catenate "0"
781      pNode = "0";
782      FullName += pNode;
783     }
784
785
786     FullName += "\"";
787     FullName += myUserName;
788
789     if (myPassword.Length()!=0){  // Append password
790      FullName += " ";
791      FullName += myPassword;
792     }
793
794     FullName += "\"";
795    }
796
797    if (pNode.Length()!=0) FullName += "::";
798
799    if (myDisk.Length()!=0){       // Append Disk
800     FullName += myDisk;
801     FullName += ":";
802    }
803     
804
805    if (Way.Length()!=0)         // Append VMS path
806     FullName = FullName + "[" + Way + "]" + myName + myExtension;
807
808 //   FullName.UpperCase();
809    break;
810
811
812    case OSD_OS2 :
813    case OSD_WindowsNT :            // MSDOS-like syntax
814     {
815     int length = (int)myDisk.Length();
816
817     P2DOS (Way);
818     if (length != 1)
819
820     if (myDisk.Length()!=0){
821
822      if (
823          (length == 1 && IsAlphabetic(myDisk.Value(1))) ||     // 'A/a' to 'Z/z'
824          (length == 2 &&
825           IsAlphabetic(myDisk.Value(1)) &&
826           myDisk.Value(2) == ':')                         // 'A:' to 'Z:'
827         )    // This is a MSDOS disk syntax
828      {
829       FullName += myDisk;
830       if (myDisk.Value(length) != ':') FullName += ":";
831      }
832      else   // This is an assigned Disk
833      {
834       FullName += "\\";
835       pDisk = myDisk;
836       VMSDisk2Other(pDisk);
837       FullName += pDisk;
838       if (Way.Value(1) != '\\') FullName += "\\";
839      }
840     }
841
842     if (Way.Length()!=0)
843      FullName = FullName + Way + "\\";
844     
845     FullName += myName; 
846     FullName += myExtension;
847 //    FullName.UpperCase();
848     break;
849    }
850
851    case OSD_MacOs :                // Mackintosh-like syntax
852     if (myDisk.Length()!=0){
853      FullName += myDisk ;
854      FullName += ":";
855     }
856     P2MAC(Way); 
857     FullName += myName;
858     FullName += myExtension;
859    break;
860
861
862
863    default :                      // UNIX-like syntax
864
865  // Syntax :
866  //             user"password"@host:/disk/xxx/xxx/filename
867     P2UNIX (Way);
868
869     if (myUserName.Length()!=0 && myNode.Length()!=0){  // If USER name
870      FullName += myUserName;                        // appends user name 
871
872      if (myPassword.Length()!=0)
873       FullName = FullName + "\"" + myPassword + "\""; // a password if not empty
874
875      FullName += "@";                            // and character '@'
876     }
877
878     if (myNode.Length()!=0){                     // Appends HOST name
879      FullName += myNode;
880      FullName += ":";
881     }
882
883     if (myDisk.Length()!=0) {                    // Appends Disk name as path
884      FullName += "/";
885      pDisk = myDisk;
886      VMSDisk2Other(pDisk);
887      FullName += pDisk;
888     }
889
890 //    if (FullName.Length()) {                     // Adds a "/" if necessary
891 //      FullName += "/";
892 //    }
893
894     if (Way.Length()!=0) {                       // Appends a path if not empty
895       FullName += Way ; 
896     }
897
898     if (FullName.Length()){
899         if (FullName.Value(FullName.Length()) != '/') {
900            FullName += "/";                      // Adds a / if necessary
901        }
902     }
903
904     if (myName.Length()){                        // Adds the file name
905       FullName += myName;
906     }
907
908     if (myExtension.Length()) {                  // Adds the extension
909       FullName += myExtension;
910     }
911     break;
912  }
913 }
914
915 #ifdef TOTO  // A reactiver...
916
917 void OSD_Path::SetSystemName(const TCollection_AsciiString& aDependentName,
918                    const OSD_SysType aSysType){
919   UnixExtract(aDependentName,myNode,myUserName,myPassword,myTrek,myName,myExtension);
920 }
921 #endif
922
923 TCollection_AsciiString OSD_Path::Node()const{
924  return(myNode);
925 }
926
927
928 TCollection_AsciiString OSD_Path::UserName()const{
929  return(myUserName);
930 }
931
932
933 TCollection_AsciiString OSD_Path::Password()const{
934  return(myPassword);
935 }
936
937
938 TCollection_AsciiString OSD_Path::Disk()const{
939  return(myDisk);
940 }
941
942
943 TCollection_AsciiString OSD_Path::Trek()const{
944  return(myTrek);
945 }
946
947
948 // Return extension (suffix) of file/directory name
949
950 TCollection_AsciiString OSD_Path::Extension()const{
951  return(myExtension);
952 }
953
954
955 TCollection_AsciiString OSD_Path::Name()const{
956  return(myName);
957 }
958
959
960 void OSD_Path::SetNode(const TCollection_AsciiString& aName){
961  if (!aName.IsAscii())
962   Standard_ConstructionError::Raise("OSD_Path::SetNode bad name");
963  myNode = aName;
964 }
965
966
967
968
969 void OSD_Path::SetUserName(const TCollection_AsciiString& aName){
970  if (!aName.IsAscii())
971   Standard_ConstructionError::Raise("OSD_Path::SetUserName bad name");
972  myUserName = aName;
973 }
974
975
976
977
978 void OSD_Path::SetPassword(const TCollection_AsciiString& aName){
979  if (!aName.IsAscii())
980   Standard_ConstructionError::Raise("OSD_Path::SetPassword bad name");
981   myPassword = aName;
982 }
983
984
985
986
987 void OSD_Path::SetDisk(const TCollection_AsciiString& aName){
988  if (!aName.IsAscii())
989   Standard_ConstructionError::Raise("OSD_Path::SetDisk bad name");
990   myDisk = aName;
991 }
992
993
994
995
996 void OSD_Path::SetTrek(const TCollection_AsciiString& aName){
997  if (!aName.IsAscii())
998   Standard_ConstructionError::Raise("OSD_Path::SetTrek bad name");
999   myTrek = aName;
1000 }
1001
1002
1003
1004
1005 void OSD_Path::SetName(const TCollection_AsciiString& aName){
1006  if (!aName.IsAscii())
1007   Standard_ConstructionError::Raise("OSD_Path::SetName bad name");
1008   myName = aName;
1009 }
1010
1011
1012
1013
1014 void OSD_Path::SetExtension(const TCollection_AsciiString& aName){
1015  if (!aName.IsAscii())
1016   Standard_ConstructionError::Raise("OSD_Path::SetExtension bad name");
1017   myExtension = aName;
1018 }
1019
1020 #else
1021
1022 //------------------------------------------------------------------------
1023 //-------------------  Windows NT sources for OSD_Path -------------------
1024 //------------------------------------------------------------------------
1025
1026 #include <OSD_Path.hxx>
1027 #include <Standard_ProgramError.hxx>
1028
1029 #include <windows.h>
1030 #include <stdlib.h>
1031 #include <tchar.h>
1032
1033 #define TEST_RAISE( type, arg ) _test_raise (  ( type ), ( arg )  )
1034
1035 static void __fastcall _test_raise ( OSD_SysType, Standard_CString );
1036 static void __fastcall _remove_dup ( TCollection_AsciiString& );
1037
1038 OSD_Path :: OSD_Path () {
1039
1040 }  // end constructor ( 1 )
1041
1042 OSD_Path ::  OSD_Path (
1043               const TCollection_AsciiString& aDependentName,
1044               const OSD_SysType aSysType
1045                           ) :
1046   myUNCFlag(Standard_False),
1047   SysDep(OSD_WindowsNT)
1048 {
1049
1050  Standard_Integer        i, j, len;
1051  static char __drive [ _MAX_DRIVE ];
1052  static char __dir [ _MAX_DIR ];
1053  static char __trek [ _MAX_DIR ];
1054  static char __fname [ _MAX_FNAME ];
1055  static char __ext [ _MAX_EXT ];
1056
1057  memset(__drive, 0,_MAX_DRIVE);
1058  memset(__dir, 0,_MAX_DIR);
1059  memset(__trek, 0,_MAX_DIR);
1060  memset(__fname, 0,_MAX_FNAME);
1061  memset(__ext, 0,_MAX_EXT);
1062  Standard_Character      chr;
1063
1064  TEST_RAISE(  aSysType, TEXT( "OSD_Path" )  );
1065
1066  _splitpath (  aDependentName.ToCString (), __drive, __dir, __fname, __ext );
1067  
1068  
1069
1070  myDisk      = __drive;
1071  myName      = __fname;
1072  myExtension = __ext;
1073
1074  {
1075    TCollection_AsciiString dir   = __dir;
1076    len = dir.UsefullLength ();
1077  }
1078
1079  for ( i = j = 0; i < len; ++i, ++j ) {
1080
1081   chr = __dir[i];
1082  
1083   if (  chr == TEXT( '\\' ) || chr == TEXT( '/' )  )
1084
1085    __trek[j] = TEXT( '|' );
1086
1087   else if (  chr == TEXT( '.' )&& (i+1) < len && __dir[i+1] == TEXT( '.' )  ) {
1088   
1089    __trek[j] = TEXT( '^' );
1090    ++i;
1091   
1092   } else
1093
1094    __trek[j] = chr;
1095  
1096  }  // end for
1097  __trek[j] = '\0';
1098  TCollection_AsciiString trek  = __trek;
1099  _remove_dup ( trek );
1100  myTrek = trek;
1101
1102 }  // end constructor ( 2 )
1103
1104 OSD_Path :: OSD_Path (
1105              const TCollection_AsciiString& aNode,
1106              const TCollection_AsciiString& aUsername,
1107              const TCollection_AsciiString& aPassword,
1108              const TCollection_AsciiString& aDisk,
1109              const TCollection_AsciiString& aTrek,
1110              const TCollection_AsciiString& aName,
1111              const TCollection_AsciiString& anExtension
1112                          ) :
1113   myUNCFlag(Standard_False),
1114   SysDep(OSD_WindowsNT)
1115 {
1116
1117  SetValues ( aNode, aUsername, aPassword, aDisk, aTrek, aName, anExtension );
1118
1119 }  // end constructor ( 3 )
1120
1121 void OSD_Path :: Values (
1122                   TCollection_AsciiString& aNode,
1123                   TCollection_AsciiString& aUsername,
1124                   TCollection_AsciiString& aPassword,
1125                   TCollection_AsciiString& aDisk,
1126                   TCollection_AsciiString& aTrek,
1127                   TCollection_AsciiString& aName,
1128                   TCollection_AsciiString& anExtension
1129                  ) const {
1130
1131  aNode       = myNode;
1132  aUsername   = myUserName;
1133  aPassword   = myPassword;
1134  aDisk       = myDisk;
1135  aTrek       = myTrek;
1136  if (!aTrek.IsEmpty() && aTrek.Value(aTrek.Length()) != '|')
1137    aTrek += "|" ; // (LD)
1138  aName       = myName;
1139  anExtension = myExtension;
1140
1141 }  // end OSD_Path :: Values
1142
1143 void OSD_Path :: SetValues (
1144                   const TCollection_AsciiString& aNode,
1145                   const TCollection_AsciiString& aUsername,
1146                   const TCollection_AsciiString& aPassword,
1147                   const TCollection_AsciiString& aDisk,
1148                   const TCollection_AsciiString& aTrek,
1149                   const TCollection_AsciiString& aName,
1150                   const TCollection_AsciiString& anExtension
1151                  ) {
1152
1153  myNode      = aNode;
1154  myUserName  = aUsername;
1155  myPassword  = aPassword;
1156  myDisk      = aDisk;
1157  myTrek      = aTrek;
1158  myName      = aName;
1159  myExtension = anExtension;
1160
1161  if (  myExtension.UsefullLength () && myExtension.Value ( 1 ) != TEXT( '.' )  )
1162
1163   myExtension.Insert (  1, TEXT( '.' )  );
1164
1165  _remove_dup ( myTrek );
1166
1167 }  // end OSD_Path :: SetValues
1168
1169 void OSD_Path :: SystemName (
1170                   TCollection_AsciiString& FullName,
1171                   const OSD_SysType aType
1172                  ) const {
1173
1174  Standard_Integer        i, j;
1175  TCollection_AsciiString fullPath;
1176  static Standard_Character trek [ _MAX_PATH ];
1177  Standard_Character      chr;
1178
1179  memset(trek,0,_MAX_PATH);
1180
1181  TEST_RAISE(  aType, TEXT( "SystemName" )  );
1182
1183  for ( i = j = 1; i <= myTrek.UsefullLength () && j <= _MAX_PATH; ++i, ++j ) {
1184
1185   chr = myTrek.Value ( i );   
1186
1187   if (  chr == TEXT( '|' )  ) {
1188   
1189    trek[j-1] = TEXT( '/' );
1190   
1191   } else if (  chr == TEXT( '^' ) && j <= _MAX_PATH - 1  ) {
1192    
1193    strcpy(&(trek[(j++) - 1]),TEXT( ".." ));
1194
1195   } else
1196
1197    trek[j-1] = chr ;
1198  
1199  }  //end for
1200
1201  fullPath = myDisk + TCollection_AsciiString(trek);
1202  
1203  if ( trek[0] ) fullPath += TEXT( "/" );
1204  
1205  fullPath += ( myName + myExtension );
1206
1207  if (  fullPath.UsefullLength () > 0  )
1208
1209   FullName = fullPath;
1210
1211  else
1212
1213   FullName.Clear ();
1214
1215 }  // end OSD_Path :: SystemName
1216
1217 Standard_Boolean OSD_Path :: IsValid (
1218                               const TCollection_AsciiString& /*aDependentName*/,
1219                               const OSD_SysType aSysType
1220                              ) const {
1221
1222  TEST_RAISE(  aSysType, TEXT( "IsValid" )  );
1223
1224  return Standard_True;
1225
1226 }  // end OSD_Path :: IsValid
1227
1228 void OSD_Path :: UpTrek () {
1229
1230  Standard_Integer pos = myTrek.SearchFromEnd (  TEXT( "|" )  );
1231
1232  if ( pos == -1 )
1233
1234   pos = 0;
1235
1236  else if ( pos > 1 ) {
1237
1238   while (  myTrek.Value ( pos ) == TEXT( '|' ) && pos != 1  ) --pos;
1239
1240  }  // end if
1241
1242  myTrek.Trunc ( pos );
1243
1244 }  // end OSD_Path :: UpTrek
1245
1246 void OSD_Path :: DownTrek ( const TCollection_AsciiString& aName ) {
1247
1248  Standard_Integer pos = myTrek.UsefullLength ();
1249
1250  if (  aName.Value ( 1 ) != TEXT( '|' )    &&
1251        pos                                 &&
1252        myTrek.Value ( pos ) != TEXT( '|' )
1253  )
1254
1255   myTrek += TEXT( "|" );
1256
1257  myTrek += aName;
1258
1259  _remove_dup ( myTrek );
1260
1261 }  // end OSD_Path :: DownTrek
1262
1263 Standard_Integer OSD_Path :: TrekLength () const {
1264
1265  Standard_Integer i      = 1;
1266  Standard_Integer retVal = 0;
1267
1268  if (  myTrek.IsEmpty () || myTrek.UsefullLength () == 1 && myTrek.Value ( 1 ) == TEXT( '|' )  )
1269
1270   return retVal;
1271
1272  for (;;) {
1273  
1274   if (  myTrek.Token (  TEXT( "|" ), i++  ).IsEmpty ()  )
1275
1276    break;
1277
1278   ++retVal;
1279  
1280  }  //end while
1281
1282  return retVal;
1283
1284 }  // end TrekLength
1285
1286 void OSD_Path :: RemoveATrek ( const Standard_Integer thewhere ) {
1287
1288  Standard_Integer i, j;
1289  Standard_Boolean flag = Standard_False;
1290
1291  if (  TrekLength () < thewhere  )
1292
1293   return;
1294
1295  if (  myTrek.Value ( 1 ) != TEXT( '|' )  ) {
1296  
1297   flag = Standard_True;
1298   myTrek.Insert (  1, TEXT( '|' )  );
1299  
1300  }  // end if
1301
1302  i = myTrek.Location (
1303              thewhere, TEXT( '|' ),
1304              1, myTrek.UsefullLength ()
1305             );
1306
1307  if ( i ) {
1308
1309   j = myTrek.Location (
1310               thewhere + 1, TEXT( '|' ),
1311               1, myTrek.UsefullLength ()
1312              );
1313
1314   if ( j == 0 )
1315
1316    j = myTrek.UsefullLength () + 1;
1317
1318   myTrek.Remove ( i, j - i );
1319
1320  }  // end if
1321
1322  if ( flag )
1323
1324   myTrek.Remove ( 1 );
1325
1326 }  // end OSD_Path :: RemoveATrek ( 1 )
1327
1328 void OSD_Path :: RemoveATrek ( const TCollection_AsciiString& aName ) {
1329
1330  Standard_Integer        i;
1331  Standard_Boolean        flag = Standard_False;
1332  TCollection_AsciiString tmp;
1333
1334  if (  myTrek.Value ( 1 ) != TEXT( '|' )  ) {
1335  
1336   flag = Standard_True;
1337   myTrek.Insert (  1, TEXT( '|' )  );
1338  
1339  }  // end if
1340
1341  myTrek += TEXT( '|' );
1342
1343  tmp = aName;
1344
1345  if (  tmp.Value ( 1 ) != TEXT( '|' )  )
1346
1347   tmp.Insert (  1, TEXT( '|' )  );
1348
1349  if (   tmp.Value (  tmp.UsefullLength ()  ) != TEXT( '|' )   )
1350
1351   tmp += TEXT( '|' );
1352
1353  i = myTrek.Search ( tmp );
1354
1355  if ( i != -1 )
1356  
1357   myTrek.Remove (  i + 1, tmp.UsefullLength () - 1  );
1358
1359  if ( flag )
1360
1361   myTrek.Remove ( 1 );
1362  
1363  if (   myTrek.Value (  myTrek.UsefullLength ()  ) == TEXT( '|' )  )
1364
1365   myTrek.Trunc (  myTrek.UsefullLength () - 1  );
1366
1367 }  // end OSD_Path :: RemoveATrek ( 2 )
1368
1369 TCollection_AsciiString OSD_Path :: TrekValue (
1370                                      const Standard_Integer thewhere
1371                                     ) const {
1372
1373  TCollection_AsciiString retVal;
1374  TCollection_AsciiString trek = myTrek;
1375
1376  if (  trek.Value ( 1 ) != TEXT( '|' )  )
1377  
1378   trek.Insert (  1, TEXT( '|' )  );
1379  
1380  retVal = trek.Token (  TEXT( "|" ), thewhere  );
1381
1382  return retVal;
1383
1384 }  // end OSD_Path :: TrekValue
1385
1386 void OSD_Path :: InsertATrek (
1387                   const TCollection_AsciiString& aName,
1388                   const Standard_Integer thewhere
1389                  ) {
1390
1391  Standard_Integer        pos;
1392  TCollection_AsciiString tmp = aName;
1393  Standard_Boolean        flag = Standard_False;
1394
1395  if (  myTrek.Value ( 1 ) != TEXT( '|' )  ) {
1396  
1397   flag = Standard_True;
1398   myTrek.Insert (  1, TEXT( '|' )  );
1399  
1400  }  // end if
1401
1402  myTrek += TEXT( '|' );
1403
1404  pos = myTrek.Location (
1405                thewhere, TEXT( '|' ),
1406                1, myTrek.UsefullLength ()
1407               );
1408
1409  if ( pos ) {
1410
1411   if (   tmp.Value (  tmp.UsefullLength ()  ) != TEXT( '|' )   )
1412
1413    tmp += TEXT( '|' );
1414
1415   myTrek.Insert ( pos + 1, tmp );
1416
1417  }  // end if
1418
1419  if ( flag )
1420
1421   myTrek.Remove ( 1 );
1422
1423  if (   myTrek.Value (  myTrek.UsefullLength ()  ) == TEXT( '|' )  )
1424
1425   myTrek.Trunc (  myTrek.UsefullLength () - 1  );
1426
1427  _remove_dup ( myTrek );
1428
1429 }  // end OSD_Path :: InsertATrek
1430
1431 TCollection_AsciiString OSD_Path :: Node () const {
1432
1433  return myNode;
1434
1435 }  // end OSD_Path :: Node
1436
1437 TCollection_AsciiString OSD_Path :: UserName () const {
1438
1439  return myUserName;
1440
1441 }  // end OSD_Path :: UserName
1442
1443 TCollection_AsciiString OSD_Path :: Password () const {
1444
1445  return myPassword;
1446
1447 }  // end OSD_Path :: Password
1448
1449 TCollection_AsciiString OSD_Path :: Disk () const {
1450
1451  return myDisk;
1452
1453 }  // end OSD_Path :: Disk
1454
1455 TCollection_AsciiString OSD_Path :: Trek () const {
1456
1457  TCollection_AsciiString retVal ;
1458  retVal = myTrek ;
1459  if (!retVal.IsEmpty() && retVal.Value(retVal.Length()) != '|')
1460    retVal += "|" ;          // (LD)
1461  return retVal;
1462
1463 }  // end OSD_Path :: Trek
1464
1465 TCollection_AsciiString OSD_Path :: Name () const {
1466
1467  return myName;
1468
1469 }  // end OSD_Path :: Name
1470
1471 TCollection_AsciiString OSD_Path :: Extension () const {
1472
1473  return myExtension;
1474
1475 }  // end OSD_Path :: Extension
1476
1477 void OSD_Path :: SetNode ( const TCollection_AsciiString& aName ) {
1478
1479  myNode = aName;
1480
1481 }  // end OSD_Path :: SetNode
1482
1483 void OSD_Path :: SetUserName (const TCollection_AsciiString& aName ) {
1484
1485  myUserName = aName;
1486
1487 }  // end OSD_Path :: SetUserName
1488
1489 void OSD_Path :: SetPassword ( const TCollection_AsciiString& aName ) {
1490
1491  myPassword = aName;
1492
1493 }  // end OSD_Path :: SetPassword
1494
1495 void OSD_Path :: SetDisk ( const TCollection_AsciiString& aName ) {
1496
1497  myDisk = aName;
1498
1499 }  // end OSD_Path :: SetDisk
1500
1501 void OSD_Path :: SetTrek (const TCollection_AsciiString& aName ) {
1502
1503  myTrek = aName;
1504
1505  _remove_dup ( myTrek );
1506
1507 }  // end OSD_Path :: SetTrek
1508
1509 void OSD_Path :: SetName ( const TCollection_AsciiString& aName ) {
1510
1511  myName = aName;
1512
1513 }  // end OSD_Path :: SetName
1514
1515 void OSD_Path :: SetExtension ( const TCollection_AsciiString& aName ) {
1516
1517  myExtension = aName;
1518
1519 }  // end OSD_Path :: SetExtension
1520
1521 static void __fastcall _test_raise ( OSD_SysType type, Standard_CString str ) {
1522
1523  Standard_Character buff[ 64 ];
1524
1525  if ( type != OSD_Default && type != OSD_WindowsNT ) {
1526  
1527   _tcscpy (  buff, TEXT( "OSD_Path :: " )  );
1528   _tcscat (  buff, str );
1529   _tcscat (  buff, TEXT( " (): unknown system type" )  );
1530
1531   Standard_ProgramError :: Raise ( buff );
1532  
1533  }  // end if
1534
1535 }  // end _test_raise
1536
1537 static void __fastcall _remove_dup ( TCollection_AsciiString& str ) {
1538
1539  Standard_Integer pos = 1, orgLen, len = str.UsefullLength ();
1540
1541  orgLen = len;
1542
1543  while ( pos <= len ) {
1544  
1545   if (  str.Value ( pos     ) == TEXT( '|' ) && pos != len &&
1546         str.Value ( pos + 1 ) == TEXT( '|' ) && pos != 1
1547   ) {
1548   
1549    ++pos;
1550
1551    while (  pos <= len && str.Value ( pos ) == TEXT( '|' )  ) str.Remove ( pos ), --len;
1552   
1553   } else
1554
1555    ++pos;
1556  
1557  }  // end while
1558
1559  if (  orgLen > 1 && len > 0 && str.Value ( len ) == TEXT( '|' )  ) str.Remove ( len );
1560
1561  pos = 1;
1562  orgLen = len = str.UsefullLength ();
1563
1564  while ( pos <= len ) {
1565  
1566   if (  str.Value ( pos ) == TEXT( '^' ) && pos != len && str.Value ( pos + 1 ) == TEXT( '^' )  ) {
1567   
1568    ++pos;
1569
1570    while (  pos <= len && str.Value ( pos ) == TEXT( '^' )  ) str.Remove ( pos ), --len;
1571   
1572   } else
1573
1574    ++pos;
1575  
1576  }  // end while
1577
1578 // if (  orgLen > 1 && len > 0 && str.Value ( len ) == TEXT( '^' )  ) str.Remove ( len );
1579
1580 }  // end _remove_dup
1581
1582 #endif
1583
1584 // ---------------------------------------------------------------------------
1585
1586 // Elimine les separateurs inutiles
1587
1588
1589 static Standard_Integer RemoveExtraSeparator(TCollection_AsciiString& aString) {
1590
1591   Standard_Integer i, j, len,start = 1 ;
1592
1593   len = aString.Length() ;
1594 #ifdef _WIN32
1595   if (len > 1 && aString.Value(1) == '/' && aString.Value(2) == '/')
1596     start = 2;
1597 #endif 
1598   for (i = j = start ; j <= len ; i++,j++) {
1599       Standard_Character c = aString.Value(j) ;
1600       aString.SetValue(i,c) ;
1601       if (c == '/')
1602           while(j < len && aString.Value(j+1) == '/') j++ ;
1603   }
1604   len = i-1 ;
1605   if (aString.Value(len) == '/') len-- ;  
1606   aString.Trunc(len) ;
1607   return len ;
1608 }
1609
1610 // ---------------------------------------------------------------------------
1611
1612 TCollection_AsciiString OSD_Path::RelativePath(
1613                             const TCollection_AsciiString& aDirPath,
1614                             const TCollection_AsciiString& aAbsFilePath)
1615 {
1616   TCollection_AsciiString EmptyString = "" ;
1617   TCollection_AsciiString FilePath ;
1618   Standard_Integer len ;
1619   Standard_Integer i, n ;
1620   Standard_Boolean Wnt = 0 ;
1621
1622   FilePath = aAbsFilePath ;
1623
1624   if (aDirPath.Search(":") == 2) {    // Cas WNT
1625       Wnt = 1 ;
1626       if (FilePath.Search(":") != 2 || 
1627           UpperCase(aDirPath.Value(1)) != UpperCase(FilePath.Value(1))
1628       )
1629           return  EmptyString ;
1630
1631       FilePath.ChangeAll('\\','/') ;
1632       if (FilePath.Search("/") != 3 )
1633           return  EmptyString ;
1634   }
1635   else {        // Cas Unix
1636       if (aDirPath.Value(1) != '/' || FilePath.Value(1) != '/')
1637           return  EmptyString ;
1638   }
1639
1640   // Eliminer les separateurs redondants
1641
1642   len = RemoveExtraSeparator(FilePath) ;
1643
1644   if (!Wnt) {
1645      if (len < 2)
1646          return  EmptyString ;
1647      FilePath = FilePath.SubString(2,len) ;
1648   }
1649   TCollection_AsciiString DirToken, FileToken ;
1650   Standard_Boolean Sibling = 0 ;
1651
1652   for (i = n = 1 ;; n++) {
1653       DirToken = aDirPath.Token("/\\",n) ;
1654       if (DirToken.IsEmpty())
1655           return FilePath ;
1656
1657       if (!Sibling) {
1658           len = FilePath.Length() ;
1659           i = FilePath.Search("/") ;
1660           if (i > 0) {
1661               if (i == len)
1662                   return EmptyString ;
1663
1664               FileToken = FilePath.SubString(1,i-1) ;
1665               if (Wnt) {
1666                   DirToken.UpperCase() ;
1667                   FileToken.UpperCase() ;
1668               }
1669               if (DirToken == FileToken) {
1670                   FilePath = FilePath.SubString(i+1,len) ;
1671                   continue ;
1672               }
1673           }
1674           else if (DirToken == FilePath)
1675               return EmptyString ;
1676  
1677           else
1678               Sibling = 1 ;
1679       }
1680       FilePath.Insert(1,"../") ;
1681   }
1682 }
1683       
1684 // ---------------------------------------------------------------------------
1685     
1686 TCollection_AsciiString OSD_Path::AbsolutePath(
1687                             const TCollection_AsciiString& aDirPath,
1688                             const TCollection_AsciiString& aRelFilePath)
1689 {
1690   TCollection_AsciiString EmptyString = "" ;
1691   if (aRelFilePath.Search("/") == 1 || aRelFilePath.Search(":") == 2)
1692       return aRelFilePath ;
1693   TCollection_AsciiString DirPath = aDirPath, RelFilePath = aRelFilePath  ;
1694   Standard_Integer i,len ;
1695
1696   if (DirPath.Search("/") != 1 && DirPath.Search(":") != 2)
1697       return EmptyString ;
1698
1699   if ( DirPath.Search(":") == 2)
1700       DirPath.ChangeAll('\\','/') ;
1701   RelFilePath.ChangeAll('\\','/') ;
1702   RemoveExtraSeparator(DirPath) ;
1703   len = RemoveExtraSeparator(RelFilePath) ;
1704   
1705   while (RelFilePath.Search("../") == 1) {
1706       if (len == 3)
1707           return EmptyString ;
1708       RelFilePath = RelFilePath.SubString(4,len) ;
1709       len -= 3 ;
1710       if (DirPath.IsEmpty())
1711           return EmptyString ;
1712       i = DirPath.SearchFromEnd("/") ;
1713       if (i < 0)
1714           return EmptyString ;
1715       DirPath.Trunc(i-1) ;
1716   }
1717   DirPath += '/' ;
1718   DirPath += RelFilePath ;
1719   return DirPath ;
1720 }
1721
1722 //void OSD_Path::ExpandedName(TCollection_AsciiString& aName)
1723 void OSD_Path::ExpandedName(TCollection_AsciiString& )
1724 {
1725 }
1726
1727 //Standard_Boolean LocateExecFile(OSD_Path& aPath)
1728 Standard_Boolean LocateExecFile(OSD_Path& )
1729 {
1730   return Standard_False ;
1731 }