| /** | |
| * This file has no copyright assigned and is placed in the Public Domain. | |
| * This file is part of the mingw-w64 runtime package. | |
| * No warranty is given; refer to the file DISCLAIMER.PD within this package. | |
| */ | |
| #ifndef WIN32_LEAN_AND_MEAN | |
| #define WIN32_LEAN_AND_MEAN | |
| #endif | |
| #include <stdlib.h> | |
| #include <locale.h> | |
| #include <libgen.h> | |
| #include <windows.h> | |
| /* A 'directory separator' is a byte that equals 0x2F ('solidus' or more | |
| * commonly 'forward slash') or 0x5C ('reverse solidus' or more commonly | |
| * 'backward slash'). The byte 0x5C may look different from a backward slash | |
| * in some locales; for example, it looks the same as a Yen sign in Japanese | |
| * locales and a Won sign in Korean locales. Despite its appearance, it still | |
| * functions as a directory separator. | |
| * | |
| * A 'path' comprises an optional DOS drive letter with a colon, and then an | |
| * arbitrary number of possibily empty components, separated by non-empty | |
| * sequences of directory separators (in other words, consecutive directory | |
| * separators are treated as a single one). A path that comprises an empty | |
| * component denotes the current working directory. | |
| * | |
| * An 'absolute path' comprises at least two components, the first of which | |
| * is empty. | |
| * | |
| * A 'relative path' is a path that is not an absolute path. In other words, | |
| * it either comprises an empty component, or begins with a non-empty | |
| * component. | |
| * | |
| * POSIX doesn't have a concept about DOS drives. A path that does not have a | |
| * drive letter starts from the same drive as the current working directory. | |
| * | |
| * For example: | |
| * (Examples without drive letters match POSIX.) | |
| * | |
| * Argument dirname() returns basename() returns | |
| * -------- ----------------- ------------------ | |
| * `` or NULL `.` `.` | |
| * `usr` `.` `usr` | |
| * `usr\` `.` `usr` | |
| * `\` `\` `\` | |
| * `\usr` `\` `usr` | |
| * `\usr\lib` `\usr` `lib` | |
| * `\home\\dwc\\test` `\home\\dwc` `test` | |
| * `\\host\usr` `\\host\.` `usr` | |
| * `\\host\usr\lib` `\\host\usr` `lib` | |
| * `\\host\\usr` `\\host\\` `usr` | |
| * `\\host\\usr\lib` `\\host\\usr` `lib` | |
| * `C:` `C:.` `.` | |
| * `C:usr` `C:.` `usr` | |
| * `C:usr\` `C:.` `usr` | |
| * `C:\` `C:\` `\` | |
| * `C:\\` `C:\` `\` | |
| * `C:\\\` `C:\` `\` | |
| * `C:\usr` `C:\` `usr` | |
| * `C:\usr\lib` `C:\usr` `lib` | |
| * `C:\\usr\\lib\\` `C:\\usr` `lib` | |
| * `C:\home\\dwc\\test` `C:\home\\dwc` `test` | |
| */ | |
| struct path_info | |
| { | |
| /* This points to end of the UNC prefix and drive letter, if any. */ | |
| char* prefix_end; | |
| /* These point to the directory separator in front of the last non-empty | |
| * component. */ | |
| char* base_sep_begin; | |
| char* base_sep_end; | |
| /* This points to the last directory separator sequence if no other | |
| * non-separator characters follow it. */ | |
| char* term_sep_begin; | |
| /* This points to the end of the string. */ | |
| char* path_end; | |
| }; | |
| #define IS_DIR_SEP(c) ((c) == '/' || (c) == '\\') | |
| static | |
| void | |
| do_get_path_info(struct path_info* info, char* path) | |
| { | |
| char* pos = path; | |
| int unc_ncoms = 0; | |
| DWORD cp; | |
| int dbcs_tb, prev_dir_sep, dir_sep; | |
| /* Get the code page for paths in the same way as `fopen()`. */ | |
| cp = __mingw_filename_cp(); | |
| /* Set the structure to 'no data'. */ | |
| info->prefix_end = NULL; | |
| info->base_sep_begin = NULL; | |
| info->base_sep_end = NULL; | |
| info->term_sep_begin = NULL; | |
| if(IS_DIR_SEP(pos[0]) && IS_DIR_SEP(pos[1])) { | |
| /* The path is UNC. */ | |
| pos += 2; | |
| /* Seek to the end of the share/device name. */ | |
| dbcs_tb = 0; | |
| prev_dir_sep = 0; | |
| while(*pos != 0) { | |
| dir_sep = 0; | |
| if(dbcs_tb) | |
| dbcs_tb = 0; | |
| else if(__mingw_isleadbyte_cp(*pos, cp)) | |
| dbcs_tb = 1; | |
| else | |
| dir_sep = IS_DIR_SEP(*pos); | |
| /* If a separator has been encountered and the previous character | |
| * was not, mark this as the end of the current component. */ | |
| if(dir_sep && !prev_dir_sep) { | |
| unc_ncoms ++; | |
| /* The first component is the host name, and the second is the | |
| * share name. So we stop at the end of the second component. */ | |
| if(unc_ncoms == 2) | |
| break; | |
| } | |
| prev_dir_sep = dir_sep; | |
| pos ++; | |
| } | |
| /* The UNC prefix terminates here. The terminating directory separator | |
| * is not part of the prefix, and initiates a new absolute path. */ | |
| info->prefix_end = pos; | |
| } | |
| else if((pos[0] >= 'A' && pos[0] <= 'Z' && pos[1] == ':') | |
| || (pos[0] >= 'a' && pos[0] <= 'z' && pos[1] == ':')) { | |
| /* The path contains a DOS drive letter in the beginning. */ | |
| pos += 2; | |
| /* The DOS drive prefix terminates here. Unlike UNC paths, the remaing | |
| * part can be relative. For example, `C:foo` denotes `foo` in the | |
| * working directory of drive `C:`. */ | |
| info->prefix_end = pos; | |
| } | |
| /* The remaining part of the path is almost the same as POSIX. */ | |
| dbcs_tb = 0; | |
| prev_dir_sep = 0; | |
| while(*pos != 0) { | |
| dir_sep = 0; | |
| if(dbcs_tb) | |
| dbcs_tb = 0; | |
| else if(__mingw_isleadbyte_cp(*pos, cp)) | |
| dbcs_tb = 1; | |
| else | |
| dir_sep = IS_DIR_SEP(*pos); | |
| /* If a separator has been encountered and the previous character | |
| * was not, mark this as the beginning of the terminating separator | |
| * sequence. */ | |
| if(dir_sep && !prev_dir_sep) | |
| info->term_sep_begin = pos; | |
| /* If a non-separator character has been encountered and a previous | |
| * terminating separator sequence exists, start a new component. */ | |
| if(!dir_sep && prev_dir_sep) { | |
| info->base_sep_begin = info->term_sep_begin; | |
| info->base_sep_end = pos; | |
| info->term_sep_begin = NULL; | |
| } | |
| prev_dir_sep = dir_sep; | |
| pos ++; | |
| } | |
| /* Store the end of the path for convenience. */ | |
| info->path_end = pos; | |
| } | |
| char* | |
| dirname(char* path) | |
| { | |
| struct path_info info; | |
| char* upath; | |
| const char* top; | |
| static char* static_path_copy; | |
| if(path == NULL || path[0] == 0) | |
| return (char*) "."; | |
| do_get_path_info(&info, path); | |
| upath = info.prefix_end ? info.prefix_end : path; | |
| top = (IS_DIR_SEP(path[0]) || IS_DIR_SEP(upath[0])) ? "\\" : "."; | |
| /* If a non-terminating directory separator exists, it terminates the | |
| * dirname. Truncate the path there. */ | |
| if(info.base_sep_begin) { | |
| info.base_sep_begin[0] = 0; | |
| /* If the unprefixed path has not been truncated to empty, it is now | |
| * the dirname, so return it. */ | |
| if(upath[0]) | |
| return path; | |
| } | |
| /* The dirname is empty. In principle we return `<prefix>.` if the | |
| * path is relative and `<prefix>\` if it is absolute. This can be | |
| * optimized if there is no prefix. */ | |
| if(upath == path) | |
| return (char*) top; | |
| /* When there is a prefix, we must append a character to the prefix. | |
| * If there is enough room in the original path, we just reuse its | |
| * storage. */ | |
| if(upath != info.path_end) { | |
| upath[0] = *top; | |
| upath[1] = 0; | |
| return path; | |
| } | |
| /* This is only the last resort. If there is no room, we have to copy | |
| * the prefix elsewhere. */ | |
| upath = realloc(static_path_copy, info.prefix_end - path + 2); | |
| if(!upath) | |
| return (char*) top; | |
| static_path_copy = upath; | |
| memcpy(upath, path, info.prefix_end - path); | |
| upath += info.prefix_end - path; | |
| upath[0] = *top; | |
| upath[1] = 0; | |
| return static_path_copy; | |
| } | |
| char* | |
| basename(char* path) | |
| { | |
| struct path_info info; | |
| char* upath; | |
| if(path == NULL || path[0] == 0) | |
| return (char*) "."; | |
| do_get_path_info(&info, path); | |
| upath = info.prefix_end ? info.prefix_end : path; | |
| /* If the path is non-UNC and empty, then it's relative. POSIX says '.' | |
| * shall be returned. */ | |
| if(IS_DIR_SEP(path[0]) == 0 && upath[0] == 0) | |
| return (char*) "."; | |
| /* If a terminating separator sequence exists, it is not part of the | |
| * name and shall be truncated. */ | |
| if(info.term_sep_begin) | |
| info.term_sep_begin[0] = 0; | |
| /* If some other separator sequence has been found, the basename | |
| * immediately follows it. */ | |
| if(info.base_sep_end) | |
| return info.base_sep_end; | |
| /* If removal of the terminating separator sequence has caused the | |
| * unprefixed path to become empty, it must have comprised only | |
| * separators. POSIX says `/` shall be returned, but on Windows, we | |
| * return `\` instead. */ | |
| if(upath[0] == 0) | |
| return (char*) "\\"; | |
| /* Return the unprefixed path. */ | |
| return upath; | |
| } |