DIRECTOR: More fixes for partial filename matching

For Macintosh, it is possible to have filenames with a "/" in them.
Dumper Companion will punyencode this and any other non-ASCII characters
when extracting from a Macintosh filesystem. As such, when checking
components of a filename, we should attempt to match against the punydecoded
name, but always return the "real" name (i.e. the name of the file in
the local filesystem, possibly punyencoded).

In addition, it is possible for a movie A/B/C.DIR to go to a movie
"E/F.DIR", where the actual path is A/E/F.DIR. To make the partial matching
work, first we try removing each component from the start of the target
path, then retry all combinations again after removing a component from
the end of the source directory, etc.

Fixes several movie switches in The Seven Colors.

common/fs.h

@@ -79,7 +79,6 @@ private:
 	 */
 	FSNode(AbstractFSNode *realNode);
 
-	String getRealName() const;
 public:
 	/**
 	 * Flag to tell listDir() which kind of files to list.
@@ -169,6 +168,16 @@ public:
 	 */
 	virtual String getName() const;
 
+	/**
+	 * Return a string representation of the name of the file, without any
+	 * Punycode transformation. This can be used e.g. by detection code that
+	 * relies on matching the name of a given file. However, it is *not*
+	 * suitable for use with fopen / File::open, nor should it be archived.
+	 *
+	 * @return The file name.
+	 */
+	virtual String getRealName() const;
+
 	/**
 	 * Return a string representation of the file that is suitable for
 	 * archiving (i.e. writing to the config file). This will usually be a

engines/director/util.cpp

@@ -593,8 +593,7 @@ Common::Path resolveFSPath(Common::String &path, Common::Path &base, bool direct
 	Common::FSList fslist;
 	bool exists = false;
 	while (!directory_list.empty()) {
-		Common::String token = directory_list.nextToken();
+		Common::String token = punycode_decodefilename(directory_list.nextToken());
-		Common::String decodedToken = punycode_decodefilename(token);
 		fslist.clear();
 		Common::FSNode::ListMode mode = Common::FSNode::kListDirectoriesOnly;
 		if (directory_list.empty() && !directory) {
@@ -608,14 +607,15 @@ Common::Path resolveFSPath(Common::String &path, Common::Path &base, bool direct
 		for (auto &i : fslist) {
 			// for each element in the path, choose the first FSNode
 			// with a case-insensitive matching name
-			if (i.getName().equalsIgnoreCase(decodedToken)) {
+			Common::String decodedName = i.getName();
+			if (decodedName.equalsIgnoreCase(token)) {
 				// If this the final path component, check if we're allowed to match with a directory
 				if (directory_list.empty() && (directory != i.isDirectory())) {
 					continue;
 				}
 
 				exists = true;
-				newPath.appendInPlace(i.getName());
+				newPath.appendInPlace(i.getRealName());
 				if (!directory_list.empty() && !newPath.empty())
 					newPath.appendInPlace(Common::String(g_director->_dirSeparator), g_director->_dirSeparator);
 
@@ -688,7 +688,7 @@ Common::Path resolvePath(Common::String &path, Common::Path &base, bool director
 				continue;
 			}
 			bool match = true;
-			for (int i = 0; i < srcComponents.size(); i++) {
+			for (size_t i = 0; i < srcComponents.size(); i++) {
 				Common::String component = Common::punycode_decodefilename(destComponents[i]);
 				if (!component.equalsIgnoreCase(srcComponents[i])) {
 					match = false;
@@ -711,22 +711,37 @@ Common::Path resolvePath(Common::String &path, Common::Path &base, bool director
 
 Common::Path resolvePartialPath(Common::String &path, Common::Path &base, bool directory, const char **exts) {
 	path = convertPath(path);
-	Common::StringArray tokens = Common::StringTokenizer(path, Common::String(g_director->_dirSeparator)).split();
-
 	Common::Path result;
-	while (tokens.size()) {
+
-		Common::String subpath;
+	Common::StringArray baseTokens = base.splitComponents();
-		for (uint i = 0; i < tokens.size(); i++) {
+	bool basesLeft = true;
-			subpath += tokens[i];
+	while (basesLeft) {
-			if (i < tokens.size() - 1) {
+		Common::Path testBase = Common::Path::joinComponents(baseTokens);
-				subpath += g_director->_dirSeparator;
+
+		// Try removing leading components of the target path
+		Common::StringArray tokens = Common::StringTokenizer(path, Common::String(g_director->_dirSeparator)).split();
+
+		while (tokens.size()) {
+			Common::String subpath;
+			for (uint i = 0; i < tokens.size(); i++) {
+				subpath += tokens[i];
+				if (i < tokens.size() - 1) {
+					subpath += g_director->_dirSeparator;
+				}
 			}
+			result = resolvePath(subpath, testBase, directory, exts);
+			if (!result.empty()) {
+				break;
+			}
+			tokens.remove_at(0);
 		}
-		result = resolvePath(subpath, base, directory, exts);
+		if (!result.empty())
-		if (!result.empty()) {
 			break;
+		if (!baseTokens.size()) {
+			basesLeft = false;
+		} else {
+			baseTokens.pop_back();
 		}
-		tokens.remove_at(0);
 	}
 	return result;
 }