-make

	package aQute.bnd.make;
	
	import java.util.*;
	import java.util.Map.Entry;
	import java.util.regex.*;
	
	import aQute.bnd.header.*;
	import aQute.bnd.osgi.*;
	import aQute.bnd.service.*;
	
	public class Make {
		Builder								builder;
		Map<Instruction,Map<String,String>>	make;
	
		public Make(Builder builder) {
			this.builder = builder;
		}
	
		public Resource process(String source) {
			Map<Instruction,Map<String,String>> make = getMakeHeader();
			builder.trace("make " + source);
	
			for (Map.Entry<Instruction,Map<String,String>> entry : make.entrySet()) {
				Instruction instr = entry.getKey();
				Matcher m = instr.getMatcher(source);
				if (m.matches() || instr.isNegated()) {
					Map<String,String> arguments = replace(m, entry.getValue());
					List<MakePlugin> plugins = builder.getPlugins(MakePlugin.class);
					for (MakePlugin plugin : plugins) {
						try {
							Resource resource = plugin.make(builder, source, arguments);
							if (resource != null) {
								builder.trace("Made " + source + " from args " + arguments + " with " + plugin);
								return resource;
							}
						}
						catch (Exception e) {
							builder.error("Plugin " + plugin + " generates error when use in making " + source
									+ " with args " + arguments, e);
						}
					}
				}
			}
			return null;
		}
	
		private Map<String,String> replace(Matcher m, Map<String,String> value) {
			Map<String,String> newArgs = Processor.newMap();
			for (Map.Entry<String,String> entry : value.entrySet()) {
				String s = entry.getValue();
				s = replace(m, s);
				newArgs.put(entry.getKey(), s);
			}
			return newArgs;
		}
	
		String replace(Matcher m, CharSequence s) {
			StringBuilder sb = new StringBuilder();
			int max = '0' + m.groupCount() + 1;
			for (int i = 0; i < s.length(); i++) {
				char c = s.charAt(i);
				if (c == '$' && i < s.length() - 1) {
					c = s.charAt(++i);
					if (c >= '0' && c <= max) {
						int index = c - '0';
						String replacement = m.group(index);
						if (replacement != null)
							sb.append(replacement);
					} else {
						if (c == '$')
							i++;
						sb.append(c);
					}
				} else
					sb.append(c);
			}
			return sb.toString();
		}
	
		Map<Instruction,Map<String,String>> getMakeHeader() {
			if (make != null)
				return make;
			make = Processor.newMap();
	
			String s = builder.getProperty(Builder.MAKE);
			Parameters make = builder.parseHeader(s);
	
			for (Entry<String,Attrs> entry : make.entrySet()) {
				String pattern = Processor.removeDuplicateMarker(entry.getKey());
	
				Instruction instr = new Instruction(pattern);
				this.make.put(instr, entry.getValue());
			}
	
			return this.make;
		}
	}