View difference between Paste ID: VsA82fKj and 9MLbD7GC

 /**
  * Expand environment variables in text (bash style)
  * @author gocha <http://twitter.com/gochaism> (I release it into public domain, though)
  * FYI: Windows have ExpandEnvironmentStrings function for a similar purpose.
-import java.util.Map;
+
-import java.util.regex.Pattern;
+
-import java.util.regex.Matcher;
+#include <stdio.h>
-import java.util.regex.MatchResult;
+#include <stdlib.h>
 #include <malloc.h>
-public class VariablePath
+#include <ctype.h>
 
-	/**
+#ifdef HAVE_STDBOOL_H
-	 * Expand environment variables in text
+#  include <stdbool.h>
-	 * @param path input path string
+#else
-	 * @param userVariableMap user-defined variable name/value map (null if not needed)
+#  ifndef HAVE__BOOL
-	 * @param useEnvironmentVariables true if expand environment variables
+#    ifdef __cplusplus
-	 * @param throwException true if throw Exception if a variable is not defined
+       typedef bool _Bool;
-	 * @return expanded path string
+#    else
-	 * @throws IllegalArgumentException if a variable is not defined
+#      define _Bool signed char
-	 */
+#    endif
-	private static String expand(String path, Map<String, String> userVariableMap, boolean useEnvironmentVariables, boolean throwException) throws IllegalArgumentException
+#  endif
 #  define bool _Bool
-		Pattern variablePattern = Pattern.compile("\\$\\{(.*)\\}|\\$([0-9]+|[A-Za-z_][0-9A-Za-z_]*)");
+#  define false 0
-		Matcher variableMatcher = variablePattern.matcher(path);
+#  define true 1
-		StringBuffer pathBuffer = new StringBuffer();
+#  define __bool_true_false_are_defined 1
-		int lastMatchEnd = 0;
+#endif
-		while (variableMatcher.find())
+
 /**
-			// get variable name
+ * Expand environment variables in a string (bash style)
-			MatchResult matchResult = variableMatcher.toMatchResult();
+ * @param str Input path string.
-			boolean variableHasPathensis = (matchResult.group(1) != null);
+ * @param outputStr Output path string buffer.
-			String variableName = (variableHasPathensis ? matchResult.group(1) : matchResult.group(2));
+ * @param bufferSize Size of the output buffer in chars. (includes null character)
-			String variableContent = null;
+ * @return Number of characters written to the buffer (excludes null character). Returns -1 if a fatal error occurred.
  */
-			// get environment variable
+int ExpandEnvironmentVariables(const char *str, char *outputStr, int bufferSize)
-			if (useEnvironmentVariables)
+
 	int inIndex = 0;
-				variableContent = System.getenv(variableName);
+	int outIndex = 0;
 	int varStartIndex = -1;
-			// if not available, get user-defined variable
+	bool isInVariable = false;
-			if (variableContent == null && userVariableMap != null)
+	bool hasParenthesis = false;
 	char *varName = NULL;
-				variableContent = userVariableMap.get(variableName);
+	char *varValue = NULL;
 	int varNameLength = 0;
-			// if the variable is not defined
+	int varValueLength = 0;
-			if (variableContent == null)
+	unsigned char cIn, cNext;
 
-				if (throwException)
+	do
 	{
-					// throw Exception if needed
+		// check output buffer size
-					throw new IllegalArgumentException(path.substring(matchResult.start(), matchResult.end()) + " is not defined.");
+		if (outIndex >= bufferSize)
 		{
 			outputStr[bufferSize - 1] = '\0';
 			outIndex = bufferSize + 1;
-					// otherwise, use empty string
+			break;
-					variableContent = "";
+
 
 		// read a character
 		cIn = (unsigned char) str[inIndex];
-			// put the value, and a part of string just before the variable
+		cNext = (cIn != '\0') ? (unsigned char) str[inIndex + 1] : '\0';
-			pathBuffer.append(path.substring(lastMatchEnd, matchResult.start()));
+
-			pathBuffer.append(variableContent);
+		if (isInVariable)
-			lastMatchEnd = matchResult.end();
+
 			// check if we are still in a variable
-		// put the rest, and return the result
+			if (hasParenthesis)
-		pathBuffer.append(path.substring(lastMatchEnd, path.length()));
+
-		return pathBuffer.toString();
+				isInVariable = (cIn != '}');
-	}
+
 				if (cIn == '\0')
-	/**
+
-	 * Expand environment variables in text
+					fprintf(stderr, "error: missing closing parenthesis.\n");
-	 * @param path input path string
+					outputStr[outIndex] = '\0';
-	 * @return expanded path string
+					return -1;
-	 */
+
-	public static String expand(String path)
+				else if (cIn == '{')
 				{
-		return expand(path, null, true, false);
+					fprintf(stderr, "error: bad substitution.\n");
-	}
+					outputStr[outIndex] = '\0';
 					return -1;
-	/**
+
-	 * VariablePath test method
+
-	 * @param args path string
+			else
-	 */
+
-	public static void main(String[] args)
+				// check for the pattern [0-9]+|[A-Za-z_][0-9A-Za-z_]*
 				if ((isdigit(str[varStartIndex]) != 0))
-		if (args.length > 0)
+
 					isInVariable = (isdigit(cIn) != 0);
-			try
+
 				else
-				String path = args[0];
+
-				System.out.println("Input : " + path);
+					isInVariable = ((isalnum(cIn) != 0) || cIn == '_');
-				System.out.println("Output: " + VariablePath.expand(path));
+
 			}
