rpm/org.eclipse.linuxtools.rpmstubby/src/org/eclipse/linuxtools/internal/rpmstubby/parser/PerlMakefileParser.java - linuxtools/org.eclipse.linuxtools - Git at Google

 /*******************************************************************************
  * Copyright (c) 2013, 2018 Red Hat, Inc.
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
  * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Neil Guzman - perl implementation
  *******************************************************************************/
 package org.eclipse.linuxtools.internal.rpmstubby.parser;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Scanner;
 import java.util.Stack;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.linuxtools.internal.rpmstubby.StubbyLog;

 /**
  * Class to parse a Perl Makefile.PL to grab specfile properties
  *
  */
 public class PerlMakefileParser {

     /*
      * Perl Regular Expressions
      *
      */
     private static final String WHITE_SPACE = "(?:\\s+)";
     private static final String COMMENT = "#.+";                            // # comment
     private static final String LINE_WITH_COMMENT = "(?:(.*)#.+)";          // line # comment
     private static final String VARIABLE_PARAMS = "(?:my|local|our)";

     private static final String WORD = "(\\b\\w+\\b)";                      // variable
     private static final String NON_WHITE_SPACE = "(\\S+)";
     private static final String VARIABLE = "(?:" + VARIABLE_PARAMS
             + WHITE_SPACE + ")?(?:\\$|@|%)" + WORD + WHITE_SPACE + "?";     // %variable | my $variable | our @variable
     private static final String ASSOCIATIVE_KEY = WHITE_SPACE + "?"
             + NON_WHITE_SPACE + WHITE_SPACE + "?";

     private static final String EXCLUDE_SPECIALS = "(?![=~|\\-\\*\\+\\/])";
     private static final String NON_CONDITIONAL = "(?!(?:\\s*if|elsif|unless))";
     private static final String ASSIGNMENT_OPERATOR = "=";
     private static final String ASSOCIATIVE_OPERATOR = "=>";
     private static final String SIMPLE_ASSIGNMENT = NON_CONDITIONAL
             + WHITE_SPACE + "?" + VARIABLE + "(?:" + ASSIGNMENT_OPERATOR + ")"
             + EXCLUDE_SPECIALS + "(?:(.+))";                                // %var = value || [1] = [2]
     private static final String ASSOCIATIVE_ASSIGNMENT = ASSOCIATIVE_KEY
             + ASSOCIATIVE_OPERATOR + "(?:(.+))";                            // 'key' => 'value' || [1] => [2]

     private static final String FUNCTION = "\\s*" + WORD
             + "*\\s*?\\((.*)\\)\\s*";                                       // foo(bar) | foo(foo(bar)) | foo() || [1]([2])
     private static final String BEGIN_END = "(?:[^#]*<<END)";               // [CS] test<<END | <<END
     private static final String END_END = "^END$";                          // [CS]
     private static final String BEGIN_BC = "^=(?!cut)[a-z]\\S+(\\s)?\\S+";  // [CS] =test | =test test
     private static final String END_BC = "^=cut$";                          // [CS]

     private static final String MAKEFILE_FUNCTION_NAME = "WriteMakefile";
     private static final String MAKEFILE_FUNCTION = "^.*"
             + MAKEFILE_FUNCTION_NAME + WHITE_SPACE + "?\\(.*$";

     /*
      * A few common opening characters and their closing counterparts
      *
      */
     private static final Map<Character, Character> SURROUNDING_CHARACTER;
     static {
         Map<Character, Character> aMap = new HashMap<>();
         aMap.put('[', ']');
         aMap.put('{', '}');
         aMap.put('(', ')');
         aMap.put(']', '[');
         aMap.put('}', '{');
         aMap.put(')', '(');
         SURROUNDING_CHARACTER = Collections.unmodifiableMap(aMap);
     }

     private static final char SQUARE_BRACKET = '[';
     private static final char CURLY_BRACKET = '{';
     private static final char ROUND_BRACKET = '(';

     private static final int IN_BRACKETS = 0x00000001;
     private static final int MAKE_FUNCTION = 0x00000002;

     private IFile file;
     private Map<String, String> mVariableDefinitions;
     private Map<String, String> mMakefileDefinitions;

     /**
      * Initialize.
      *
      * @param file
      *            The perl Makefile.
      * @throws CoreException
      *             Throws CoreException.
      * @throws IOException
      *             Throws IOException.
      */
     public PerlMakefileParser(IFile file) throws IOException, CoreException {
         mVariableDefinitions = new HashMap<>();
         mMakefileDefinitions = new HashMap<>();
         if (file.getContents().available() <= 0) {
             return;
         }
         this.file = file;
         parse();
     }

     /**
      * Parse the perl Makefile.
      *
      */
     public void parse() {
         String content = "";
         String line = "";
         try (Scanner variableScanner = new Scanner(file.getContents())) {
             grabSimpleDefinitions(cleanUpContent(variableScanner));
             cleanupVariables(mVariableDefinitions);
             resolveVariables(mVariableDefinitions);

             /*
              * Going through the makefile function's attributes
              */
             if (!mVariableDefinitions.containsKey(MAKEFILE_FUNCTION_NAME)) {
                 return;
             }
             try (Scanner makefileScanner = new Scanner(
                     mVariableDefinitions.get(MAKEFILE_FUNCTION_NAME))) {
                 makefileScanner.useDelimiter("(?<=,)");
                 ArrayList<String> makefileList = new ArrayList<>();

                 while (makefileScanner.hasNext()) {
                     line = makefileScanner.next();
                     if (matchesAssociativeAssignment(line)) {
                         makefileList.add(line);
                     } else if (!makefileList.isEmpty()) {
                         makefileList.set(makefileList.size() - 1, makefileList
                                 .get(makefileList.size() - 1).concat(line));
                     }
                 }

                 for (String str : makefileList) {
                     content = content.concat(str + '\n');
                 }
                 grabAssociativeDefinitions(content);
                 cleanupVariables(mMakefileDefinitions);
                 resolveVariables(mMakefileDefinitions);

             }
             variableScanner.close();
         } catch (CoreException e) {
             StubbyLog.logError(e);
         }
     }

     /**
      * Get the value of the variable.
      *
      * @param key The variable to get the value of.
      * @return The value of the variable.
      */
     public String getValue(String key) {
         String rc = "";
         if (mMakefileDefinitions.containsKey(key)) {
             rc = mMakefileDefinitions.get(key);
         }
         return rc;
     }

     /**
      * Get the list of values from the variable.
      *
      * @param key The variable to get the value of.
      * @return The list of values from the variable.
      */
     public List<String> getValueList(String key) {
         List<String> rc = new ArrayList<>();
         String var = "";
         if (mMakefileDefinitions.containsKey(key)) {
             var = mMakefileDefinitions.get(key);
             String[] tmp = var.split(",");
             for (String str : tmp) {
                 str = cleanUpString(str);
                 rc.add(str);
             }
         }
         return rc;
     }

     /**
      * Grab the simple key->value pairs from some content.
      *
      * @param content
      *            The content to grab the key->value pairs from.
      */
     private void grabSimpleDefinitions(String content) {
         try (Scanner scanner = new Scanner(content)) {
             Stack<Character> brackets = new Stack<>();
             String key = "";
             String value = "";
             String tempVar = "";
             String line = "";
             String[] tmp;
             int flags = 0;

             while (scanner.hasNext()) {
                 line = scanner.nextLine();
                 if (matchesSimpleAssignment(line)) {
                     tmp = line.split("=");
                     key = removeVariableSigils(tmp[0]).toLowerCase()
                             .replaceAll("\\W", "");
                     value = tmp[1];
                     if (containsOpener(value)) {
                         flags |= IN_BRACKETS;
                     } else {
                         mVariableDefinitions.put(key, value);
                     }
                 } else if (containsMakefileFunction(line)) {
                     flags |= MAKE_FUNCTION;
                     flags |= IN_BRACKETS;
                 }
                 if ((flags & IN_BRACKETS) == IN_BRACKETS) {
                     checkBrackets(brackets, line);
                     tempVar = tempVar.concat(line.trim());
                     if (brackets.isEmpty()) {
                         if ((flags & MAKE_FUNCTION) == MAKE_FUNCTION) {
                             mVariableDefinitions
                                     .putAll(extractFunction(tempVar));
                         } else {
                             tmp = tempVar.split("=[^>]");
                             key = removeVariableSigils(tmp[0]).toLowerCase()
                                     .replaceAll("\\W", "");
                             value = tmp[1];
                             mVariableDefinitions.put(key, value);
                         }
                         tempVar = "";
                         flags &= 0;
                     }
                 }
             }
         }
     }

     /**
      * Grab the associative key=>value pairs from some content.
      *
      * @param content
      *            The content to grab the key=>value pairs from.
      */
     private void grabAssociativeDefinitions(String content) {
         try (Scanner scanner = new Scanner(content)) {
             Stack<Character> brackets = new Stack<>();
             String key = "";
             String value = "";
             String tempVar = "";
             String line = "";
             String[] tmp;
             int flags = 0;

             while (scanner.hasNext()) {
                 line = scanner.nextLine();
                 if (matchesAssociativeAssignment(line)
                         && (flags & IN_BRACKETS) != IN_BRACKETS) {
                     tmp = line.split("=>");
                     key = removeVariableSigils(tmp[0].toLowerCase().replaceAll(
                             "\\W", ""));
                     value = tmp[1];
                     if (containsOpener(value)) {
                         flags |= IN_BRACKETS;
                     } else {
                         mMakefileDefinitions.put(key, value);
                     }
                 }
                 if ((flags & IN_BRACKETS) == IN_BRACKETS) {
                     checkBrackets(brackets, line);
                     tempVar = tempVar.concat(line.trim());
                     if (brackets.isEmpty()) {
                         key = removeVariableSigils(tempVar
                                 .substring(0, tempVar.indexOf("=>"))
                                 .toLowerCase().replaceAll("\\W", ""));
                         value = tempVar.substring(tempVar.indexOf("=>") + 2);
                         mMakefileDefinitions.put(key, value);
                         tempVar = "";
                         flags &= 0;
                     }
                 }
             }
         }
     }

     /**
      * Check if the line is within a set of brackets. Update the stack tracking
      * bracket completeness.
      *
      * @param brackets
      *            The stack tracking the bracket completeness.
      * @param line
      *            The line to parse for brackets.
      */
     public static void checkBrackets(Stack<Character> brackets, String line) {
         for (char c : line.toCharArray()) {
             if (c == SQUARE_BRACKET || c == CURLY_BRACKET || c == ROUND_BRACKET) {
                 brackets.push(c);
             } else if (c == SURROUNDING_CHARACTER.get(SQUARE_BRACKET)
                     || c == SURROUNDING_CHARACTER.get(CURLY_BRACKET)
                     || c == SURROUNDING_CHARACTER.get(ROUND_BRACKET)) {
                 if (brackets.peek() == SURROUNDING_CHARACTER.get(c)
                         && !brackets.isEmpty()) {
                     brackets.pop();
                 }
             }
         }
     }

     /**
      * Go through the map of key->value pairings and check and see if a key has
      * another key as a value. If so, resolve that.
      *
      * @param variables
      *            The key->value pairings.
      */
     private void resolveVariables(Map<String, String> variables) {
         String tempVal = "";
         for (Entry<String,String> entry : variables.entrySet()) {
             tempVal = entry.getValue();
             if (mVariableDefinitions.containsKey(tempVal)) {
                 variables.put(entry.getKey(), mVariableDefinitions.get(tempVal));
             }
         }
     }

     /**
      * Extract the function name and the contents of the function and return it
      * as a key->value pairing.
      *
      * @param line
      *            The line to extract the function from.
      * @return The key->value pairing of function and parameter(s).
      */
     public static Map<String, String> extractFunction(String line) {
         Map<String, String> rc = new HashMap<>();
         Pattern pattern = Pattern.compile(FUNCTION, Pattern.CASE_INSENSITIVE);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.find()) {
             rc.put(variableMatcher.group(1), variableMatcher.group(2));
         }
         return rc;
     }

     /**
      * Extract the key->value pairing from an associative assignment.
      *
      * @param line
      *            The line to extract the function from.
      * @return The key->value pairing of function and parameter(s).
      */
     public static Map<String, String> extractKeyValueAssociation(String line) {
         Map<String, String> rc = new HashMap<>();
         String key = "";
         String value = "";
         if (matchesAssociativeAssignment(line)) {
             String[] keyValue = line.split("=>");
             key = cleanUpString(keyValue[0].toLowerCase());
             value = cleanUpString(keyValue[1]);
             rc.put(key, value);
         }
         return rc;
     }

     /**
      * Utility to go through the map of variables to clean up their values.
      *
      * @param variables
      *            The map of variables to go through.
      */
     private static void cleanupVariables(Map<String, String> variables) {
         String val = "";
         for (Entry<String,String> entry : variables.entrySet()) {
             val = cleanUpString(removeVariableSigils(entry.getValue()))
                     .trim();
             if (val.startsWith("(") || val.startsWith("[")
                     || val.startsWith("{")) {
                 val = val.substring(1);
             }
             if (val.endsWith(")") || val.endsWith("]") || val.endsWith("}")) {
                 val = val.substring(0, val.length() - 1);
             }
             val = cleanUpString(val);
             variables.put(entry.getKey(), val);
         }
     }

     /**
      * Utility to clean up the line of some unwanted characters.
      *
      * @param line
      *            The line to clean up.
      * @return The cleaned up version of the line.
      */
     private static String cleanUpString(String line) {
         line = line.trim().replaceAll("('|\")", "");
         if (line.endsWith(";")) {
             line = line.substring(0, line.length() - 1);
         }
         if (line.endsWith(",")) {
             line = line.substring(0, line.length() - 1);
         }
         return line;
     }

     /**
      * Remove the variable sigils.
      *
      * @param variable
      *            The variable to remove sigils from.
      * @return A word only variable with no sigils.
      */
     public static String removeVariableSigils(String variable) {
         return variable
                 .replaceAll(
                         "(\\bmy\\b|\\bour\\b|\\blocal\\b|(\\\\)?\\$|(\\\\)?@|(\\\\)?%)",
                         "");
     }

     /**
      * Clean up the contents of the file and remove all the comments, END
      * blocks, and block comments.
      *
      * @param scanner
      *            The scanner of the file to be read.
      * @return The cleaned up content.
      */
     private static String cleanUpContent(Scanner scanner) {
         String rc = "";
         String line = "";
         boolean flagEND = true;
         boolean flagBC = true;
         while (scanner.hasNext()) {
             line = scanner.nextLine();
             // ignore lines between ENDS
             if (containsBeginEND(line)) {
                 flagEND = false;
             } else if (matchesEndEND(line)) {
                 line = scanner.nextLine();
                 flagEND = true; // true
             }
             // ignore lines between =someword and =cut
             if (matchesBeginBC(line)) {
                 flagBC = false;
             } else if (matchesEndBC(line)) {
                 line = scanner.nextLine();
                 flagBC = true;
             }
             // remove the comments
             if (matchesLineWithComment(line)) {
                 line = line.replaceAll(COMMENT, "");
             }
             // if not empty line or within comment/END block
             if (flagEND && flagBC && !line.trim().equals("")) {
                 rc = rc.concat(line + '\n');
             }
         }
         return rc;
     }

     /**
      * Check if a line contains a function.
      *
      * @param line
      *            The line to check.
      * @return True if the line contains a function.
      */
     public static boolean containsFunction(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile(FUNCTION, Pattern.CASE_INSENSITIVE);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.find()) {
             rc = true;
         }
         return rc;
     }

     /**
      * Check to see if the line contains the WriteMakefile function.
      *
      * @param line
      *            The line to check.
      * @return True if the line contains the WriteMakefile function.
      */
     public static boolean containsMakefileFunction(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile(MAKEFILE_FUNCTION,
                 Pattern.CASE_INSENSITIVE);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.find()) {
             rc = true;
         }
         return rc;
     }

     /**
      * Check to see if the line contains an opening bracket.
      *
      * @param line
      *            The line to check.
      * @return True if the line contains an opening bracket.
      */
     public static boolean containsOpener(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile("(\\(|\\[|\\{)",
                 Pattern.CASE_INSENSITIVE);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.find()) {
             rc = true;
         }
         return rc;
     }

     /**
      * Check if a line contains <<END. It is case-sensitive.
      *
      * @param line
      *            The line to check.
      * @return True if the line contains <<END.
      */
     public static boolean containsBeginEND(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile(BEGIN_END);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.find()) {
             rc = true;
         }
         return rc;
     }

     /**
      * Check if a line is a simple assignment of a variable.
      *
      * @param line
      *            The line to check.
      * @return True if the line is a simple assignment of a variable.
      */
     public static boolean matchesSimpleAssignment(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile(SIMPLE_ASSIGNMENT,
                 Pattern.CASE_INSENSITIVE);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.matches()) {
             rc = true;
         }
         return rc;
     }

     /**
      * Check if a line is a simple assignment of a variable.
      *
      * @param line
      *            The line to check.
      * @return True if the line is a simple assignment of a variable.
      */
     public static boolean matchesAssociativeAssignment(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile(ASSOCIATIVE_ASSIGNMENT,
                 Pattern.CASE_INSENSITIVE);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.matches()) {
             rc = true;
         }
         return rc;
     }

     /**
      * Check if a line matches the END. It is case-sensitive.
      *
      * @param line
      *            The line to check.
      * @return True if the line matches END.
      */
     public static boolean matchesEndEND(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile(END_END);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.matches()) {
             rc = true;
         }
         return rc;
     }

     /**
      * Check if a line matches the beginning of a block comment. It is
      * case-sensitive.
      *
      * @param line
      *            The line to check.
      * @return True if the line matches the beginning of a block comment.
      */
     public static boolean matchesBeginBC(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile(BEGIN_BC);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.matches()) {
             rc = true;
         }
         return rc;
     }

     /**
      * Check if a line matches the end of a block comment (=cut). It is
      * case-sensitive.
      *
      * @param line
      *            The line to check.
      * @return True if the line matches =cut.
      */
     public static boolean matchesEndBC(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile(END_BC);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.matches()) {
             rc = true;
         }
         return rc;
     }

     /**
      * Check if a line matches that of a line with a comment.
      *
      * @param line
      *            The line to check.
      * @return True if the line matches that of a line with a comment.
      */
     public static boolean matchesLineWithComment(String line) {
         boolean rc = false;
         Pattern pattern = Pattern.compile(LINE_WITH_COMMENT,
                 Pattern.CASE_INSENSITIVE);
         Matcher variableMatcher = pattern.matcher(line);
         if (variableMatcher.matches()) {
             rc = true;
         }
         return rc;
     }
 }
	/*******************************************************************************
	* Copyright (c) 2013, 2018 Red Hat, Inc.
	*
	* This program and the accompanying materials are made
	* available under the terms of the Eclipse Public License 2.0
	* which is available at https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Neil Guzman - perl implementation
	*******************************************************************************/
	package org.eclipse.linuxtools.internal.rpmstubby.parser;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.Scanner;
	import java.util.Stack;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.linuxtools.internal.rpmstubby.StubbyLog;

	/**
	* Class to parse a Perl Makefile.PL to grab specfile properties
	*
	*/
	public class PerlMakefileParser {

	/*
	* Perl Regular Expressions
	*
	*/
	private static final String WHITE_SPACE = "(?:\\s+)";
	private static final String COMMENT = "#.+"; // # comment
	private static final String LINE_WITH_COMMENT = "(?:(.*)#.+)"; // line # comment
	private static final String VARIABLE_PARAMS = "(?:my\|local\|our)";

	private static final String WORD = "(\\b\\w+\\b)"; // variable
	private static final String NON_WHITE_SPACE = "(\\S+)";
	private static final String VARIABLE = "(?:" + VARIABLE_PARAMS
	+ WHITE_SPACE + ")?(?:\\$\|@\|%)" + WORD + WHITE_SPACE + "?"; // %variable \| my $variable \| our @variable
	private static final String ASSOCIATIVE_KEY = WHITE_SPACE + "?"
	+ NON_WHITE_SPACE + WHITE_SPACE + "?";

	private static final String EXCLUDE_SPECIALS = "(?![=~\|\\-\\*\\+\\/])";
	private static final String NON_CONDITIONAL = "(?!(?:\\s*if\|elsif\|unless))";
	private static final String ASSIGNMENT_OPERATOR = "=";
	private static final String ASSOCIATIVE_OPERATOR = "=>";
	private static final String SIMPLE_ASSIGNMENT = NON_CONDITIONAL
	+ WHITE_SPACE + "?" + VARIABLE + "(?:" + ASSIGNMENT_OPERATOR + ")"
	+ EXCLUDE_SPECIALS + "(?:(.+))"; // %var = value \|\| [1] = [2]
	private static final String ASSOCIATIVE_ASSIGNMENT = ASSOCIATIVE_KEY
	+ ASSOCIATIVE_OPERATOR + "(?:(.+))"; // 'key' => 'value' \|\| [1] => [2]

	private static final String FUNCTION = "\\s*" + WORD
	+ "\\s?\\((.)\\)\\s"; // foo(bar) \| foo(foo(bar)) \| foo() \|\| [1]([2])
	private static final String BEGIN_END = "(?:[^#]*<<END)"; // [CS] test<<END \| <<END
	private static final String END_END = "^END$"; // [CS]
	private static final String BEGIN_BC = "^=(?!cut)[a-z]\\S+(\\s)?\\S+"; // [CS] =test \| =test test
	private static final String END_BC = "^=cut$"; // [CS]

	private static final String MAKEFILE_FUNCTION_NAME = "WriteMakefile";
	private static final String MAKEFILE_FUNCTION = "^.*"
	+ MAKEFILE_FUNCTION_NAME + WHITE_SPACE + "?\\(.*$";

	/*
	* A few common opening characters and their closing counterparts
	*
	*/
	private static final Map<Character, Character> SURROUNDING_CHARACTER;
	static {
	Map<Character, Character> aMap = new HashMap<>();
	aMap.put('[', ']');
	aMap.put('{', '}');
	aMap.put('(', ')');
	aMap.put(']', '[');
	aMap.put('}', '{');
	aMap.put(')', '(');
	SURROUNDING_CHARACTER = Collections.unmodifiableMap(aMap);
	}

	private static final char SQUARE_BRACKET = '[';
	private static final char CURLY_BRACKET = '{';
	private static final char ROUND_BRACKET = '(';

	private static final int IN_BRACKETS = 0x00000001;
	private static final int MAKE_FUNCTION = 0x00000002;

	private IFile file;
	private Map<String, String> mVariableDefinitions;
	private Map<String, String> mMakefileDefinitions;

	/**
	* Initialize.
	*
	* @param file
	* The perl Makefile.
	* @throws CoreException
	* Throws CoreException.
	* @throws IOException
	* Throws IOException.
	*/
	public PerlMakefileParser(IFile file) throws IOException, CoreException {
	mVariableDefinitions = new HashMap<>();
	mMakefileDefinitions = new HashMap<>();
	if (file.getContents().available() <= 0) {
	return;
	}
	this.file = file;
	parse();
	}

	/**
	* Parse the perl Makefile.
	*
	*/
	public void parse() {
	String content = "";
	String line = "";
	try (Scanner variableScanner = new Scanner(file.getContents())) {
	grabSimpleDefinitions(cleanUpContent(variableScanner));
	cleanupVariables(mVariableDefinitions);
	resolveVariables(mVariableDefinitions);

	/*
	* Going through the makefile function's attributes
	*/
	if (!mVariableDefinitions.containsKey(MAKEFILE_FUNCTION_NAME)) {
	return;
	}
	try (Scanner makefileScanner = new Scanner(
	mVariableDefinitions.get(MAKEFILE_FUNCTION_NAME))) {
	makefileScanner.useDelimiter("(?<=,)");
	ArrayList<String> makefileList = new ArrayList<>();

	while (makefileScanner.hasNext()) {
	line = makefileScanner.next();
	if (matchesAssociativeAssignment(line)) {
	makefileList.add(line);
	} else if (!makefileList.isEmpty()) {
	makefileList.set(makefileList.size() - 1, makefileList
	.get(makefileList.size() - 1).concat(line));
	}
	}

	for (String str : makefileList) {
	content = content.concat(str + '\n');
	}
	grabAssociativeDefinitions(content);
	cleanupVariables(mMakefileDefinitions);
	resolveVariables(mMakefileDefinitions);

	}
	variableScanner.close();
	} catch (CoreException e) {
	StubbyLog.logError(e);
	}
	}

	/**
	* Get the value of the variable.
	*
	* @param key The variable to get the value of.
	* @return The value of the variable.
	*/
	public String getValue(String key) {
	String rc = "";
	if (mMakefileDefinitions.containsKey(key)) {
	rc = mMakefileDefinitions.get(key);
	}
	return rc;
	}

	/**
	* Get the list of values from the variable.
	*
	* @param key The variable to get the value of.
	* @return The list of values from the variable.
	*/
	public List<String> getValueList(String key) {
	List<String> rc = new ArrayList<>();
	String var = "";
	if (mMakefileDefinitions.containsKey(key)) {
	var = mMakefileDefinitions.get(key);
	String[] tmp = var.split(",");
	for (String str : tmp) {
	str = cleanUpString(str);
	rc.add(str);
	}
	}
	return rc;
	}

	/**
	* Grab the simple key->value pairs from some content.
	*
	* @param content
	* The content to grab the key->value pairs from.
	*/
	private void grabSimpleDefinitions(String content) {
	try (Scanner scanner = new Scanner(content)) {
	Stack<Character> brackets = new Stack<>();
	String key = "";
	String value = "";
	String tempVar = "";
	String line = "";
	String[] tmp;
	int flags = 0;

	while (scanner.hasNext()) {
	line = scanner.nextLine();
	if (matchesSimpleAssignment(line)) {
	tmp = line.split("=");
	key = removeVariableSigils(tmp[0]).toLowerCase()
	.replaceAll("\\W", "");
	value = tmp[1];
	if (containsOpener(value)) {
	flags \|= IN_BRACKETS;
	} else {
	mVariableDefinitions.put(key, value);
	}
	} else if (containsMakefileFunction(line)) {
	flags \|= MAKE_FUNCTION;
	flags \|= IN_BRACKETS;
	}
	if ((flags & IN_BRACKETS) == IN_BRACKETS) {
	checkBrackets(brackets, line);
	tempVar = tempVar.concat(line.trim());
	if (brackets.isEmpty()) {
	if ((flags & MAKE_FUNCTION) == MAKE_FUNCTION) {
	mVariableDefinitions
	.putAll(extractFunction(tempVar));
	} else {
	tmp = tempVar.split("=[^>]");
	key = removeVariableSigils(tmp[0]).toLowerCase()
	.replaceAll("\\W", "");
	value = tmp[1];
	mVariableDefinitions.put(key, value);
	}
	tempVar = "";
	flags &= 0;
	}
	}
	}
	}
	}

	/**
	* Grab the associative key=>value pairs from some content.
	*
	* @param content
	* The content to grab the key=>value pairs from.
	*/
	private void grabAssociativeDefinitions(String content) {
	try (Scanner scanner = new Scanner(content)) {
	Stack<Character> brackets = new Stack<>();
	String key = "";
	String value = "";
	String tempVar = "";
	String line = "";
	String[] tmp;
	int flags = 0;

	while (scanner.hasNext()) {
	line = scanner.nextLine();
	if (matchesAssociativeAssignment(line)
	&& (flags & IN_BRACKETS) != IN_BRACKETS) {
	tmp = line.split("=>");
	key = removeVariableSigils(tmp[0].toLowerCase().replaceAll(
	"\\W", ""));
	value = tmp[1];
	if (containsOpener(value)) {
	flags \|= IN_BRACKETS;
	} else {
	mMakefileDefinitions.put(key, value);
	}
	}
	if ((flags & IN_BRACKETS) == IN_BRACKETS) {
	checkBrackets(brackets, line);
	tempVar = tempVar.concat(line.trim());
	if (brackets.isEmpty()) {
	key = removeVariableSigils(tempVar
	.substring(0, tempVar.indexOf("=>"))
	.toLowerCase().replaceAll("\\W", ""));
	value = tempVar.substring(tempVar.indexOf("=>") + 2);
	mMakefileDefinitions.put(key, value);
	tempVar = "";
	flags &= 0;
	}
	}
	}
	}
	}

	/**
	* Check if the line is within a set of brackets. Update the stack tracking
	* bracket completeness.
	*
	* @param brackets
	* The stack tracking the bracket completeness.
	* @param line
	* The line to parse for brackets.
	*/
	public static void checkBrackets(Stack<Character> brackets, String line) {
	for (char c : line.toCharArray()) {
	if (c == SQUARE_BRACKET \|\| c == CURLY_BRACKET \|\| c == ROUND_BRACKET) {
	brackets.push(c);
	} else if (c == SURROUNDING_CHARACTER.get(SQUARE_BRACKET)
	\|\| c == SURROUNDING_CHARACTER.get(CURLY_BRACKET)
	\|\| c == SURROUNDING_CHARACTER.get(ROUND_BRACKET)) {
	if (brackets.peek() == SURROUNDING_CHARACTER.get(c)
	&& !brackets.isEmpty()) {
	brackets.pop();
	}
	}
	}
	}

	/**
	* Go through the map of key->value pairings and check and see if a key has
	* another key as a value. If so, resolve that.
	*
	* @param variables
	* The key->value pairings.
	*/
	private void resolveVariables(Map<String, String> variables) {
	String tempVal = "";
	for (Entry<String,String> entry : variables.entrySet()) {
	tempVal = entry.getValue();
	if (mVariableDefinitions.containsKey(tempVal)) {
	variables.put(entry.getKey(), mVariableDefinitions.get(tempVal));
	}
	}
	}

	/**
	* Extract the function name and the contents of the function and return it
	* as a key->value pairing.
	*
	* @param line
	* The line to extract the function from.
	* @return The key->value pairing of function and parameter(s).
	*/
	public static Map<String, String> extractFunction(String line) {
	Map<String, String> rc = new HashMap<>();
	Pattern pattern = Pattern.compile(FUNCTION, Pattern.CASE_INSENSITIVE);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.find()) {
	rc.put(variableMatcher.group(1), variableMatcher.group(2));
	}
	return rc;
	}

	/**
	* Extract the key->value pairing from an associative assignment.
	*
	* @param line
	* The line to extract the function from.
	* @return The key->value pairing of function and parameter(s).
	*/
	public static Map<String, String> extractKeyValueAssociation(String line) {
	Map<String, String> rc = new HashMap<>();
	String key = "";
	String value = "";
	if (matchesAssociativeAssignment(line)) {
	String[] keyValue = line.split("=>");
	key = cleanUpString(keyValue[0].toLowerCase());
	value = cleanUpString(keyValue[1]);
	rc.put(key, value);
	}
	return rc;
	}

	/**
	* Utility to go through the map of variables to clean up their values.
	*
	* @param variables
	* The map of variables to go through.
	*/
	private static void cleanupVariables(Map<String, String> variables) {
	String val = "";
	for (Entry<String,String> entry : variables.entrySet()) {
	val = cleanUpString(removeVariableSigils(entry.getValue()))
	.trim();
	if (val.startsWith("(") \|\| val.startsWith("[")
	\|\| val.startsWith("{")) {
	val = val.substring(1);
	}
	if (val.endsWith(")") \|\| val.endsWith("]") \|\| val.endsWith("}")) {
	val = val.substring(0, val.length() - 1);
	}
	val = cleanUpString(val);
	variables.put(entry.getKey(), val);
	}
	}

	/**
	* Utility to clean up the line of some unwanted characters.
	*
	* @param line
	* The line to clean up.
	* @return The cleaned up version of the line.
	*/
	private static String cleanUpString(String line) {
	line = line.trim().replaceAll("('\|\")", "");
	if (line.endsWith(";")) {
	line = line.substring(0, line.length() - 1);
	}
	if (line.endsWith(",")) {
	line = line.substring(0, line.length() - 1);
	}
	return line;
	}

	/**
	* Remove the variable sigils.
	*
	* @param variable
	* The variable to remove sigils from.
	* @return A word only variable with no sigils.
	*/
	public static String removeVariableSigils(String variable) {
	return variable
	.replaceAll(
	"(\\bmy\\b\|\\bour\\b\|\\blocal\\b\|(\\\\)?\\$\|(\\\\)?@\|(\\\\)?%)",
	"");
	}

	/**
	* Clean up the contents of the file and remove all the comments, END
	* blocks, and block comments.
	*
	* @param scanner
	* The scanner of the file to be read.
	* @return The cleaned up content.
	*/
	private static String cleanUpContent(Scanner scanner) {
	String rc = "";
	String line = "";
	boolean flagEND = true;
	boolean flagBC = true;
	while (scanner.hasNext()) {
	line = scanner.nextLine();
	// ignore lines between ENDS
	if (containsBeginEND(line)) {
	flagEND = false;
	} else if (matchesEndEND(line)) {
	line = scanner.nextLine();
	flagEND = true; // true
	}
	// ignore lines between =someword and =cut
	if (matchesBeginBC(line)) {
	flagBC = false;
	} else if (matchesEndBC(line)) {
	line = scanner.nextLine();
	flagBC = true;
	}
	// remove the comments
	if (matchesLineWithComment(line)) {
	line = line.replaceAll(COMMENT, "");
	}
	// if not empty line or within comment/END block
	if (flagEND && flagBC && !line.trim().equals("")) {
	rc = rc.concat(line + '\n');
	}
	}
	return rc;
	}

	/**
	* Check if a line contains a function.
	*
	* @param line
	* The line to check.
	* @return True if the line contains a function.
	*/
	public static boolean containsFunction(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile(FUNCTION, Pattern.CASE_INSENSITIVE);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.find()) {
	rc = true;
	}
	return rc;
	}

	/**
	* Check to see if the line contains the WriteMakefile function.
	*
	* @param line
	* The line to check.
	* @return True if the line contains the WriteMakefile function.
	*/
	public static boolean containsMakefileFunction(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile(MAKEFILE_FUNCTION,
	Pattern.CASE_INSENSITIVE);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.find()) {
	rc = true;
	}
	return rc;
	}

	/**
	* Check to see if the line contains an opening bracket.
	*
	* @param line
	* The line to check.
	* @return True if the line contains an opening bracket.
	*/
	public static boolean containsOpener(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile("(\\(\|\\[\|\\{)",
	Pattern.CASE_INSENSITIVE);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.find()) {
	rc = true;
	}
	return rc;
	}

	/**
	* Check if a line contains <<END. It is case-sensitive.
	*
	* @param line
	* The line to check.
	* @return True if the line contains <<END.
	*/
	public static boolean containsBeginEND(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile(BEGIN_END);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.find()) {
	rc = true;
	}
	return rc;
	}

	/**
	* Check if a line is a simple assignment of a variable.
	*
	* @param line
	* The line to check.
	* @return True if the line is a simple assignment of a variable.
	*/
	public static boolean matchesSimpleAssignment(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile(SIMPLE_ASSIGNMENT,
	Pattern.CASE_INSENSITIVE);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.matches()) {
	rc = true;
	}
	return rc;
	}

	/**
	* Check if a line is a simple assignment of a variable.
	*
	* @param line
	* The line to check.
	* @return True if the line is a simple assignment of a variable.
	*/
	public static boolean matchesAssociativeAssignment(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile(ASSOCIATIVE_ASSIGNMENT,
	Pattern.CASE_INSENSITIVE);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.matches()) {
	rc = true;
	}
	return rc;
	}

	/**
	* Check if a line matches the END. It is case-sensitive.
	*
	* @param line
	* The line to check.
	* @return True if the line matches END.
	*/
	public static boolean matchesEndEND(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile(END_END);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.matches()) {
	rc = true;
	}
	return rc;
	}

	/**
	* Check if a line matches the beginning of a block comment. It is
	* case-sensitive.
	*
	* @param line
	* The line to check.
	* @return True if the line matches the beginning of a block comment.
	*/
	public static boolean matchesBeginBC(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile(BEGIN_BC);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.matches()) {
	rc = true;
	}
	return rc;
	}

	/**
	* Check if a line matches the end of a block comment (=cut). It is
	* case-sensitive.
	*
	* @param line
	* The line to check.
	* @return True if the line matches =cut.
	*/
	public static boolean matchesEndBC(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile(END_BC);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.matches()) {
	rc = true;
	}
	return rc;
	}

	/**
	* Check if a line matches that of a line with a comment.
	*
	* @param line
	* The line to check.
	* @return True if the line matches that of a line with a comment.
	*/
	public static boolean matchesLineWithComment(String line) {
	boolean rc = false;
	Pattern pattern = Pattern.compile(LINE_WITH_COMMENT,
	Pattern.CASE_INSENSITIVE);
	Matcher variableMatcher = pattern.matcher(line);
	if (variableMatcher.matches()) {
	rc = true;
	}
	return rc;
	}
	}