Mercurial > octave-nkf

comparison liboctave/file-ops.cc @ 10252:2fcc927a8757

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
liboctave/file-ops.h: avoid gnulib #define for canonicalize_file_name
author John W. Eaton <jwe@octave.org>
date Wed, 03 Feb 2010 03:42:08 -0500
parents 2d47356a7a1a
children 323c9cbbd02a
comparison
equal deleted inserted replaced
10251:28e5a5f826bc 10252:2fcc927a8757
357 ? dir + file 357 ? dir + file
358 : dir + dir_sep_char () + file); 358 : dir + dir_sep_char () + file);
359 } 359 }
360 360
361 361
362 std::string
363 file_ops::canonicalize_file_name (const std::string& name)
364 {
365 std::string msg;
366 return canonicalize_file_name (name, msg);
367 }
368
369 std::string
370 file_ops::canonicalize_file_name (const std::string& name, std::string& msg)
371 {
372 msg = std::string ();
373
374 std::string retval;
375
376 #if defined (HAVE_CANONICALIZE_FILE_NAME)
377
378 char *tmp = ::canonicalize_file_name (name.c_str ());
379
380 if (tmp)
381 {
382 retval = tmp;
383 free (tmp);
384 }
385
386 #elif defined (HAVE_RESOLVEPATH)
387
388 #if !defined (errno)
389 extern int errno;
390 #endif
391
392 #if !defined (__set_errno)
393 # define __set_errno(Val) errno = (Val)
394 #endif
395
396 if (name.empty ())
397 {
398 __set_errno (ENOENT);
399 return retval;
400 }
401
402 // All known hosts with resolvepath (e.g. Solaris 7) don't turn
403 // relative names into absolute ones, so prepend the working
404 // directory if the path is not absolute.
405
406 std::string absolute_name = octave_env::make_absolute (name);
407
408 size_t resolved_size = absolute_name.length ();
409
410 while (true)
411 {
412 resolved_size = 2 * resolved_size + 1;
413
414 OCTAVE_LOCAL_BUFFER (char, resolved, resolved_size);
415
416 int resolved_len
417 = resolvepath (absolute_name.c_str (), resolved, resolved_size);
418
419 if (resolved_len < 0)
420 break;
421
422 if (resolved_len < resolved_size)
423 {
424 retval = resolved;
425 break;
426 }
427 }
428
429 #elif defined (__WIN32__)
430
431 int n = 1024;
432
433 std::string win_path (n, '\0');
434
435 while (true)
436 {
437 int status = GetFullPathName (name.c_str (), n, &win_path[0], 0);
438
439 if (status == 0)
440 break;
441 else if (status < n)
442 {
443 win_path.resize (status);
444 retval = win_path;
445 break;
446 }
447 else
448 {
449 n *= 2;
450 win_path.resize (n);
451 }
452 }
453
454 #elif defined (HAVE_REALPATH)
455
456 #if !defined (__set_errno)
457 # define __set_errno(Val) errno = (Val)
458 #endif
459
460 if (name.empty ())
461 {
462 __set_errno (ENOENT);
463 return retval;
464 }
465
466 OCTAVE_LOCAL_BUFFER (char, buf, PATH_MAX);
467
468 if (::realpath (name.c_str (), buf))
469 retval = buf;
470
471 #else
472
473 // FIXME -- provide replacement here...
474 retval = name;
475
476 #endif
477
478 if (retval.empty ())
479 {
480 using namespace std;
481 msg = strerror (errno);
482 }
483
484 return retval;
485 }
486
487 int 362 int
488 octave_mkdir (const std::string& nm, mode_t md) 363 octave_mkdir (const std::string& nm, mode_t md)
489 { 364 {
490 std::string msg; 365 std::string msg;
491 return octave_mkdir (nm, md, msg); 366 return octave_mkdir (nm, md, msg);
820 msg = strerror (errno); 695 msg = strerror (errno);
821 } 696 }
822 697
823 return retval; 698 return retval;
824 } 699 }
700
701 std::string
702 octave_canonicalize_file_name (const std::string& name)
703 {
704 std::string msg;
705 return octave_canonicalize_file_name (name, msg);
706 }
707
708 std::string
709 octave_canonicalize_file_name (const std::string& name, std::string& msg)
710 {
711 msg = std::string ();
712
713 std::string retval;
714
715 #if defined (HAVE_CANONICALIZE_FILE_NAME)
716
717 char *tmp = ::canonicalize_file_name (name.c_str ());
718
719 if (tmp)
720 {
721 retval = tmp;
722 free (tmp);
723 }
724
725 #elif defined (HAVE_RESOLVEPATH)
726
727 #if !defined (errno)
728 extern int errno;
729 #endif
730
731 #if !defined (__set_errno)
732 # define __set_errno(Val) errno = (Val)
733 #endif
734
735 if (name.empty ())
736 {
737 __set_errno (ENOENT);
738 return retval;
739 }
740
741 // All known hosts with resolvepath (e.g. Solaris 7) don't turn
742 // relative names into absolute ones, so prepend the working
743 // directory if the path is not absolute.
744
745 std::string absolute_name = octave_env::make_absolute (name);
746
747 size_t resolved_size = absolute_name.length ();
748
749 while (true)
750 {
751 resolved_size = 2 * resolved_size + 1;
752
753 OCTAVE_LOCAL_BUFFER (char, resolved, resolved_size);
754
755 int resolved_len
756 = resolvepath (absolute_name.c_str (), resolved, resolved_size);
757
758 if (resolved_len < 0)
759 break;
760
761 if (resolved_len < resolved_size)
762 {
763 retval = resolved;
764 break;
765 }
766 }
767
768 #elif defined (__WIN32__)
769
770 int n = 1024;
771
772 std::string win_path (n, '\0');
773
774 while (true)
775 {
776 int status = GetFullPathName (name.c_str (), n, &win_path[0], 0);
777
778 if (status == 0)
779 break;
780 else if (status < n)
781 {
782 win_path.resize (status);
783 retval = win_path;
784 break;
785 }
786 else
787 {
788 n *= 2;
789 win_path.resize (n);
790 }
791 }
792
793 #elif defined (HAVE_REALPATH)
794
795 #if !defined (__set_errno)
796 # define __set_errno(Val) errno = (Val)
797 #endif
798
799 if (name.empty ())
800 {
801 __set_errno (ENOENT);
802 return retval;
803 }
804
805 OCTAVE_LOCAL_BUFFER (char, buf, PATH_MAX);
806
807 if (::realpath (name.c_str (), buf))
808 retval = buf;
809
810 #else
811
812 // FIXME -- provide replacement here...
813 retval = name;
814
815 #endif
816
817 if (retval.empty ())
818 {
819 using namespace std;
820 msg = strerror (errno);
821 }
822
823 return retval;
824 }
825