#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
-#ifdef __UNIX__
+#if defined(__UNIX__) || defined(__GNU_WINDOWS__)
#include <unistd.h>
-#endif
-#ifdef __WIN32__
+#else
#include <io.h>
#endif
bool filename::unlink() const { return ::unlink(observe()) == 0; }
+void filename::reset(const astring &name) {
+ *this = name;
+ _had_directory = true; // until we know better.
+ canonicalize();
+}
+
astring filename::null_device()
{
#ifdef __WIN32__
// on windows, we want to translate away from any cygwin or msys format into a more palatable
// version that the rest of windows understands.
// first, cygwin...
- const astring CYGDRIVE_PATH = astring(astring(DEFAULT_SEPARATOR, 1) + "cygdrive"
- + astring(DEFAULT_SEPARATOR, 1));
+//hmmm: make these into statics!
+ const astring CYGDRIVE_SENTINEL = "cygdrive";
+ const astring CYGDRIVE_PATH = astring(astring(DEFAULT_SEPARATOR, 1)
+ + CYGDRIVE_SENTINEL + astring(DEFAULT_SEPARATOR, 1));
+
// must be at least as long as the string we're looking for, plus a drive letter afterwards.
- if ( (length() > CYGDRIVE_PATH.length() + 1) && begins(CYGDRIVE_PATH) ) {
+ if ( (length() >= CYGDRIVE_PATH.length() + 1)
+ && separator(get(0))
+ && separator(get(CYGDRIVE_PATH.length() - 1))
+ && compare(CYGDRIVE_SENTINEL, 1,
+ 0, CYGDRIVE_SENTINEL.length(), true) ) {
zap(0, CYGDRIVE_PATH.length() - 1); // whack the cygdrive portion plus two slashes.
insert(1, ":"); // add a colon after the imputed drive letter.
-LOG(astring("turned cygdrive string into: ") + *this);
+//LOG(astring("turned cygdrive path string into: ") + *this);
+ } else {
+//LOG(astring("path didn't match so left as: ") + *this);
}
// now we convert msys...
if ( (length() >= 2) && (get(0) == DEFAULT_SEPARATOR)
// then only on the near defunct windows platform.
zap(0, 0); // take off initial slash.
insert(1, ":"); // add the obligatory colon.
-LOG(astring("turned msys string into: ") + *this);
+//LOG(astring("turned msys string into: ") + *this);
}
}
+
+ // if no specialized path specifications were seen, and we have a unix style path
+ // here, then there will be trouble when we pass that to windows.
+//if first character is a slash, and second char is alphanumeric, then we check...
+//can we find a cygwin root dir stored in our config stuff?
+// maybe in the build version file? ugh, yuck.
+// what about in generated files, created at build time? --> yes, nice option.
+//
+//hmmm: we need the capability to re-create the config file that tells us
+// where cyg root is, but how can we, aside from guessing at where to find
+// cygwin (c:/cygwin c:/cygwin64 etc).
+//
+//hmmm:
+
#endif
// we don't crop the last separator if the name's too small. for msdos
return !!(fill.st_mode & S_IEXEC);
}
+bool filename::is_normal() const
+{
+ status_info fill;
+ if (!get_info(&fill))
+ return false;
+#if defined(__WIN32__) || defined(__VMS__)
+//hmmm: is there a corresponding set of functions for windows, where applicable?
+ bool weird = false;
+#else
+ bool weird = S_ISCHR(fill.st_mode)
+ || S_ISBLK(fill.st_mode)
+ || S_ISFIFO(fill.st_mode)
+ || S_ISSOCK(fill.st_mode);
+#endif
+ return !weird;
+}
+
int filename::find_last_separator(const astring &look_at) const
{
int last_sep = -1;
{
if (is_directory())
return true;
+ // if the file name is empty, that cannot exist.
if (!length())
return false;
return is_readable();
-/// byte_filer opened(observe(), "rb");
-/// return opened.good();
}
bool filename::legal_character(char to_check)
return true;
}
-void filename::separate(string_array &pieces) const
+void filename::separate(bool &rooted, string_array &pieces) const
{
pieces.reset();
const astring &raw_form = raw();
astring accumulator; // holds the names we find.
+ rooted = raw_form.length() && separator(raw_form[0]);
for (int i = 0; i < raw_form.length(); i++) {
if (separator(raw_form[i])) {
// this is a separator character, so eat it and add the accumulated
// string to the list.
- if (!i || accumulator.length()) pieces += accumulator;
+ if (i && accumulator.length()) pieces += accumulator;
// now reset our accumulated text.
accumulator = astring::empty_string();
} else {
if (accumulator.length()) pieces += accumulator;
}
-void filename::join(const string_array &pieces)
+void filename::join(bool rooted, const string_array &pieces)
{
astring constructed_name; // we'll make a filename here.
+ if (rooted) constructed_name += DEFAULT_SEPARATOR;
for (int i = 0; i < pieces.length(); i++) {
constructed_name += pieces[i];
if (!i || (i != pieces.length() - 1))
bool filename::base_compare_prefix(const filename &to_compare,
string_array &first, string_array &second)
{
- separate(first);
- to_compare.separate(second);
+ bool first_rooted;
+ separate(first_rooted, first);
+ bool second_rooted;
+ to_compare.separate(second_rooted, second);
+ if (first_rooted != second_rooted) {
+ return false;
+ }
// that case should never be allowed, since there are some bits missing
// in the name to be compared.
if (first.length() > second.length())
bool filename::base_compare_suffix(const filename &to_compare,
string_array &first, string_array &second)
{
- separate(first);
- to_compare.separate(second);
+ bool first_rooted;
+ separate(first_rooted, first);
+ bool second_rooted;
+ to_compare.separate(second_rooted, second);
// that case should never be allowed, since there are some bits missing
// in the name to be compared.
if (first.length() > second.length())
projects / feisty_meow.git / blobdiff