blob: 6510f6334bd62d8db058ba33bc5b861c4f4dfde9 [file] [log] [blame]
/* Copyright 2006 aQute SARL
* Licensed under the Apache License, Version 2.0, see http://www.apache.org/licenses/LICENSE-2.0 */
package aQute.lib.osgi;
import java.io.*;
import java.lang.reflect.*;
import java.net.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;
import aQute.libg.version.*;
/**
* Provide a macro processor. This processor can replace variables in strings
* based on a properties and a domain. The domain can implement functions that
* start with a "_" and take args[], the names of these functions are available
* as functions in the macro processor (without the _). Macros can nest to any
* depth but may not contain loops.
*
*/
public class Macro {
Properties properties;
Processor domain;
Object targets[];
boolean flattening;
public Macro(Properties properties, Processor domain, Object... targets) {
this.properties = properties;
this.domain = domain;
this.targets = targets;
}
public Macro(Processor processor) {
this(new Properties(), processor);
}
public String process(String line) {
return process(line, null);
}
String process(String line, Link link) {
StringBuffer sb = new StringBuffer();
process(line, 0, '\u0000', '\u0000', sb, link);
return sb.toString();
}
int process(CharSequence org, int index, char begin, char end,
StringBuffer result, Link link) {
StringBuilder line = new StringBuilder(org);
int nesting = 1;
StringBuffer variable = new StringBuffer();
outer: while (index < line.length()) {
char c1 = line.charAt(index++);
if (c1 == end) {
if (--nesting == 0) {
result.append(replace(variable.toString(), link));
return index;
}
} else if (c1 == begin)
nesting++;
else if (c1 == '\\' && index < line.length() - 1
&& line.charAt(index) == '$') {
// remove the escape backslash and interpret the dollar as a
// literal
index++;
variable.append('$');
continue outer;
} else if (c1 == '$' && index < line.length() - 2) {
char c2 = line.charAt(index);
char terminator = getTerminator(c2);
if (terminator != 0) {
index = process(line, index + 1, c2, terminator, variable,
link);
continue outer;
}
}
variable.append(c1);
}
result.append(variable);
return index;
}
char getTerminator(char c) {
switch (c) {
case '(':
return ')';
case '[':
return ']';
case '{':
return '}';
case '<':
return '>';
case '\u00ab': // Guillemet double << >>
return '\u00bb';
case '\u2039': // Guillemet single
return '\u203a';
}
return 0;
}
protected String replace(String key, Link link) {
if (link != null && link.contains(key))
return "${infinite:" + link.toString() + "}";
if (key != null) {
key = key.trim();
if (key.length() > 0) {
String value = (String) properties.getProperty(key);
if (value != null)
return process(value, new Link(link, key));
value = doCommands(key);
if (value != null)
return process(value, new Link(link, key));
if (key != null && key.trim().length() > 0) {
value = System.getProperty(key);
if (value != null)
return value;
}
if (!flattening)
domain.warning("No translation found for macro: " + key);
} else {
domain.warning("Found empty macro key");
}
} else {
domain.warning("Found null macro key");
}
return "${" + key + "}";
}
/**
* Parse the key as a command. A command consist of parameters separated by
* ':'.
*
* @param key
* @return
*/
static Pattern commands = Pattern.compile("(?<!\\\\);");
private String doCommands(String key) {
String[] args = commands.split(key);
if (args == null || args.length == 0)
return null;
for (int i = 0; i < args.length; i++)
if (args[i].indexOf('\\') >= 0)
args[i] = args[i].replaceAll("\\\\;", ";");
Processor rover = domain;
while (rover != null) {
String result = doCommand(rover, args[0], args);
if (result != null)
return result;
rover = rover.getParent();
}
for (int i = 0; targets != null && i < targets.length; i++) {
String result = doCommand(targets[i], args[0], args);
if (result != null)
return result;
}
return doCommand(this, args[0], args);
}
private String doCommand(Object target, String method, String[] args) {
if (target == null)
System.out.println("Huh? Target should never be null " + domain);
else {
String cname = "_" + method.replaceAll("-", "_");
try {
Method m = target.getClass().getMethod(cname,
new Class[] { String[].class });
return (String) m.invoke(target, new Object[] { args });
} catch (NoSuchMethodException e) {
// Ignore
} catch (InvocationTargetException e) {
domain.warning("Exception in replace: " + e.getCause());
e.printStackTrace();
} catch (Exception e) {
domain.warning("Exception in replace: " + e + " method="
+ method);
e.printStackTrace();
}
}
return null;
}
/**
* Return a unique list where the duplicates are removed.
*
* @param args
* @return
*/
static String _uniqHelp = "${uniq;<list> ...}";
public String _uniq(String args[]) {
verifyCommand(args, _uniqHelp, null, 1, Integer.MAX_VALUE);
Set<String> set = new LinkedHashSet<String>();
for (int i = 1; i < args.length; i++) {
Processor.split(args[i], set);
}
return Processor.join(set, ",");
}
public String _filter(String args[]) {
return filter(args, false);
}
public String _filterout(String args[]) {
return filter(args, true);
}
static String _filterHelp = "${%s;<list>;<regex>}";
String filter(String[] args, boolean include) {
verifyCommand(args, String.format(_filterHelp, args[0]), null, 3, 3);
Collection<String> list = new ArrayList<String>(Processor
.split(args[1]));
Pattern pattern = Pattern.compile(args[2]);
for (Iterator<String> i = list.iterator(); i.hasNext();) {
if (pattern.matcher(i.next()).matches() == include)
i.remove();
}
return Processor.join(list);
}
static String _sortHelp = "${sort;<list>...}";
public String _sort(String args[]) {
verifyCommand(args, _sortHelp, null, 2, Integer.MAX_VALUE);
List<String> result = new ArrayList<String>();
for (int i = 1; i < args.length; i++) {
Processor.split(args[i], result);
}
Collections.sort(result);
return Processor.join(result);
}
static String _joinHelp = "${join;<list>...}";
public String _join(String args[]) {
verifyCommand(args, _joinHelp, null, 1, Integer.MAX_VALUE);
List<String> result = new ArrayList<String>();
for (int i = 1; i < args.length; i++) {
Processor.split(args[i], result);
}
return Processor.join(result);
}
static String _ifHelp = "${if;<condition>;<iftrue> [;<iffalse>] }";
public String _if(String args[]) {
verifyCommand(args, _ifHelp, null, 3, 4);
String condition = args[1].trim();
if (condition.length() != 0)
return args[2];
if (args.length > 3)
return args[3];
else
return "";
}
public String _now(String args[]) {
return new Date().toString();
}
public static String _fmodifiedHelp = "${fmodified;<list of filenames>...}, return latest modification date";
public String _fmodified(String args[]) throws Exception {
verifyCommand(args, _fmodifiedHelp, null, 2, Integer.MAX_VALUE);
long time = 0;
Collection<String> names = new ArrayList<String>();
for (int i = 1; i < args.length; i++) {
Processor.split(args[i], names);
}
for (String name : names) {
File f = new File(name);
if (f.exists() && f.lastModified() > time)
time = f.lastModified();
}
return "" + time;
}
public String _long2date(String args[]) {
try {
return new Date(Long.parseLong(args[1])).toString();
} catch (Exception e) {
e.printStackTrace();
}
return "not a valid long";
}
public String _literal(String args[]) {
if (args.length != 2)
throw new RuntimeException(
"Need a value for the ${literal;<value>} macro");
return "${" + args[1] + "}";
}
public String _def(String args[]) {
if (args.length != 2)
throw new RuntimeException(
"Need a value for the ${def;<value>} macro");
String value = properties.getProperty(args[1]);
if (value == null)
return "";
else
return value;
}
/**
*
* replace ; <list> ; regex ; replace
*
* @param args
* @return
*/
public String _replace(String args[]) {
if (args.length != 4) {
domain.warning("Invalid nr of arguments to replace "
+ Arrays.asList(args));
return null;
}
String list[] = args[1].split("\\s*,\\s*");
StringBuffer sb = new StringBuffer();
String del = "";
for (int i = 0; i < list.length; i++) {
String element = list[i].trim();
if (!element.equals("")) {
sb.append(del);
sb.append(element.replaceAll(args[2], args[3]));
del = ", ";
}
}
return sb.toString();
}
public String _warning(String args[]) {
for (int i = 1; i < args.length; i++) {
domain.warning(process(args[i]));
}
return "";
}
public String _error(String args[]) {
for (int i = 1; i < args.length; i++) {
domain.error(process(args[i]));
}
return "";
}
/**
* toclassname ; <path>.class ( , <path>.class ) *
*
* @param args
* @return
*/
static String _toclassnameHelp = "${classname;<list of class names>}, convert class paths to FQN class names ";
public String _toclassname(String args[]) {
verifyCommand(args, _toclassnameHelp, null, 2, 2);
Collection<String> paths = Processor.split(args[1]);
List<String> names = new ArrayList<String>(paths.size());
for (String path : paths) {
if (path.endsWith(".class")) {
String name = path.substring(0, path.length() - 6).replace('/',
'.');
names.add(name);
} else {
domain
.warning("in toclassname, "
+ args[1]
+ " is not a class path because it does not end in .class");
}
}
return Processor.join(names, ",");
}
/**
* toclassname ; <path>.class ( , <path>.class ) *
*
* @param args
* @return
*/
static String _toclasspathHelp = "${toclasspath;<list>}, convert a list of class names to paths";
public String _toclasspath(String args[]) {
verifyCommand(args, _toclasspathHelp, null, 2, 2);
Collection<String> names = Processor.split(args[1]);
Collection<String> paths = new ArrayList<String>(names.size());
for (String name : names) {
String path = name.replace('.', '/') + ".class";
paths.add(path);
}
return Processor.join(paths, ",");
}
public String _dir(String args[]) {
if (args.length < 2) {
domain.warning("Need at least one file name for ${dir;...}");
return null;
} else {
String del = "";
StringBuffer sb = new StringBuffer();
for (int i = 1; i < args.length; i++) {
File f = new File(args[i]).getAbsoluteFile();
if (f.exists() && f.getParentFile().exists()) {
sb.append(del);
sb.append(f.getParentFile().getAbsolutePath());
del = ",";
}
}
return sb.toString();
}
}
public String _basename(String args[]) {
if (args.length < 2) {
domain.warning("Need at least one file name for ${basename;...}");
return null;
} else {
String del = "";
StringBuffer sb = new StringBuffer();
for (int i = 1; i < args.length; i++) {
File f = new File(args[i]).getAbsoluteFile();
if (f.exists() && f.getParentFile().exists()) {
sb.append(del);
sb.append(f.getName());
del = ",";
}
}
return sb.toString();
}
}
public String _isfile(String args[]) {
if (args.length < 2) {
domain.warning("Need at least one file name for ${isfile;...}");
return null;
} else {
boolean isfile = true;
for (int i = 1; i < args.length; i++) {
File f = new File(args[i]).getAbsoluteFile();
isfile &= f.isFile();
}
return isfile ? "true" : "false";
}
}
public String _isdir(String args[]) {
if (args.length < 2) {
domain.warning("Need at least one file name for ${isdir;...}");
return null;
} else {
boolean isdir = true;
for (int i = 1; i < args.length; i++) {
File f = new File(args[i]).getAbsoluteFile();
isdir &= f.isDirectory();
}
return isdir ? "true" : "false";
}
}
public String _tstamp(String args[]) {
String format = "yyyyMMddhhmm";
long now = System.currentTimeMillis();
if (args.length > 1) {
format = args[1];
if (args.length > 2) {
now = Long.parseLong(args[2]);
if (args.length > 3) {
domain.warning("Too many arguments for tstamp: "
+ Arrays.toString(args));
}
}
}
SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.format(new Date(now));
}
/**
* Wildcard a directory. The lists can contain Instruction that are matched
* against the given directory
*
* ${wc;<dir>;<list>(;<list>)*}
*
* @author aqute
*
*/
public String _lsr(String args[]) {
return ls(args, true);
}
public String _lsa(String args[]) {
return ls(args, false);
}
String ls(String args[], boolean relative) {
if (args.length < 2)
throw new IllegalArgumentException(
"the ${ls} macro must at least have a directory as parameter");
File dir = new File(args[1]);
if (!dir.isAbsolute())
throw new IllegalArgumentException(
"the ${ls} macro directory parameter is not absolute: "
+ dir);
if (!dir.exists())
throw new IllegalArgumentException(
"the ${ls} macro directory parameter does not exist: "
+ dir);
if (!dir.isDirectory())
throw new IllegalArgumentException(
"the ${ls} macro directory parameter points to a file instead of a directory: "
+ dir);
String[] files = dir.list();
List<String> result;
if (args.length < 3) {
result = Arrays.asList(files);
} else
result = new ArrayList<String>();
for (int i = 2; i < args.length; i++) {
String parts[] = args[i].split("\\s*,\\s*");
for (String pattern : parts) {
// So make it in to an instruction
Instruction instr = Instruction.getPattern(pattern);
// For each project, match it against the instruction
for (int f = 0; f < files.length; f++) {
if (files[f] != null) {
if (instr.matches(files[f])) {
if (!instr.isNegated()) {
if (relative)
result.add(files[f]);
else
result.add(new File(dir, files[f])
.getAbsolutePath());
}
files[f] = null;
}
}
}
}
}
return Processor.join(result, ",");
}
public String _currenttime(String args[]) {
return Long.toString(System.currentTimeMillis());
}
/**
* Modify a version to set a version policy. Thed policy is a mask that is
* mapped to a version.
*
* <pre>
* + increment
* - decrement
* = maintain
* &tilde; discard
*
* ==+ = maintain major, minor, increment micro, discard qualifier
* &tilde;&tilde;&tilde;= = just get the qualifier
* version=&quot;[${version;==;${@}},${version;=+;${@}})&quot;
* </pre>
*
*
*
*
* @param args
* @return
*/
static String _versionHelp = "${version;<mask>;<version>}, modify a version\n"
+ "<mask> ::= [ M [ M [ M [ MQ ]]]\n"
+ "M ::= '+' | '-' | MQ\n"
+ "MQ ::= '~' | '='";
static Pattern _versionPattern[] = new Pattern[] { null, null,
Pattern.compile("[-+=~]{0,3}[=~]?"), Verifier.VERSION };
public String _version(String args[]) {
verifyCommand(args, _versionHelp, null, 3, 3);
String mask = args[1];
Version version = new Version(args[2]);
StringBuilder sb = new StringBuilder();
String del = "";
for (int i = 0; i < mask.length(); i++) {
char c = mask.charAt(i);
String result = null;
if (c != '~') {
if (i == 3) {
result = version.getQualifier();
} else {
int x = version.get(i);
switch (c) {
case '+':
x++;
break;
case '-':
x--;
break;
case '=':
break;
}
result = Integer.toString(x);
}
if (result != null) {
sb.append(del);
del = ".";
sb.append(result);
}
}
}
return sb.toString();
}
/**
* System command. Execute a command and insert the result.
*
* @param args
* @param help
* @param patterns
* @param low
* @param high
*/
public String _system(String args[]) throws Exception {
verifyCommand(args,
"${system;<command>[;<in>]}, execute a system command", null,
2, 3);
String command = args[1];
String input = null;
if (args.length > 2) {
input = args[2];
}
Process process = Runtime.getRuntime().exec(command, null,
domain.getBase());
if (input != null) {
process.getOutputStream().write(input.getBytes("UTF-8"));
}
process.getOutputStream().close();
String s = getString(process.getInputStream());
process.getInputStream().close();
int exitValue = process.waitFor();
if (exitValue != 0) {
domain.error("System command " + command + " failed with "
+ exitValue);
}
return s.trim();
}
/**
* Get the contents of a file.
*
* @param in
* @return
* @throws IOException
*/
public String _cat(String args[]) throws IOException {
verifyCommand(args, "${cat;<in>}, get the content of a file", null, 2,
2);
File f = domain.getFile(args[1]);
if (f.isFile()) {
InputStream in = new FileInputStream(f);
return getString(in);
} else if (f.isDirectory()) {
return Arrays.toString( f.list());
} else {
try {
URL url = new URL(args[1]);
InputStream in = url.openStream();
return getString(in);
} catch( MalformedURLException mfue ) {
// Ignore here
}
return null;
}
}
public static String getString(InputStream in) throws IOException {
try {
StringBuilder sb = new StringBuilder();
BufferedReader rdr = new BufferedReader(new InputStreamReader(in));
String line = null;
while ((line = rdr.readLine()) != null) {
sb.append(line);
sb.append("\n");
}
return sb.toString();
} finally {
in.close();
}
}
public static void verifyCommand(String args[], String help,
Pattern[] patterns, int low, int high) {
String message = "";
if (args.length > high) {
message = "too many arguments";
} else if (args.length < low) {
message = "too few arguments";
} else {
for (int i = 0; patterns != null && i < patterns.length
&& i < args.length - 1; i++) {
if (patterns[i] != null
&& !patterns[i].matcher(args[i + 1]).matches()) {
message += String.format(
"Argument %s (%s) does not match %s\n", i, args[i],
patterns[i].pattern());
}
}
}
if (message.length() != 0) {
StringBuilder sb = new StringBuilder();
String del = "${";
for (String arg : args) {
sb.append(del);
sb.append(arg);
del = ";";
}
sb.append("}, is not understood. ");
sb.append(message);
throw new IllegalArgumentException(sb.toString());
}
}
// Helper class to track expansion of variables
// on the stack.
static class Link {
Link previous;
String key;
public Link(Link previous, String key) {
this.previous = previous;
this.key = key;
}
public boolean contains(String key) {
if (this.key.equals(key))
return true;
if (previous == null)
return false;
return previous.contains(key);
}
public String toString() {
StringBuffer sb = new StringBuffer();
String del = "[";
for (Link r = this; r != null; r = r.previous) {
sb.append(del);
sb.append(r.key);
del = ",";
}
sb.append("]");
return sb.toString();
}
}
/**
* Take all the properties and translate them to actual values. This method
* takes the set properties and traverse them over all entries, including
* the default properties for that properties. The values no longer contain
* macros.
*
* @return A new Properties with the flattened values
*/
public Properties getFlattenedProperties() {
// Some macros only work in a lower processor, so we
// do not report unknown macros while flattening
flattening = true;
try {
Properties flattened = new Properties();
for (Enumeration<?> e = properties.propertyNames(); e
.hasMoreElements();) {
String key = (String) e.nextElement();
if ( ! key.startsWith("_"))
flattened.put(key, process(properties.getProperty(key)));
}
return flattened;
} finally {
flattening = false;
}
};
}