| /******************************************************************************* |
| * Copyright (c) 2008, 2017 xored software, Inc. and others. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * xored software, Inc. - initial API and Implementation (Andrei Sobolev) |
| *******************************************************************************/ |
| package org.eclipse.dltk.tcl.parser; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.dltk.tcl.ast.ArgumentMatch; |
| import org.eclipse.dltk.tcl.ast.AstFactory; |
| import org.eclipse.dltk.tcl.ast.ComplexString; |
| import org.eclipse.dltk.tcl.ast.Node; |
| import org.eclipse.dltk.tcl.ast.Script; |
| import org.eclipse.dltk.tcl.ast.StringArgument; |
| import org.eclipse.dltk.tcl.ast.Substitution; |
| import org.eclipse.dltk.tcl.ast.TclArgument; |
| import org.eclipse.dltk.tcl.ast.TclArgumentList; |
| import org.eclipse.dltk.tcl.ast.TclCommand; |
| import org.eclipse.dltk.tcl.ast.VariableReference; |
| import org.eclipse.dltk.tcl.definitions.Argument; |
| import org.eclipse.dltk.tcl.definitions.Command; |
| import org.eclipse.dltk.tcl.definitions.ComplexArgument; |
| import org.eclipse.dltk.tcl.definitions.Constant; |
| import org.eclipse.dltk.tcl.definitions.Group; |
| import org.eclipse.dltk.tcl.definitions.Switch; |
| import org.eclipse.dltk.tcl.definitions.TypedArgument; |
| import org.eclipse.dltk.tcl.internal.parser.raw.BracesSubstitution; |
| import org.eclipse.dltk.tcl.internal.parser.raw.CommandSubstitution; |
| import org.eclipse.dltk.tcl.internal.parser.raw.QuotesSubstitution; |
| import org.eclipse.dltk.tcl.internal.parser.raw.SimpleTclParser; |
| import org.eclipse.dltk.tcl.internal.parser.raw.TclParseException; |
| import org.eclipse.dltk.tcl.internal.parser.raw.TclScript; |
| import org.eclipse.dltk.tcl.internal.parser.raw.TclWord; |
| import org.eclipse.emf.common.util.EList; |
| |
| public class TclParserUtils implements ITclParserOptions { |
| |
| public static final Pattern VERSION_PATTERN = Pattern |
| .compile("([\\(\\[][^\\(\\)]*[\\)\\]])"); //$NON-NLS-1$ |
| public static final Pattern INTERVAL_PATTERN = Pattern |
| .compile("([\\(\\[])(.*)[:;](.*)([\\)\\]])"); //$NON-NLS-1$ |
| public static final Pattern VALID_VERSION_PATTERN = Pattern.compile( |
| "([\\(\\[](([0-9]+(\\.[0-9]+)*)|-)[;:](([0-9]+(\\.[0-9]+)*)|-)[\\)\\]]\\s*)*"); //$NON-NLS-1$ |
| |
| public static boolean isVersionValid(String version) { |
| if (version == null || version.length() == 0) |
| return true; |
| version = version.trim(); |
| Matcher matcher = VALID_VERSION_PATTERN.matcher(version); |
| return matcher.matches(); |
| } |
| |
| public static boolean parseVersion(String version, String currentVersion) { |
| |
| if (version == null || version.length() == 0) |
| return false; |
| |
| Matcher versionMatcher = VERSION_PATTERN.matcher(version); |
| |
| boolean isValid = false; |
| |
| while (versionMatcher.find()) { |
| |
| boolean isIntervalValid = true; |
| |
| String interval = versionMatcher.group(1); |
| Matcher intervalMatcher = INTERVAL_PATTERN.matcher(interval); |
| |
| while (intervalMatcher.find()) { |
| |
| String lowerType = intervalMatcher.group(1); |
| String lowerVersion = intervalMatcher.group(2); |
| String upperVersion = intervalMatcher.group(3); |
| String upperType = intervalMatcher.group(4); |
| |
| if (!lowerVersion.equals("-")) { //$NON-NLS-1$ |
| if (lowerType.equals("(") //$NON-NLS-1$ |
| && compareVersions(currentVersion, |
| lowerVersion) <= 0) { |
| isIntervalValid = false; |
| continue; |
| } |
| |
| if (lowerType.equals("[") //$NON-NLS-1$ |
| && compareVersions(currentVersion, |
| lowerVersion) < 0) { |
| isIntervalValid = false; |
| continue; |
| } |
| } |
| if (!upperVersion.equals("-")) { //$NON-NLS-1$ |
| if (upperType.equals(")") //$NON-NLS-1$ |
| && compareVersions(currentVersion, |
| upperVersion) >= 0) { |
| isIntervalValid = false; |
| continue; |
| } |
| |
| if (upperType.equals("]") //$NON-NLS-1$ |
| && compareVersions(currentVersion, |
| upperVersion) > 0) { |
| isIntervalValid = false; |
| continue; |
| } |
| } |
| } |
| if (isIntervalValid) { |
| isValid = true; |
| break; |
| } |
| } |
| return isValid; |
| } |
| |
| public static int compareVersions(String v1, String v2) { |
| String[] splited1 = v1.split("\\."); //$NON-NLS-1$ |
| String[] splited2 = v2.split("\\."); //$NON-NLS-1$ |
| |
| int res = splited1.length - splited2.length; |
| |
| int min = (splited1.length < splited2.length) ? splited1.length |
| : splited2.length; |
| |
| for (int i = 0; i < min; i++) { |
| if (Integer.parseInt(splited1[i]) > Integer.parseInt(splited2[i])) |
| return 1; |
| if (Integer.parseInt(splited1[i]) < Integer.parseInt(splited2[i])) |
| return -1; |
| } |
| return res; |
| } |
| |
| public static List<TclArgument> parseCommandArguments(int offset, |
| String content, List<Integer> blockArguments) { |
| List<TclArgument> results = new ArrayList<>(); |
| try { |
| AstFactory factory = AstFactory.eINSTANCE; |
| SimpleTclParser parser = new SimpleTclParser(); |
| parser.setSkipComments(false); |
| TclScript script; |
| try { |
| script = parser.parse(content); |
| } catch (TclParseException e) { |
| e.printStackTrace(); |
| return results; |
| } |
| List<org.eclipse.dltk.tcl.internal.parser.raw.TclCommand> commands = script |
| .getCommands(); |
| for (int i = 0; i < commands.size(); i++) { |
| org.eclipse.dltk.tcl.internal.parser.raw.TclCommand command = commands |
| .get(i); |
| for (final TclWord word : command.getWords()) { |
| |
| final TclArgument exp; |
| Object o = word.getContents().get(0); |
| if (o instanceof QuotesSubstitution) { |
| QuotesSubstitution qs = (QuotesSubstitution) o; |
| |
| StringArgument literal = factory.createStringArgument(); |
| literal.setStart(offset + qs.getStart()); |
| literal.setEnd(offset + qs.getEnd() + 1); |
| final String value = content.substring(word.getStart(), |
| word.getEnd() + 1); |
| literal.setValue(value); |
| literal.setRawValue(value); |
| exp = literal; |
| } else if (o instanceof BracesSubstitution) { |
| BracesSubstitution bs = (BracesSubstitution) o; |
| |
| StringArgument block = factory.createStringArgument(); |
| block.setStart(offset + bs.getStart()); |
| block.setEnd(offset + bs.getEnd() + 1); |
| final String value = content.substring(word.getStart(), |
| word.getEnd() + 1); |
| block.setValue(value); |
| block.setRawValue(value); |
| exp = block; |
| } else if (o instanceof CommandSubstitution |
| && word.getContents().size() == 1) { |
| CommandSubstitution bs = (CommandSubstitution) o; |
| |
| StringArgument bl = factory.createStringArgument(); |
| bl.setStart(offset + bs.getStart()); |
| bl.setEnd(offset + bs.getEnd() + 1); |
| final String value = content.substring(word.getStart(), |
| word.getEnd() + 1); |
| bl.setValue(value); |
| bl.setRawValue(value); |
| if (blockArguments != null) { |
| blockArguments.add(results.size()); |
| } |
| exp = bl; |
| } else { |
| StringArgument reference = factory |
| .createStringArgument(); |
| reference.setStart(offset + word.getStart()); |
| reference.setEnd(offset + word.getEnd() + 1); |
| final String value = content.substring(word.getStart(), |
| word.getEnd() + 1); |
| reference.setValue(value); |
| reference.setRawValue(value); |
| exp = reference; |
| } |
| results.add(exp); |
| } |
| } |
| return results; |
| } catch (StringIndexOutOfBoundsException bounds) { |
| return results; |
| } |
| } |
| |
| public static <T> void traverse(List<T> nodes, TclVisitor visitor) { |
| for (int i = 0; i < nodes.size(); i++) { |
| Node nde = (Node) nodes.get(i); |
| if (nde instanceof Script) { |
| Script script = (Script) nde; |
| if (visitor.visit(script)) { |
| traverse(script.getCommands(), visitor); |
| visitor.endVisit(script); |
| } |
| } else if (nde instanceof Substitution) { |
| Substitution substitution = (Substitution) nde; |
| if (visitor.visit(substitution)) { |
| traverse(substitution.getCommands(), visitor); |
| visitor.endVisit(substitution); |
| } |
| } else if (nde instanceof TclCommand) { |
| TclCommand command = (TclCommand) nde; |
| if (visitor.visit(command)) { |
| traverse(Collections.singletonList(command.getName()), |
| visitor); |
| traverse(command.getArguments(), visitor); |
| visitor.endVisit(command); |
| } |
| } else if (nde instanceof StringArgument) { |
| StringArgument argument = (StringArgument) nde; |
| if (visitor.visit(argument)) { |
| visitor.endVisit(argument); |
| } |
| } else if (nde instanceof TclArgumentList) { |
| TclArgumentList list = (TclArgumentList) nde; |
| if (visitor.visit(list)) { |
| traverse(list.getArguments(), visitor); |
| visitor.endVisit(list); |
| } |
| } else if (nde instanceof ComplexString) { |
| ComplexString list = (ComplexString) nde; |
| if (visitor.visit(list)) { |
| traverse(list.getArguments(), visitor); |
| visitor.endVisit(list); |
| } |
| } else if (nde instanceof VariableReference) { |
| VariableReference list = (VariableReference) nde; |
| if (visitor.visit(list)) { |
| TclArgument index = list.getIndex(); |
| if (index != null) { |
| traverse(Collections.singletonList(index), visitor); |
| } |
| visitor.endVisit(list); |
| } |
| } |
| } |
| } |
| |
| public static String getSynopsis(Command command) { |
| if (command == null) |
| return null; |
| List<StringBuilder> list = new ArrayList<>(); |
| StringBuilder synopsis = new StringBuilder(); |
| String name = command.getName(); |
| if (name != null && name.length() != 0) { |
| list.add(new StringBuilder(name)); |
| } else { |
| // TODO error : bad definition |
| } |
| for (int i = 0; i < command.getArguments().size(); i++) { |
| Argument arg = command.getArguments().get(i); |
| list = concatSynopsises(list, getSynopsisArgInfo(arg, i)); |
| } |
| boolean first = true; |
| for (StringBuilder str : list) { |
| if (!first) |
| synopsis.append("\n"); //$NON-NLS-1$ |
| else |
| first = false; |
| synopsis.append(str.toString()); |
| } |
| return synopsis.toString(); |
| } |
| |
| static final int SUBCOMMAND = 0; |
| static final int OPTIONS = 1; |
| static final int MODE = 2; |
| static final int REGULAR = 3; |
| |
| private static List<StringBuilder> getSynopsisArgInfo(Argument arg, |
| int pos) { |
| List<StringBuilder> list = new ArrayList<>(); |
| if (arg instanceof Constant) { |
| list.add(new StringBuilder(((Constant) arg).getName())); |
| } else if (arg instanceof TypedArgument) { |
| list.add(new StringBuilder(((TypedArgument) arg).getName())); |
| } else if (arg instanceof Group) { |
| String constant = ((Group) arg).getConstant(); |
| if (constant != null && constant.length() != 0) |
| list.add(new StringBuilder(constant)); |
| for (Argument sub : ((Group) arg).getArguments()) { |
| list = concatSynopsises(list, getSynopsisArgInfo(sub, pos + 1)); |
| } |
| } else if (arg instanceof ComplexArgument) { |
| for (Argument sub : ((ComplexArgument) arg).getArguments()) { |
| list = concatSynopsises(list, getSynopsisArgInfo(sub, pos + 1)); |
| } |
| for (StringBuilder sub : list) { |
| sub.insert(0, "{"); //$NON-NLS-1$ |
| sub.append("}"); //$NON-NLS-1$ |
| } |
| } else if (arg instanceof Switch) { |
| int type = REGULAR; |
| String constant = null; |
| if (((Switch) arg).getGroups() != null) { |
| constant = ((Switch) arg).getGroups().get(0).getConstant(); |
| if (constant != null && constant.length() != 0) { |
| if (constant.startsWith("-")) { //$NON-NLS-1$ |
| type = OPTIONS; |
| } else { |
| if (pos == 0) |
| type = SUBCOMMAND; |
| else |
| type = MODE; |
| } |
| } |
| } else { |
| // TODO bad definition |
| } |
| switch (type) { |
| case REGULAR: |
| if (arg.getLowerBound() == 0) { |
| list.add(new StringBuilder()); |
| } |
| case SUBCOMMAND: |
| for (Group group : ((Switch) arg).getGroups()) { |
| list.addAll(getSynopsisArgInfo(group, pos + 1)); |
| } |
| return list; |
| case OPTIONS: |
| case MODE: |
| boolean first = true; |
| StringBuilder options = new StringBuilder(); |
| options.append("<"); //$NON-NLS-1$ |
| for (Group group : ((Switch) arg).getGroups()) { |
| for (StringBuilder str : getSynopsisArgInfo(group, |
| pos + 1)) { |
| if (!first) |
| options.append("|"); //$NON-NLS-1$ |
| else |
| first = false; |
| options.append(str); |
| } |
| } |
| options.append(">"); //$NON-NLS-1$ |
| list.add(options); |
| } |
| } |
| for (StringBuilder res : list) { |
| if (arg.getUpperBound() == 0) { |
| // TODO error : bad definition |
| } else if (arg.getUpperBound() == -1) { |
| if (arg.getLowerBound() == 0) { |
| res.append(" ..."); //$NON-NLS-1$ |
| res.insert(0, "?"); //$NON-NLS-1$ |
| res.append("?"); //$NON-NLS-1$ |
| } else { |
| String value = res.toString(); |
| for (int i = 0; i < arg.getUpperBound() - 1; i++) |
| res.append(" ").append(value); //$NON-NLS-1$ |
| res.append(" ?").append(value).append(" ...?"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } else if (arg.getUpperBound() == 1) { |
| if (arg.getLowerBound() == 0) { |
| res.insert(0, "?"); //$NON-NLS-1$ |
| res.append("?"); //$NON-NLS-1$ |
| } |
| } else { |
| String value = res.toString(); |
| for (int i = 0; i < arg.getUpperBound(); i++) |
| res.append(" ").append(value); //$NON-NLS-1$ |
| } |
| } |
| return list; |
| } |
| |
| private static List<StringBuilder> concatSynopsises( |
| List<StringBuilder> prefixes, List<StringBuilder> ss) { |
| List<StringBuilder> newList = new ArrayList<>(); |
| if (prefixes.size() == 0) |
| return ss; |
| for (StringBuilder prefix : prefixes) { |
| for (StringBuilder s : ss) { |
| newList.add(new StringBuilder(prefix.length() + s.length() + 1) |
| .append(prefix).append(" ").append(s)); //$NON-NLS-1$ |
| } |
| } |
| return newList; |
| } |
| |
| /* |
| * static DefinitionsFactory factory = DefinitionsFactory.eINSTANCE; public |
| * Command getDefinition(String synopsis) { Command command = |
| * factory.createCommand(); StringTokenizer tokenizer = new |
| * StringTokenizer(synopsis); boolean first = true; while |
| * (tokenizer.hasMoreTokens()){ String token = tokenizer.nextToken(" "); if |
| * (first) { command.setName(token); first = false; } else { Argument arg = |
| * null; if (token.startsWith("?")){ if (token.endsWith("?")){ arg = |
| * factory.createTypedArgument(); arg.setLowerBound(0); |
| * ((TypedArgument)arg).setName(token.substring(1,token.length()-1)); } else |
| * { arg = factory.createGroup(); boolean isOver = false; while |
| * (tokenizer.hasMoreTokens() && !isOver){ String subToken = |
| * tokenizer.nextToken(" "); if (subToken.endsWith("?")){ subToken = |
| * subToken.substring(0,subToken.length()-1); if (subToken.equals("...")){ |
| * arg.setUpperBound(-1); break; } } } } } command.getArguments().add(arg); |
| * } |
| * |
| * } return command; } |
| */ |
| /** |
| * Return empty list if not matched. |
| * |
| * @param command |
| * @param name |
| * @return |
| */ |
| public static TclArgument[] getTypedMatch(TclCommand command, String name) { |
| EList<ArgumentMatch> matches = command.getMatches(); |
| List<TclArgument> results = new ArrayList<>(); |
| for (ArgumentMatch argumentMatch : matches) { |
| Argument definition = argumentMatch.getDefinition(); |
| if (definition instanceof TypedArgument) { |
| TypedArgument arg = (TypedArgument) definition; |
| if (name.equals(arg.getName())) { |
| results.addAll(argumentMatch.getArguments()); |
| } |
| } |
| } |
| return results.toArray(new TclArgument[results.size()]); |
| } |
| } |