-			catch (Exception e)
+
 			// reached to end of variable
-				e.printStackTrace();
+			if (!isInVariable)
 			{
 				// get variable name
 				varNameLength = inIndex - varStartIndex;
 				varName = (char*) malloc(varNameLength + 1);
-			System.out.println("Usage: VariablePath PathString");
+				memcpy(varName, &str[varStartIndex], varNameLength);
 				varName[varNameLength] = '\0';
-	}
+
 				if (varName[0] != '\0')
 				{
 					// expand a variable
 					varValue = getenv(varName);
 					if (varValue != NULL)
 					{
 						varValueLength = strlen(varValue);
 						if (outIndex + varValueLength <= bufferSize)
 						{
 							memcpy(&outputStr[outIndex], varValue, varValueLength);
 							outIndex += varValueLength;
 						}
 						else
 						{
 							memcpy(&outputStr[outIndex], varValue, bufferSize - outIndex);
 							outIndex = bufferSize;
 						}
 
 						if (outIndex == bufferSize)
 						{
 							outputStr[bufferSize - 1] = '\0';
 							outIndex = bufferSize + 1;
 							break;
 						}
 					}
 					else
 					{
 						fprintf(stderr, "error: ${%s} is not defined.\n", varName);
 						outputStr[outIndex] = '\0';
 						return -1;
 					}
 
 					if (!hasParenthesis)
 					{
 						// redo the same character
 						inIndex--;
 						continue;
 					}
 				}
 				else
 				{
 					// not a variable
 					if (hasParenthesis)
 					{
 						fprintf(stderr, "error: variable name must not be empty.\n");
 						outputStr[outIndex] = '\0';
 						return -1;
 					}
 					else
 					{
 						outputStr[outIndex] = '$';
 						outIndex++;
 
 						if (outIndex < bufferSize)
 						{
 							outputStr[outIndex] = cIn;
 							outIndex++;
 						}
 					}
 				}
 			}
 		}
 		else
 		{
 			if (cIn == '$')
 			{
 				// start of a variable
 				isInVariable = true;
 
 				// check if it has a parenthesis
 				if (cNext == '{')
 				{
 					hasParenthesis = true;
 					inIndex++;
 				}
 				else
 				{
 					hasParenthesis = false;
 				}
 				varStartIndex = inIndex + 1;
 			}
 			else
 			{
 				// plain string
 				outputStr[outIndex] = cIn;
 				outIndex++;
 			}
 		}
 
 #ifdef MS932_SUPPORT
 		// check for the lead-byte of MS932 (Windows-31J)
 		if ((cIn >= 0x81 && cIn <= 0x9f) || (cIn >= 0xe0 && cIn <= 0xfc))
 		{
 			// check for the trailer-byte as well
 			if ((cNext >= 0x40 && cNext <= 0x7e) || (cNext >= 0x80 && cNext <= 0xfc))
 			{
 				if (!isInVariable)
 				{
 					if (outIndex + 1 < bufferSize)
 					{
 						outputStr[outIndex] = cNext;
 					}
 					else
 					{
 						outputStr[outIndex - 1] = '\0';
 					}
 					outIndex++;
 				}
 				inIndex++;
 			}
 		}
 #endif
 	} while (str[inIndex++] != '\0');
 	return outIndex - 1;
 }
 
 // test routine
 int main(int argc, char *argv[])
 {
 	char s[4096];
 	char *pat;
 	int ret;
 
 	pat = "HOME";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "$HOME";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "${HOME}";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "${HOME!}";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "$HOME!";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "$HOME$HOME";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "$123ABC";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "$";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "${";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "${{";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "$}";
 	ret = ExpandEnvironmentVariables(pat, s, sizeof(s));
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "$NOT_DEFINED";
 	ret = ExpandEnvironmentVariables(pat, s, 8);
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	pat = "ABCDEFG$HOME";
 	ret = ExpandEnvironmentVariables(pat, s, 8);
 	printf("\"%s\" -> \"%s\" (%d)\n\n", pat, s, ret);
 
 	return 0;
 }