diff options
Diffstat (limited to 'src/plugins/preflighting/src/com/motorolamobility/preflighting/internal/commandinput/CommandLineInputProcessor.java')
| -rw-r--r-- | src/plugins/preflighting/src/com/motorolamobility/preflighting/internal/commandinput/CommandLineInputProcessor.java | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/src/plugins/preflighting/src/com/motorolamobility/preflighting/internal/commandinput/CommandLineInputProcessor.java b/src/plugins/preflighting/src/com/motorolamobility/preflighting/internal/commandinput/CommandLineInputProcessor.java new file mode 100644 index 0000000..293bc49 --- /dev/null +++ b/src/plugins/preflighting/src/com/motorolamobility/preflighting/internal/commandinput/CommandLineInputProcessor.java @@ -0,0 +1,230 @@ +/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.motorolamobility.preflighting.internal.commandinput;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.eclipse.osgi.util.NLS;
+
+import com.motorolamobility.preflighting.core.validation.ComplexParameter;
+import com.motorolamobility.preflighting.core.validation.Parameter;
+import com.motorolamobility.preflighting.i18n.PreflightingNLS;
+import com.motorolamobility.preflighting.internal.commandinput.exception.ParameterParseException;
+
+/**
+ * Process command line commands below:
+ */
+public class CommandLineInputProcessor
+{
+ /**
+ * White space character
+ */
+ private static final String WHITE_SPACE = " "; //$NON-NLS-1$
+
+ /**
+ * Simple parameter marker character
+ */
+ private static final String PARAMETER_MARKER = "-"; //$NON-NLS-1$
+
+ /**
+ * Simple parameter separator
+ */
+ private static final String COMPLEX_PARAMETER_SEPARATOR = "="; //$NON-NLS-1$
+
+ /**
+ *
+ * @param params
+ * @return
+ * @throws ParameterParseException
+ */
+ public List<Parameter> processCommandLine(String params) throws ParameterParseException
+ {
+ // Parse command line arguments and create parameters
+ List<Parameter> commandLineParameters = new ArrayList<Parameter>();
+
+ // if no parameters were passed, assume help will be printed
+ if (params.length() == 0)
+ {
+ Parameter helpParameter =
+ new Parameter(ApplicationParameterInterpreter.PARAM_HELP, null);
+ commandLineParameters.add(helpParameter);
+ }
+ else
+ {
+ // find the pattern " -", which is expected to separate each parameter
+ String regex = "((?!(\\s+" + PARAMETER_MARKER + ")).)*"; //$NON-NLS-1$ //$NON-NLS-2$
+ Pattern pat = Pattern.compile(regex);
+ Matcher matcher = pat.matcher(params);
+ Parameter commandLineparameter = null;
+
+ // for each parameter part found, process it
+ while (matcher.find())
+ {
+ String parameterValues = params.substring(matcher.start(), matcher.end());
+
+ if (parameterValues.length() > 0)
+ {
+ commandLineparameter = getCommandLineParameter(parameterValues);
+ commandLineParameters.add(commandLineparameter);
+ }
+ }
+ }
+ return commandLineParameters;
+ }
+
+ /**
+ * Gets a parameter from command line. Command line arguments are passed to the
+ * application like this: -arg foo bar -c check1 name1=val1 name2=val2
+ *
+ * The parameter for this example is:
+ * name = arg
+ * values = foo, bar
+ *
+ * @param parameterValues String containing the parameter and its values. Eg: -arg foo bar
+ * @return And instance of object Parameter
+ * @throws ParameterParseException
+ */
+ private Parameter getCommandLineParameter(String parameterValues)
+ throws ParameterParseException
+ {
+
+ Parameter parameter = null;
+
+ if (parameterValues.indexOf(COMPLEX_PARAMETER_SEPARATOR) == -1)
+ {
+
+ // Its a simple parameter, example: -param1 value1 or example: -param2
+ parameter = getParameterFromCommandLine(parameterValues);
+
+ }
+ else
+ {
+ // Its a complex parameter, example: -c checker1 file=C:\arg.txt version=2
+ parameter = getComplexParameterFromCommandLine(parameterValues);
+ }
+
+ return parameter;
+ }
+
+ /**
+ * Get a complex parameter from command line. Example: -c checker1 param1=val1 param2=var2
+ * @param values String[] containing the complex parameter. For example, for command line -c checker1 param1=val1 param2=var2
+ * the contents of values are: [[c] [check1] [param1=val1] [param2=val2]]
+ * @return Instance of Parameter, containing a ComplexParameter
+ * @throws ParameterParseException
+ */
+ private Parameter getComplexParameterFromCommandLine(String parameterValues)
+ throws ParameterParseException
+ {
+ // complex parameter example: -c checker param1=val1 param2=val2
+ ComplexParameter parameter = new ComplexParameter();
+
+ String[] values = parameterValues.split(WHITE_SPACE);
+
+ if (values.length < 3)
+ {
+ throw new ParameterParseException(NLS.bind(
+ PreflightingNLS.CommandLineInputProcessor_IncorrectSyntax, parameterValues));
+ }
+ else
+ {
+
+ String parameterType = values[0];
+
+ if (parameterType.startsWith(PARAMETER_MARKER))
+ {
+ parameterType = parameterType.substring(1);
+ }
+ parameter.setParameterType(parameterType);
+ parameter.setValue(values[1]);
+
+ int lenghtToCut = values[0].length() + values[1].length() + 2;
+ String subParameters = parameterValues.substring(lenghtToCut);
+
+ String[] checkSyntax = subParameters.split("\\s*\\w+\\s*" + COMPLEX_PARAMETER_SEPARATOR //$NON-NLS-1$
+ + "\\s*\\w+\\s*"); //$NON-NLS-1$
+ if (checkSyntax.length > 0)
+ {
+ throw new ParameterParseException(NLS.bind(
+ PreflightingNLS.CommandLineInputProcessor_IncorrectSyntax, parameterValues));
+ }
+
+ Pattern pat = Pattern.compile("\\w+\\s*" + COMPLEX_PARAMETER_SEPARATOR + "\\s*\\w+"); //$NON-NLS-1$ //$NON-NLS-2$
+ Matcher matcher = pat.matcher(subParameters);
+
+ while (matcher.find())
+ {
+ String part = subParameters.substring(matcher.start(), matcher.end());
+ String[] pair = part.split(COMPLEX_PARAMETER_SEPARATOR);
+ parameter.addParameter(pair[0].trim(), pair[1].trim());
+ }
+ }
+ return parameter;
+ }
+
+ /**
+ * Get a parameter from command line (example -param value), passed as a String[].
+ * @param parameterValues parameter values
+ * @return Instance of Parameter
+ * @throws ParameterParseException
+ */
+ private Parameter getParameterFromCommandLine(String parameterValues)
+ throws ParameterParseException
+ {
+ Parameter parameter = new Parameter();
+
+ // find first white space to separate tag from value
+ int indexOfFirstWhiteSpace = parameterValues.indexOf(WHITE_SPACE);
+ String parameterType = null;
+ String parameterValue = null;
+
+ // if there is no whitespace, everything is the parameter value necessary
+ if (indexOfFirstWhiteSpace >= 0)
+ {
+ // substring original string from character 1 (skip "-"), to first
+ // whitespace character
+ parameterType = parameterValues.substring(1, indexOfFirstWhiteSpace);
+ // retrieve the rest of the original string (starting from first whitespace)
+ // as the value for the parameter
+ parameterValue = parameterValues.substring(indexOfFirstWhiteSpace).trim();
+ }
+ else
+ {
+ // skip "-"
+ parameterType = parameterValues.substring(1);
+ }
+
+ // check for unexpected format (both parts of the parameter empty)
+ if (((parameterValue == null) || (parameterValue.length() == 0))
+ && ((parameterType == null) || (parameterType.length() == 0)))
+ {
+ throw new ParameterParseException(NLS.bind(
+ PreflightingNLS.CommandLineInputProcessor_IncorrectSyntax, parameterValues));
+ }
+
+ // store parameter type and value
+ parameter.setParameterType(parameterType);
+ if ((parameterValue != null) && (parameterValue.length() > 0))
+ {
+ parameter.setValue(parameterValue);
+ }
+
+ return parameter;
+ }
+}
|