From ffdeed6d39f651bc6ffb75ecf9b8134798041f82 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Mon, 9 Sep 2019 20:13:50 -0400 Subject: Upgrade version to 0.2 --- docs/jacoco-ut/bjc.everge/Everge.java.html | 453 ++++++++++++++--------------- 1 file changed, 223 insertions(+), 230 deletions(-) (limited to 'docs/jacoco-ut/bjc.everge/Everge.java.html') diff --git a/docs/jacoco-ut/bjc.everge/Everge.java.html b/docs/jacoco-ut/bjc.everge/Everge.java.html index 8416daa..82fd293 100644 --- a/docs/jacoco-ut/bjc.everge/Everge.java.html +++ b/docs/jacoco-ut/bjc.everge/Everge.java.html @@ -1,84 +1,77 @@ Everge.java

Everge.java

package bjc.everge;
 
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.PrintStream;
+import java.io.*;
 
 import java.nio.charset.Charset;
 
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
+import java.nio.file.*;
 
-import java.util.ArrayList;
-import java.util.Deque;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Scanner;
+import java.util.*;
 
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.concurrent.locks.*;
 
-import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
+import java.util.regex.*;
 
 /**
  * Everge front-end application.
  *
  * @author Ben Culkin
  */
-public class Everge {
+public class Everge {
 	/**
 	 * Details how we handle our input.
 	 */
-	public static enum InputStatus {
+	public static enum InputStatus {
 		/**
 		 * Process the input as a single string.
 		 */
-		ALL,
+		ALL,
 		/**
 		 * Process the input line-by-line.
 		 */
-		LINE,
+		LINE,
 		/**
 		 * Process the input, splitting it around occurances of a regex.
 		 */
-		REGEX;
+		REGEX;
 	}
 
 	// Options for doing repl-pairs
-	private ReplOpts ropts = new ReplOpts();
+	private ReplOpts ropts = new ReplOpts();
 
 	// Loaded repl-pairs
-	private List<ReplPair> lrp = new ArrayList<>();
+	private List<ReplPair> lrp = new ArrayList<>();
 
 	// Input status
-	private InputStatus inputStat = InputStatus.ALL;
+	private InputStatus inputStat = InputStatus.ALL;
 
 	// Are we processing CLI args? (haven't seen a -- yet)
-	private boolean doingArgs = true;
+	private boolean doingArgs = true;
 
 	// Should an NL be printed after each replace?
-	private boolean printNL = true;
+	private boolean printNL = true;
 
 	// Verbosity level
-	private int verbosity = 0;
+	private int verbosity = 0;
 
 	// The pattern to use for REGEX input mode
 	private String pattern;
 
 	// The queue of arguments to process
-	private Deque<String> argQue = new LinkedList<>();
+	private Deque<String> argQue = new LinkedList<>();
 
 	// Used to prevent inter-mixing argument alterations with input processing.
-	private ReadWriteLock argLock = new ReentrantReadWriteLock();
+	private ReadWriteLock argLock = new ReentrantReadWriteLock();
 
 	// Input/output streams
-	public PrintStream outStream = System.out;
-	public PrintStream errStream = System.err;
+	/**
+	 * Stream to use for normal output.
+	 */
+	public PrintStream outStream = System.out;
+	/**
+	 * Stream to use for error output.
+	 */
+	public PrintStream errStream = System.err;
 
 	/**
 	 * Main method for front end,
@@ -87,10 +80,10 @@ import java.util.regex.PatternSyntaxException;
 	 * 		The CLI arguments.
 	 */
 	public static void main(String[] args) {
-		Everge evg = new Everge();
+		Everge evg = new Everge();
 
-		evg.processArgs(args);
-	}
+		evg.processArgs(args);
+	}
 
 	/**
 	 * Process one or more command line arguments.
@@ -100,16 +93,16 @@ import java.util.regex.PatternSyntaxException;
 	 * @return Whether we processed succesfully or not.
 	 */
 	public boolean processArgs(String... args) {
-		List<String> errs = new ArrayList<>();
+		List<String> errs = new ArrayList<>();
 
-		boolean stat = processArgs(errs, args);
-		if (!stat) {
-			for (String err : errs) {
-				errStream.println(err);
-			}
+		boolean stat = processArgs(errs, args);
+		if (!stat) {
+			for (String err : errs) {
+				errStream.println(err);
+			}
 		}
 
-		return stat;
+		return stat;
 	}
 
 	/**
@@ -122,185 +115,185 @@ import java.util.regex.PatternSyntaxException;
 	 * @return Whether we processed succesfully or not.
 	 */
 	public boolean processArgs(List<String> errs, String... args) {
-		argLock.writeLock().lock();
+		argLock.writeLock().lock();
 
-		boolean retStat = true;
+		boolean retStat = true;
 
 		try {
-			loadQueue(args);
+			loadQueue(args);
 
 			// Process CLI args
-			while(argQue.size() > 0) {
-				String arg = argQue.pop();
+			while(argQue.size() > 0) {
+				String arg = argQue.pop();
 
-				if (arg.equals("--")) {
-					doingArgs = false;
-					continue;
+				if (arg.equals("--")) {
+					doingArgs = false;
+					continue;
 				}
 
 				// Process an argument
-				if (doingArgs && arg.startsWith("-")) {
-					String argName = arg;
-					String argBody = "";
+				if (doingArgs && arg.startsWith("-")) {
+					String argName = arg;
+					String argBody = "";
 
 					// Process arguments to arguments 
-					int idx = arg.indexOf("=");
-					if (idx != -1) {
-						argName = arg.substring(0, idx);
-						argBody = arg.substring(idx + 1);
+					int idx = arg.indexOf("=");
+					if (idx != -1) {
+						argName = arg.substring(0, idx);
+						argBody = arg.substring(idx + 1);
 					}
 
-					switch (argName) {
+					switch (argName) {
 					case "-n":
 					case "--newline":
-						printNL = true;
-						break;
+						printNL = true;
+						break;
 					case "-N":
 					case "--no-newline":
-						printNL = false;
-						break;
+						printNL = false;
+						break;
 					case "-v":
 					case "--verbose":
-						verbosity += 1;
-						break;
+						verbosity += 1;
+						break;
 					case "-q":
 					case "--quiet":
-						verbosity -= 1;
-						break;
+						verbosity -= 1;
+						break;
 					case "--verbosity":
-						if (argQue.size() < 1) {
-							errs.add("[ERROR] No parameter to --verbosity");
-							retStat = false;
-							break;
+						if (argQue.size() < 1) {
+							errs.add("[ERROR] No parameter to --verbosity");
+							retStat = false;
+							break;
 						}
-						argBody = argQue.pop();
-						break;
+						argBody = argQue.pop();
+						break;
 					case "-V":
 						try {
-							verbosity = Integer.parseInt(argBody);
-						} catch (NumberFormatException nfex) {
-							String msg = String.format("[ERROR] Invalid verbosity: '%s' is not an integer",
+							verbosity = Integer.parseInt(argBody);
+						} catch (NumberFormatException nfex) {
+							String msg = String.format("[ERROR] Invalid verbosity: '%s' is not an integer",
 									argBody);
-							errs.add(msg);
-							retStat = false;
-						}
-						break;
+							errs.add(msg);
+							retStat = false;
+						}
+						break;
 					case "--pattern":
-						if (argQue.size() < 1) {
-							errs.add("[ERROR] No parameter to --pattern");
-							retStat = false;
-							break;
+						if (argQue.size() < 1) {
+							errs.add("[ERROR] No parameter to --pattern");
+							retStat = false;
+							break;
 						}
-						argBody = argQue.pop();
+						argBody = argQue.pop();
 					case "-p":
 						try {
-							pattern = argBody;
-
-							Pattern.compile(argBody);
-						} catch (PatternSyntaxException psex) {
-							String msg = String.format("[ERROR] Pattern '%s' is invalid: %s",
-									pattern, psex.getMessage());
-							errs.add(msg);
-							retStat = false;
-						}
-						break;
+							pattern = argBody;
+
+							Pattern.compile(argBody);
+						} catch (PatternSyntaxException psex) {
+							String msg = String.format("[ERROR] Pattern '%s' is invalid: %s",
+									pattern, psex.getMessage());
+							errs.add(msg);
+							retStat = false;
+						}
+						break;
 					case "--file":
-						if (argQue.size() < 1) {
-							errs.add("[ERROR] No argument to --file");
-							retStat = false;
-							break;
+						if (argQue.size() < 1) {
+							errs.add("[ERROR] No argument to --file");
+							retStat = false;
+							break;
 						}
-						argBody = argQue.pop();
+						argBody = argQue.pop();
 					case "-f":
-						try (FileInputStream fis = new FileInputStream(argBody);
-								Scanner scn = new Scanner(fis)) {
-							List<ReplError> ferrs = new ArrayList<>();
+						try (FileInputStream fis = new FileInputStream(argBody);
+								Scanner scn = new Scanner(fis)) {
+							List<ReplError> ferrs = new ArrayList<>();
 
-							lrp = ReplPair.readList(lrp, scn, ferrs, ropts);
+							lrp = ReplPair.readList(lrp, scn, ferrs, ropts);
 
-							if (ferrs.size() > 0) {
-								StringBuilder sb = new StringBuilder();
+							if (ferrs.size() > 0) {
+								StringBuilder sb = new StringBuilder();
 								
-								String errString = "an error";
-								if (ferrs.size() > 1) errString = String.format("%d errors");
+								String errString = "an error";
+								if (ferrs.size() > 1) errString = String.format("%d errors");
 
 								{
-									String msg = String.format(
-											"[ERROR] Encountered errors parsing data file'%s'\n",
-											argBody);
-									sb.append(msg);
+									String msg = String.format(
+											"[ERROR] Encountered %s parsing data file'%s'\n",
+											errString, argBody);
+									sb.append(msg);
 								}
 
-								for (ReplError err : ferrs) {
-									sb.append(String.format("\t%s\n", err));
-								}
+								for (ReplError err : ferrs) {
+									sb.append(String.format("\t%s\n", err));
+								}
 
-								errs.add(sb.toString());
-								retStat = false;
+								errs.add(sb.toString());
+								retStat = false;
 							}
-						} catch (FileNotFoundException fnfex) {
-							String msg = String.format("[ERROR] Could not open data file '%s' for input",
+						} catch (FileNotFoundException fnfex) {
+							String msg = String.format("[ERROR] Could not open data file '%s' for input",
 									argBody);
-							errs.add(msg);
-							retStat = false;
-						} catch (IOException ioex) {
-							String msg = String.format("[ERROR] Unknown I/O error reading data file '%s': %s",
-									argBody, ioex.getMessage());
-							errs.add(msg);
-							retStat = false;
-						}
-						break;
+							errs.add(msg);
+							retStat = false;
+						} catch (IOException ioex) {
+							String msg = String.format("[ERROR] Unknown I/O error reading data file '%s': %s",
+									argBody, ioex.getMessage());
+							errs.add(msg);
+							retStat = false;
+						}
+						break;
 					case "--arg-file":
-						if (argQue.size() < 1) {
-							errs.add("[ERROR] No argument to --arg-file");
-							break;
+						if (argQue.size() < 1) {
+							errs.add("[ERROR] No argument to --arg-file");
+							break;
 						}
-						argBody = argQue.pop();
+						argBody = argQue.pop();
 					case "-F":
-						try (FileInputStream fis = new FileInputStream(argBody);
-								Scanner scn = new Scanner(fis)) {
-							List<String> sl = new ArrayList<>();
-
-							while (scn.hasNextLine()) {
-								String ln = scn.nextLine().trim();
-
-								if (ln.equals(""))      continue;
-								if (ln.startsWith("#")) continue;
-
-								sl.add(ln);
-							}
-
-							processArgs(sl.toArray(new String[0]));
-						} catch (FileNotFoundException fnfex) {
-							String msg = String.format("[ERROR] Could not open argument file '%s' for input", argBody);
-							errs.add(msg);
-							retStat = false;
-						} catch (IOException ioex) {
-							String msg = String.format("[ERROR] Unknown I/O error reading input file '%s': %s",
-									argBody, ioex.getMessage());
-							errs.add(msg);
-							retStat = false;
-						}
-						break;
+						try (FileInputStream fis = new FileInputStream(argBody);
+								Scanner scn = new Scanner(fis)) {
+							List<String> sl = new ArrayList<>();
+
+							while (scn.hasNextLine()) {
+								String ln = scn.nextLine().trim();
+
+								if (ln.equals(""))      continue;
+								if (ln.startsWith("#")) continue;
+
+								sl.add(ln);
+							}
+
+							processArgs(sl.toArray(new String[0]));
+						} catch (FileNotFoundException fnfex) {
+							String msg = String.format("[ERROR] Could not open argument file '%s' for input", argBody);
+							errs.add(msg);
+							retStat = false;
+						} catch (IOException ioex) {
+							String msg = String.format("[ERROR] Unknown I/O error reading input file '%s': %s",
+									argBody, ioex.getMessage());
+							errs.add(msg);
+							retStat = false;
+						}
+						break;
 					default:
 						{
-							String msg = String.format("[ERROR] Unrecognised CLI argument name '%s'\n", argName);
-							errs.add(msg);
-							retStat = false;
+							String msg = String.format("[ERROR] Unrecognised CLI argument name '%s'\n", argName);
+							errs.add(msg);
+							retStat = false;
 						}
 					}
-				} else {
+				} else {
 					// Strip off an escaped initial dash
-					if (arg.startsWith("\\-")) arg = arg.substring(1);
+					if (arg.startsWith("\\-")) arg = arg.substring(1);
 
-					processInputFile(arg);
+					processInputFile(arg);
 				}
-			}
+			}
 		} finally {
-			argLock.writeLock().unlock();
+			argLock.writeLock().unlock();
 		}
 
-		return retStat;
+		return retStat;
 	}
 
 	/**
@@ -311,16 +304,16 @@ import java.util.regex.PatternSyntaxException;
 	 * @return Whether we processed succesfully or not.
 	 */
 	public boolean processInputFile(String fle) {
-		List<String> errs = new ArrayList<>();
+		List<String> errs = new ArrayList<>();
 
-		boolean stat = processInputFile(errs, fle);
-		if (!stat) {
-			for (String err : errs) {
-				errStream.println(err);
-			}
+		boolean stat = processInputFile(errs, fle);
+		if (!stat) {
+			for (String err : errs) {
+				errStream.println(err);
+			}
 		}
 
-		return stat;
+		return stat;
 	}
 
 	/**
@@ -333,58 +326,58 @@ import java.util.regex.PatternSyntaxException;
 	 * @return Whether we processed succesfully or not.
 	 */
 	public boolean processInputFile(List<String> errs, String fle) {
-		argLock.readLock().lock();
+		argLock.readLock().lock();
 
 		// Read in and do replacements on a file
 		try {
-			if (verbosity > 2) {
-				errStream.printf("[TRACE] Reading file (%s) in mode (%s)\n", fle, inputStat);
+			if (verbosity > 2) {
+				errStream.printf("[TRACE] Reading file (%s) in mode (%s)\n", fle, inputStat);
 			}
 
-			if (inputStat == InputStatus.ALL) {
-				Path pth = Paths.get(fle);
+			if (inputStat == InputStatus.ALL) {
+				Path pth = Paths.get(fle);
 
-				if (!Files.isReadable(pth)) {
-					String msg = String.format("[ERROR] File '%s' is not readable\n", fle);
-					errs.add(msg);
-					return false;
-				} else {
-					byte[] inp = Files.readAllBytes(pth);
+				if (!Files.isReadable(pth)) {
+					String msg = String.format("[ERROR] File '%s' is not readable\n", fle);
+					errs.add(msg);
+					return false;
+				}
 
-					String strang = new String(inp, Charset.forName("UTF-8"));
+				byte[] inp = Files.readAllBytes(pth);
 
-					processString(strang);
-				}
-			} else if (inputStat == InputStatus.LINE) {
-				try (FileInputStream fis = new FileInputStream(fle); Scanner scn = new Scanner(fis)) {
-					while(scn.hasNextLine()) {
-						processString(scn.nextLine());
+				String strang = new String(inp, Charset.forName("UTF-8"));
+
+				processString(strang);
+			} else if (inputStat == InputStatus.LINE) {
+				try (FileInputStream fis = new FileInputStream(fle); Scanner scn = new Scanner(fis)) {
+					while(scn.hasNextLine()) {
+						processString(scn.nextLine());
 					}
-				}
-			} else if (inputStat == InputStatus.REGEX) {
-				try (FileInputStream fis = new FileInputStream(fle); Scanner scn = new Scanner(fis)) {
-					scn.useDelimiter(pattern);
+				}
+			} else if (inputStat == InputStatus.REGEX) {
+				try (FileInputStream fis = new FileInputStream(fle); Scanner scn = new Scanner(fis)) {
+					scn.useDelimiter(pattern);
 
-					while(scn.hasNext()) {
-						processString(scn.next());
+					while(scn.hasNext()) {
+						processString(scn.next());
 					}
-				}
+				}
 			} else {
-				String msg = String.format("[INTERNAL-ERROR] Input status '%s' is not yet implemented\n",
+				String msg = String.format("[INTERNAL-ERROR] Input status '%s' is not yet implemented\n",
 						inputStat);
-				errs.add(msg);
-				return false;
+				errs.add(msg);
+				return false;
 			}
-		} catch (IOException ioex) {
-			String msg = String.format("[ERROR] Unknown I/O related error for file '%s'\n\tError was %s",
-					fle, ioex.getMessage());
-			errs.add(msg);
-			return false;
+		} catch (IOException ioex) {
+			String msg = String.format("[ERROR] Unknown I/O related error for file '%s'\n\tError was %s",
+					fle, ioex.getMessage());
+			errs.add(msg);
+			return false;
 		} finally {
-			argLock.readLock().unlock();
+			argLock.readLock().unlock();
 		}
 
-		return true;
+		return true;
 	}
 
 	/**
@@ -394,43 +387,43 @@ import java.util.regex.PatternSyntaxException;
 	 * 		The input string to process.
 	 */
 	public void processString(String inp) {
-		argLock.readLock().lock();
+		argLock.readLock().lock();
 
 		try {
-			String strang = inp;
+			String strang = inp;
 
-			for (ReplPair rp : lrp) {
-				strang = rp.apply(strang);
-			}
+			for (ReplPair rp : lrp) {
+				strang = rp.apply(strang);
+			}
 
-			outStream.print(strang);
-			if (printNL) outStream.println();
+			outStream.print(strang);
+			if (printNL) outStream.println();
 		} finally {
-			argLock.readLock().unlock();
+			argLock.readLock().unlock();
 		}
-	}
+	}
 
 	// Load arguments into the argument queue.
 	private void loadQueue(String... args) {
-		boolean doArgs = true;
-		for (String arg : args) {
-			if (arg.equals("--")) doArgs = false;
+		boolean doArgs = true;
+		for (String arg : args) {
+			if (arg.equals("--")) doArgs = false;
 
 			// Handle things like -nNv correctly
-			if (doArgs) {
-				if (arg.startsWith("-") && !arg.startsWith("--")) {
-					char[] car = arg.substring(1).toCharArray();
-					for (char c : car) {
-						String argstr = String.format("-%c", c);
-						argQue.add(argstr);
+			if (doArgs) {
+				if (arg.startsWith("-") && !arg.startsWith("--")) {
+					char[] car = arg.substring(1).toCharArray();
+					for (char c : car) {
+						String argstr = String.format("-%c", c);
+						argQue.add(argstr);
 					}
-				} else {
-					argQue.add(arg);
+				} else {
+					argQue.add(arg);
 				}
 			} else {
-				argQue.add(arg);
+				argQue.add(arg);
 			}
 		}
-	}
+	}
 }
Created with JaCoCo 0.8.2.201808211720
\ No newline at end of file -- cgit v1.2.3