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