Reverted to rev 1.4 keys had been mistakenly deleted.
[phpeclipse.git] / net.sourceforge.phpeclipse.externaltools / src / net / sourceforge / phpdt / externaltools / model / ToolUtil.java
1 package net.sourceforge.phpdt.externaltools.model;
2
3 /**********************************************************************
4  Copyright (c) 2002 IBM Corp. and others. All rights reserved.
5  This file is made available under the terms of the Common Public License v1.0
6  which accompanies this distribution, and is available at
7  http://www.eclipse.org/legal/cpl-v10.html
8  �
9  Contributors:
10  **********************************************************************/
11
12 import java.util.ArrayList;
13
14 import net.sourceforge.phpdt.externaltools.internal.model.ExternalToolsModelMessages;
15 import net.sourceforge.phpdt.externaltools.internal.registry.ArgumentVariable;
16 import net.sourceforge.phpdt.externaltools.internal.registry.ArgumentVariableRegistry;
17 import net.sourceforge.phpdt.externaltools.internal.registry.PathLocationVariable;
18 import net.sourceforge.phpdt.externaltools.internal.registry.PathLocationVariableRegistry;
19 import net.sourceforge.phpdt.externaltools.variable.ExpandVariableContext;
20 import net.sourceforge.phpeclipse.externaltools.ExternalToolsPlugin;
21
22 import org.eclipse.core.runtime.IPath;
23 import org.eclipse.core.runtime.MultiStatus;
24
25 /**
26  * General utility class dealing with external tools
27  */
28 public final class ToolUtil {
29         /**
30          * Argument parsing constants
31          */
32         private static final char ARG_DELIMITER = ' '; //$NON-NLS-1$
33
34         private static final char ARG_DBL_QUOTE = '"'; //$NON-NLS-1$
35
36         /**
37          * Variable tag indentifiers
38          */
39         private static final char VAR_TAG_START_CHAR1 = '$'; //$NON-NLS-1$
40
41         private static final char VAR_TAG_START_CHAR2 = '{'; //$NON-NLS-1$
42
43         private static final char VAR_TAG_END_CHAR1 = '}'; //$NON-NLS-1$
44
45         private static final String VAR_TAG_START = "${"; //$NON-NLS-1$
46
47         private static final String VAR_TAG_END = "}"; //$NON-NLS-1$
48
49         private static final String VAR_TAG_SEP = ":"; //$NON-NLS-1$
50
51         /**
52          * No instances allowed
53          */
54         private ToolUtil() {
55                 super();
56         }
57
58         /**
59          * Builds a variable tag that will be auto-expanded before the tool is run.
60          * 
61          * @param varName
62          *            the name of a known variable (one of the VAR_* constants for
63          *            instance)
64          * @param varArgument
65          *            an optional argument for the variable, <code>null</code> if
66          *            none
67          */
68         public static String buildVariableTag(String varName, String varArgument) {
69                 StringBuffer buf = new StringBuffer();
70                 buildVariableTag(varName, varArgument, buf);
71                 return buf.toString();
72         }
73
74         /**
75          * Builds a variable tag that will be auto-expanded before the tool is run.
76          * 
77          * @param varName
78          *            the name of a known variable (one of the VAR_* constants for
79          *            instance)
80          * @param varArgument
81          *            an optional argument for the variable, <code>null</code> if
82          *            none
83          * @param buffer
84          *            the buffer to write the constructed variable tag
85          */
86         public static void buildVariableTag(String varName, String varArgument,
87                         StringBuffer buffer) {
88                 buffer.append(VAR_TAG_START);
89                 buffer.append(varName);
90                 if (varArgument != null && varArgument.length() > 0) {
91                         buffer.append(VAR_TAG_SEP);
92                         buffer.append(varArgument);
93                 }
94                 buffer.append(VAR_TAG_END);
95         }
96
97         /**
98          * Expands all the variables found in an individual argument text.
99          * 
100          * @param argument
101          *            one of the argument text in the list of arguments
102          * @param context
103          *            the context to use for expanding variables
104          * @param status
105          *            multi status to report any problems expanding variables
106          * @return the argument text with all variables expanded, or
107          *         <code>null</code> if not possible
108          */
109         public static String expandArgument(String argument,
110                         ExpandVariableContext context, MultiStatus status) {
111                 StringBuffer buffer = new StringBuffer();
112
113                 int start = 0;
114                 while (true) {
115                         VariableDefinition varDef = extractVariableTag(argument, start);
116
117                         // No more variables found...
118                         if (varDef.start == -1) {
119                                 if (start == 0)
120                                         buffer.append(argument);
121                                 else
122                                         buffer.append(argument.substring(start));
123                                 break;
124                         }
125
126                         // Invalid variable format
127                         if (varDef.end == -1 || varDef.name == null
128                                         || varDef.name.length() == 0) {
129                                 String msg = ExternalToolsModelMessages
130                                                 .getString("ToolUtil.argumentVarFormatWrong"); //$NON-NLS-1$
131                                 status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
132                                 return null;
133                         }
134
135                         // Copy text between start and variable.
136                         if (varDef.start > start)
137                                 buffer.append(argument.substring(start, varDef.start));
138                         start = varDef.end;
139
140                         // Lookup the variable if it exist
141                         ArgumentVariableRegistry registry;
142                         registry = ExternalToolsPlugin.getDefault()
143                                         .getArgumentVariableRegistry();
144                         ArgumentVariable variable = registry
145                                         .getArgumentVariable(varDef.name);
146                         if (variable == null) {
147                                 String msg = ExternalToolsModelMessages
148                                                 .format(
149                                                                 "ToolUtil.argumentVarMissing", new Object[] { varDef.name }); //$NON-NLS-1$
150                                 status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
151                                 return null;
152                         }
153
154                         // Expand the variable as text if possible
155                         String text = variable.getExpander().getText(varDef.name,
156                                         varDef.argument, context);
157                         if (text == null) {
158                                 String msg = ExternalToolsModelMessages
159                                                 .format(
160                                                                 "ToolUtil.argumentVarExpandFailed", new Object[] { varDef.name }); //$NON-NLS-1$
161                                 status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
162                                 return null;
163                         }
164                         buffer.append(text);
165                 }
166
167                 return buffer.toString();
168         }
169
170         /**
171          * Returns a list of individual arguments where all variables have been
172          * expanded.
173          * 
174          * @param arguments
175          *            the arguments with leading and trailing spaces already
176          *            removed.
177          * @param context
178          *            the context used to expand the variable(s)
179          * @param status
180          *            multi status to report any problems expanding variables
181          * @return the list of individual arguments where some elements in the list
182          *         maybe <code>null</code> if problems expanding variable(s).
183          */
184         public static String[] expandArguments(String arguments,
185                         ExpandVariableContext context, MultiStatus status) {
186                 if (arguments == null || arguments.length() == 0)
187                         return new String[0];
188
189                 String[] argList = parseArgumentsIntoList(arguments);
190                 for (int i = 0; i < argList.length; i++)
191                         argList[i] = expandArgument(argList[i], context, status);
192
193                 return argList;
194         }
195
196         /**
197          * Returns the expanded directory location if represented by a directory
198          * variable. Otherwise, the directory location given is return unless an
199          * unknown variable was detected.
200          * 
201          * @param dirLocation
202          *            a directory location either as a path or a variable with
203          *            leading and trailing spaces already removed.
204          * @param context
205          *            the context used to expand the variable
206          * @param status
207          *            multi status to report any problems expanding variables
208          * @return the directory location as a string or <code>null</code> if not
209          *         possible
210          */
211         public static String expandDirectoryLocation(String dirLocation,
212                         ExpandVariableContext context, MultiStatus status) {
213                 if (dirLocation == null || dirLocation.length() == 0)
214                         return ""; //$NON-NLS-1$
215
216                 VariableDefinition varDef = extractVariableTag(dirLocation, 0);
217                 // Return if no variable found
218                 if (varDef.start < 0)
219                         return dirLocation;
220
221                 // Disallow text before/after variable
222                 if (varDef.start != 0
223                                 || (varDef.end < dirLocation.length() && varDef.end != -1)) {
224                         String msg = ExternalToolsModelMessages
225                                         .getString("ToolUtil.dirLocVarBetweenText"); //$NON-NLS-1$
226                         status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
227                         return null;
228                 }
229
230                 // Invalid variable format
231                 if (varDef.name == null || varDef.name.length() == 0
232                                 || varDef.end == -1) {
233                         String msg = ExternalToolsModelMessages
234                                         .getString("ToolUtil.dirLocVarFormatWrong"); //$NON-NLS-1$
235                         status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
236                         return null;
237                 }
238
239                 // Lookup the variable if it exist
240                 PathLocationVariableRegistry registry;
241                 registry = ExternalToolsPlugin.getDefault()
242                                 .getDirectoryLocationVariableRegistry();
243                 PathLocationVariable variable = registry
244                                 .getPathLocationVariable(varDef.name);
245                 if (variable == null) {
246                         String msg = ExternalToolsModelMessages.format(
247                                         "ToolUtil.dirLocVarMissing", new Object[] { varDef.name }); //$NON-NLS-1$
248                         status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
249                         return null;
250                 }
251
252                 // Expand the variable into a IPath if possible
253                 IPath path = variable.getExpander().getPath(varDef.name,
254                                 varDef.argument, context);
255                 if (path == null) {
256                         String msg = ExternalToolsModelMessages
257                                         .format(
258                                                         "ToolUtil.dirLocVarExpandFailed", new Object[] { varDef.name }); //$NON-NLS-1$
259                         status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
260                         return null;
261                 }
262
263                 return path.toOSString();
264         }
265
266         /**
267          * Returns the expanded file location if represented by a file variable.
268          * Otherwise, the file location given is return unless an unknown variable
269          * was detected.
270          * 
271          * @param fileLocation
272          *            a file location either as a path or a variable with leading
273          *            and trailing spaces already removed.
274          * @param context
275          *            the context used to expand the variable
276          * @param status
277          *            multi status to report any problems expanding variables
278          * @return the file location as a string or <code>null</code> if not
279          *         possible
280          */
281         public static String expandFileLocation(String fileLocation,
282                         ExpandVariableContext context, MultiStatus status) {
283                 if (fileLocation == null || fileLocation.length() == 0)
284                         return ""; //$NON-NLS-1$
285
286                 VariableDefinition varDef = extractVariableTag(fileLocation, 0);
287                 // Return if no variable found
288                 if (varDef.start < 0)
289                         return fileLocation;
290
291                 // Disallow text before/after variable
292                 if (varDef.start != 0
293                                 || (varDef.end < fileLocation.length() && varDef.end != -1)) {
294                         String msg = ExternalToolsModelMessages
295                                         .getString("ToolUtil.fileLocVarBetweenText"); //$NON-NLS-1$
296                         status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
297                         return null;
298                 }
299
300                 // Invalid variable format
301                 if (varDef.name == null || varDef.name.length() == 0
302                                 || varDef.end == -1) {
303                         String msg = ExternalToolsModelMessages
304                                         .getString("ToolUtil.fileLocVarFormatWrong"); //$NON-NLS-1$
305                         status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
306                         return null;
307                 }
308
309                 // Lookup the variable if it exist
310                 PathLocationVariableRegistry registry;
311                 registry = ExternalToolsPlugin.getDefault()
312                                 .getFileLocationVariableRegistry();
313                 PathLocationVariable variable = registry
314                                 .getPathLocationVariable(varDef.name);
315                 if (variable == null) {
316                         String msg = ExternalToolsModelMessages.format(
317                                         "ToolUtil.fileLocVarMissing", new Object[] { varDef.name }); //$NON-NLS-1$
318                         status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
319                         return null;
320                 }
321
322                 // Expand the variable into a IPath if possible
323                 IPath path = variable.getExpander().getPath(varDef.name,
324                                 varDef.argument, context);
325                 if (path == null) {
326                         String msg = ExternalToolsModelMessages
327                                         .format(
328                                                         "The variable {0} with argument {1} could not be expanded to a valid path.",
329                                                         new Object[] { varDef.name, varDef.argument });
330                         status.merge(ExternalToolsPlugin.newErrorStatus(msg, null));
331                         return null;
332                 }
333
334                 return path.toString();
335         }
336
337         /**
338          * Extracts from the source text the variable tag's name and argument.
339          * 
340          * @param text
341          *            the source text to parse for a variable tag
342          * @param start
343          *            the index in the string to start the search
344          * @return the variable definition
345          */
346         public static VariableDefinition extractVariableTag(String text, int start) {
347                 VariableDefinition varDef = new VariableDefinition();
348
349                 varDef.start = text.indexOf(VAR_TAG_START, start);
350                 if (varDef.start < 0)
351                         return varDef;
352                 start = varDef.start + VAR_TAG_START.length();
353
354                 int end = text.indexOf(VAR_TAG_END, start);
355                 if (end < 0)
356                         return varDef;
357                 varDef.end = end + VAR_TAG_END.length();
358                 if (end == start)
359                         return varDef;
360
361                 int mid = text.indexOf(VAR_TAG_SEP, start);
362                 if (mid < 0 || mid > end) {
363                         varDef.name = text.substring(start, end);
364                 } else {
365                         if (mid > start)
366                                 varDef.name = text.substring(start, mid);
367                         mid = mid + VAR_TAG_SEP.length();
368                         if (mid < end)
369                                 varDef.argument = text.substring(mid, end);
370                 }
371
372                 return varDef;
373         }
374
375         /**
376          * Parses the argument text into an array of individual arguments using the
377          * space character as the delimiter. An individual argument containing
378          * spaces must have a double quote (") at the start and end. Two double
379          * quotes together is taken to mean an embedded double quote in the argument
380          * text. Variables are treated as a single unit and therefore spaces and
381          * double quotes inside a variable are copied as is and not parsed.
382          * 
383          * @param arguments
384          *            the arguments as one string
385          * @return the array of arguments
386          */
387         public static String[] parseArgumentsIntoList(String arguments) {
388                 if (arguments == null || arguments.length() == 0)
389                         return new String[0];
390
391                 ArrayList list = new ArrayList(10);
392                 boolean inQuotes = false;
393                 boolean inVar = false;
394                 int start = 0;
395                 int end = arguments.length();
396                 StringBuffer buffer = new StringBuffer(end);
397
398                 while (start < end) {
399                         char ch = arguments.charAt(start);
400                         start++;
401
402                         switch (ch) {
403                         case ARG_DELIMITER:
404                                 if (inQuotes || inVar) {
405                                         buffer.append(ch);
406                                 } else {
407                                         if (buffer.length() > 0) {
408                                                 list.add(buffer.toString());
409                                                 buffer.setLength(0);
410                                         }
411                                 }
412                                 break;
413
414                         case ARG_DBL_QUOTE:
415                                 if (inVar) {
416                                         buffer.append(ch);
417                                 } else {
418                                         if (start < end) {
419                                                 if (arguments.charAt(start) == ARG_DBL_QUOTE) {
420                                                         // Two quotes together represents one quote
421                                                         buffer.append(ch);
422                                                         start++;
423                                                 } else {
424                                                         inQuotes = !inQuotes;
425                                                 }
426                                         } else {
427                                                 // A lone quote at the end, just drop it.
428                                                 inQuotes = false;
429                                         }
430                                 }
431                                 break;
432
433                         case VAR_TAG_START_CHAR1:
434                                 buffer.append(ch);
435                                 if (!inVar && start < end) {
436                                         if (arguments.charAt(start) == VAR_TAG_START_CHAR2) {
437                                                 buffer.append(VAR_TAG_START_CHAR2);
438                                                 inVar = true;
439                                                 start++;
440                                         }
441                                 }
442                                 break;
443
444                         case VAR_TAG_END_CHAR1:
445                                 buffer.append(ch);
446                                 inVar = false;
447                                 break;
448
449                         default:
450                                 buffer.append(ch);
451                                 break;
452                         }
453
454                 }
455
456                 if (buffer.length() > 0)
457                         list.add(buffer.toString());
458
459                 String[] results = new String[list.size()];
460                 list.toArray(results);
461                 return results;
462         }
463
464         /**
465          * Structure to represent a variable definition within a source string.
466          */
467         public static final class VariableDefinition {
468                 /**
469                  * Index in the source text where the variable started or
470                  * <code>-1</code> if no valid variable start tag identifier found.
471                  */
472                 public int start = -1;
473
474                 /**
475                  * Index in the source text of the character following the end of the
476                  * variable or <code>-1</code> if no valid variable end tag found.
477                  */
478                 public int end = -1;
479
480                 /**
481                  * The variable's name found in the source text, or <code>null</code>
482                  * if no valid variable found.
483                  */
484                 public String name = null;
485
486                 /**
487                  * The variable's argument found in the source text, or
488                  * <code>null</code> if no valid variable found or if the variable did
489                  * not specify an argument
490                  */
491                 public String argument = null;
492
493                 /**
494                  * Create an initialized variable definition.
495                  */
496                 private VariableDefinition() {
497                         super();
498                 }
499
500                 /**
501                  * Create an initialized variable definition.
502                  */
503                 private VariableDefinition(int start, int end) {
504                         super();
505                         this.start = start;
506                         this.end = end;
507                 }
508         }
509 }