| /** |
| * 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 <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 = AreFileApisANSI() ? CP_ACP : CP_OEMCP; |
| |
| /* 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(IsDBCSLeadByteEx(cp, *pos)) |
| 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(IsDBCSLeadByteEx(cp, *pos)) |
| 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; |
| } |
