eneller/GdBShell
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

recoded array handling

Browse Source
This commit is contained in:
eneller
2020-08-13 00:17:32 +02:00
parent e6f12cef97
commit 57d54e9916
1 changed files with 397 additions and 504 deletions
Download Patch File Download Diff File Expand all files Collapse all files

325
GdBShell.java
View File

@@ -1,15 +1,14 @@
import static cTools.KernelWrapper.*; //imports a Java Wrapper for C kernel functions, needs the sourced source_me
import java.util.ArrayList;
import java.util.Scanner;
import java.lang.*;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException; import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.nio.charset.StandardCharsets; import java.util.Scanner;
import static cTools.KernelWrapper.*;
//TODO find why some calls dont terminate
//TODO switch case for printcolor
//TODO clean up ugly array handling that accounts for most of the lines
//TODO remove stringbuilders/buffers because they are unnecessary //TODO remove stringbuilders/buffers because they are unnecessary
//TODO implement auto source? //TODO implement auto source?
@@ -51,40 +50,18 @@ public class main{
String input = scn.nextLine();//get input String input = scn.nextLine();//get input
String[] inputArray = input.split(" "); String[] inputArray = input.split("\\s+");//split at whitespace characters such as tabs and spaces
//get rid of spaces and tabs
int countInputs = 0;
int[] countArray = new int[inputArray.length];
//count all inputs that actually contain something and put them in a new array in the second for loop
for (int i =0;i< inputArray.length;i++){
if (inputArray[i].equals(" ")||inputArray[i].equals(" ")||inputArray[i].equals("")){
;
}
else{
countArray[countInputs]=i;
countInputs++;
}
}
//System.out.println(Arrays.toString(countArray));
String[] returnArray = new String[countInputs];
for (int i=0; i<countInputs;i++){
returnArray[i]= inputArray[(countArray[i])];
}
return returnArray; return inputArray;
//return replaceCat(returnArray);
} }
static void parseInput(String[] inputArray) { static void parseInput(String[] inputArray) {
//System.out.println(inputArray.length + Arrays.toString(inputArray));
//check for empty inputs //check for empty inputs
if (inputArray.length<=1){ if (inputArray.length == 0) {
if(inputArray.length==0){return;} return;
if(inputArray[0].equals(" ")){return;}
if(inputArray[0].equals(" ")){return;}
} }
//implements the exit terminal function //implements the exit terminal function
@@ -92,119 +69,63 @@ public class main{
if (inputArray.length == 1) { if (inputArray.length == 1) {
printColor("Session ended by user", "red", true); printColor("Session ended by user", "red", true);
System.exit(0); System.exit(0);
} } else {
else{
printColor("\"exit\" doesn't take parameters. It will end this current shell. Did you try to find a different executable?", "red", true); printColor("\"exit\" doesn't take parameters. It will end this current shell. Did you try to find a different executable?", "red", true);
return; return;
} }
} }
String[][] commandsArr = splitArray(inputArray, "&&");
//find concats with && in input and execute only if previous command was successful int prevValue;//saves the return code of the previously executed command
ArrayList<Integer> concatPosition = new ArrayList<Integer>();
//save the positions of concats
for (int i=0; i<inputArray.length;i++){
if(inputArray[i].equals("&&")){
concatPosition.add(i);
}
}
/* int i = 0;//allows to save the command position
//for testing***************, prints the positions of the concats
for (int i=0;i<concatPosition.size();i++){
printColor(Integer.toString(concatPosition.get(i))+" ","yellow",false);
}
//************************** //execute single commands here
*/
//if there are any concats prevValue = parseRedirect(commandsArr[i]);
if(concatPosition.size()>0){ i = 1;
//split the inputArray into singular commands that were separated by &&
ArrayList<ArrayList<String>> commandsList = new ArrayList<ArrayList<String>>();
for (int i=0;i<concatPosition.size()+1;i++){
commandsList.add( new ArrayList<String>());
}
//upper Arraylist used with fixed size, doesnt throw warning like using an array would
//because one concat splits the input into two parts --->+1
//iterate over every command except last, because no concat comes after the last one
int prevConcatPos=0;
for (int i=0;i<concatPosition.size();i++){
for(int j=prevConcatPos;j<concatPosition.get(i);j++){
(commandsList.get(i)).add(inputArray[j]);
}
prevConcatPos=concatPosition.get(i)+1;
}
//add last command
for (int i=concatPosition.get(concatPosition.size()-1)+1;i<inputArray.length;i++){
(commandsList.get(commandsList.size()-1)).add(inputArray[i]);
}
//execute commands in commandsList if previous command was successful, ie terminated with code 0
int returnValue = 0;
for(int i=0;i<commandsList.size();i++){
//if previous command successful
if (returnValue==0){
//build array from arraylist that contains command
String[] command = new String[commandsList.get(i).size()];
for (int j=0;j<command.length;j++){
command[j]= commandsList.get(i).get(j);
}
//execute command and save return value
returnValue = parseRedirect(command);
}
//if it wasnt successful
else{
//build command as string that wasnt succcessful
int failedCommandNumber = i-1;
StringBuffer buffer = new StringBuffer();
for (int j=0;j<commandsList.get(failedCommandNumber).size();j++){
buffer.append(commandsList.get(failedCommandNumber).get(j));
}
printColor("Stopped concatenation at command number "+ failedCommandNumber +" \""+buffer.toString()+"\"","red",true); boolean singleCommand = true;
if(returnValue==Integer.MIN_VALUE){ //execute possible concatenations
printColor("Couldn't find executable assigned to \""+ commandsList.get(failedCommandNumber).get(0)+"\"","red",true); for (; i < commandsArr.length; i++) {
} singleCommand = false;
else{ //execute if previous command was successful, else do error printing
printColor("Exited with error code "+returnValue,"red",true);
}
if (prevValue == 0) {
printColor("Process exited without error", "green", true);
prevValue = parseRedirect(commandsArr[i]);
} else {
break; break;
} }
} }
} if (prevValue == 0) {
// if its only one command without concats
else{
int returnValue = parseRedirect(inputArray);
if (returnValue==0){
printColor("Process exited without error", "green", true); printColor("Process exited without error", "green", true);
} else {
if (singleCommand == false) {
printColor("Stopped concatenation at command number " + (i - 1) + " \"" + String.join(" ", commandsArr[i - 1]) + "\":", "red", true);
} }
else{ switch (prevValue) {
if(returnValue == Integer.MIN_VALUE){ //TODO add the internal error codes to print useful messages
printColor("Couldn't find executable assigned to \""+ inputArray[0]+"\"","red",true); case Integer.MIN_VALUE + 1://from execute()
} printColor("Entered empty command", "red", true);
else{ break;
printColor("Process exited with code "+ returnValue,"red",true); case Integer.MIN_VALUE://from execute
printColor("Couldn't find executable assigned to \"" + commandsArr[i - 1][0] + "\"", "red", true);
break;
default:
printColor("Exited with error code " + prevValue, "red", true);//everything else
} }
} }
}
return;//TODO clean up error messages
return;
} }
static int parseRedirect(String[] inputArray) {//should take pipe and read/write,, add >> for append? static int parseRedirect(String[] inputArray) {//should take pipe and read/write,, add >> for append?
@@ -234,25 +155,26 @@ public class main{
} }
//TODO look up error return value of OPEN to separate from no redirect initialized as -1
int fd_in = -1; int fd_in = -1;
if (redirectInPos != -1) { if (redirectInPos != -1) {
if (checkls(inputArray[redirectInPos + 1])) { if (checkls(inputArray[redirectInPos + 1])) {
fd_in = open(inputArray[redirectInPos + 1], O_RDONLY); fd_in = open(inputArray[redirectInPos + 1], O_RDONLY);
} } else {
else{return -10;}//throw error because invalid input file return -10;
}//throw error because invalid input file
} }
int fd_out = -1; int fd_out = -1;
if (redirectOutPos != -1) { if (redirectOutPos != -1) {
fd_out = open(inputArray[redirectOutPos+1],O_WRONLY|O_CREAT|O_TRUNC);//create file if non existent, overwrite if it is fd_out = open(inputArray[redirectOutPos + 1], O_WRONLY | O_CREAT | O_TRUNC);//overwrite file if exists, create else
} }
String[] commands = new String[firstPos]; String[] command = Arrays.copyOfRange(inputArray, 0, firstPos);
for (int i=0;i< commands.length;i++){
commands[i]=inputArray[i]; int returnValue = parsePipe(command, fd_in, fd_out);
}
int returnValue= parsePipe(commands,fd_in,fd_out); //close potential files
if (fd_in != -1) { if (fd_in != -1) {
close(fd_in); close(fd_in);
} }
@@ -264,67 +186,41 @@ public class main{
} }
static int parsePipe(String[] inputArray, int fd_in, int fd_out) { static int parsePipe(String[] inputArray, int fd_in, int fd_out) {
int returnValue = -5;
ArrayList<Integer> pipePos = new ArrayList<Integer>();
int count =0;
for (int i =0;i< inputArray.length; i++){
if (inputArray[i].equals("|")){
pipePos.add(count);
count=0;
} String[][] command = splitArray(inputArray, "|");
else{count++;}
}
pipePos.add(count);
//populate array of commands separated by |
String[][] commands = new String[pipePos.size()][];
int prevPipePos = 0;
for (int i=0;i< pipePos.size();i++){
commands[i] = new String[pipePos.get(i)];
for (int j=0;j<commands[i].length;j++){
commands[i][j]=inputArray[j+prevPipePos];
}
prevPipePos = prevPipePos + pipePos.get(i)+1;
}
//execute commands //execute commands
int returnValue;
//first command gets stdin //first command gets stdin
int lastIn = -1; int lastIn = -1;
int[] pipefd = new int[2]; int[] pipefd = new int[2];
if(commands.length>1){ if (command.length > 1) {
pipe(pipefd); pipe(pipefd);
returnValue= execute(commands[0],fd_in,pipefd[1]); returnValue = execute(command[0], fd_in, pipefd[1]);
for(int i=1;i<commands.length-1;i++){ for (int i = 1; i < command.length - 1; i++) {
returnValue = execute(commands[i],pipefd[0],pipefd[1]); returnValue = execute(command[i], pipefd[0], pipefd[1]);
} }
lastIn = pipefd[0]; lastIn = pipefd[0];
System.err.println("here"); } else {
}
else{
lastIn = fd_in; lastIn = fd_in;
} }
// execute last (or only) command // execute last (or only) command
returnValue = execute(commands[commands.length-1],lastIn,fd_out); returnValue = execute(command[command.length - 1], lastIn, fd_out);
return returnValue; return returnValue;
} }
static int execute(String[] inputArray, int fd_in, int fd_out) {//0 for read, 1 for write static int execute(String[] inputArray, int fd_in, int fd_out) {//0 for read, 1 for write
int[] intArray = new int[]{Integer.MIN_VALUE};//to pass to the waitpid function int[] intArray = new int[]{Integer.MIN_VALUE};//to pass to the waitpid function
//split the Array into path and arguments //split the Array into path and arguments
//tries to find the executable at first position of input //tries to find the executable at first position of input
String path = null; String path = null;
if (inputArray.length!=0){ if (inputArray.length > 0) {
String input = inputArray[0]; String input = inputArray[0];
/* /*
@@ -337,23 +233,18 @@ public class main{
else{*/ else{*/
path = which(input); path = which(input);
//} //}
} } else {
else{return Integer.MIN_VALUE+1;}// add error in parseInput for this number return Integer.MIN_VALUE + 1;
}// internal error code
//if path found, compile argslist and start execv //if path found, compile argslist and start execv
if (isNumeric(path) == false) { if (isNumeric(path) == false) {
printColor("Executing program at " + path, "green", true); printColor("Executing program at " + path, "green", true);
//System.out.println();
//int[] pipeArray = new int[]{0};//sets the pip
int forkInt = fork();// saves the return value because every call will fork the process again int forkInt = fork();// saves the return value because every call will fork the process again
//baby process //baby process
if (forkInt == 0) { if (forkInt == 0) {
//Array[0] mit rest als parameter ausführen (path, args[]) //Array[0] mit rest als parameter ausführen (path, args[])
@@ -381,12 +272,33 @@ public class main{
waitpid(forkInt, intArray, 0); waitpid(forkInt, intArray, 0);
//read from pipe HEEERE???
} }
} }
return intArray[0]; return intArray[0];
} }
public static ArrayList<Integer> findArrayOccurrence(Object[] oArr, Object o) {
ArrayList<Integer> aList = new ArrayList<Integer>();
for (int i = 0; i < oArr.length; i++) {
if (oArr[i].equals(o)) {
aList.add(i);
}
}
return aList;
}
public static String[][] splitArray(String[] oArr, String o) {
ArrayList<Integer> aList = findArrayOccurrence(oArr, o);
aList.add(oArr.length);//emulate occurence of split object behind last array element to make handling easier in the for loop
String[][] sArr = new String[aList.size()][];
int prevOcc = 0;
for (int i = 0; i < aList.size(); i++) {
sArr[i] = Arrays.copyOfRange(oArr, prevOcc, aList.get(i));
prevOcc = aList.get(i) + 1;
}
return sArr;
}
public static String which(String arguments) { public static String which(String arguments) {
@@ -394,8 +306,6 @@ public class main{
prcBuilder.command("bash", "-c", "which " + arguments); prcBuilder.command("bash", "-c", "which " + arguments);
try { try {
Process process = prcBuilder.start(); Process process = prcBuilder.start();
@@ -411,28 +321,21 @@ public class main{
String path = buffer.toString(); String path = buffer.toString();
if (path.contains("/")) { if (path.contains("/")) {
return path; return path;
} } else {
else{
int exitCode = process.waitFor(); int exitCode = process.waitFor();
return Integer.toString(exitCode); return Integer.toString(exitCode);
//System.out.println("\nExited with error code : " + exitCode); //System.out.println("\nExited with error code : " + exitCode);
} }
} } catch (IOException e) {
catch (IOException e) { printColor("err1", "red", true);
printColor("err1","red",true); //e.toString(); } catch (InterruptedException e) {
} printColor("err2", "red", true);
catch (InterruptedException e) {
printColor("err2","red",true); //e.toString();
} }
return "t"; return "t";
} }
public static boolean checkls(String input) { public static boolean checkls(String input) {
//check what ls does in this program if executed locally //check what ls does in this program if executed locally
@@ -448,13 +351,11 @@ public class main{
buffer1.append("/"); buffer1.append("/");
} }
} }
//System.out.println(buffer1);
ProcessBuilder prcBuilder = new ProcessBuilder(); ProcessBuilder prcBuilder = new ProcessBuilder();
prcBuilder.command("bash", "-c", "ls " + buffer1.toString()); prcBuilder.command("bash", "-c", "ls " + buffer1.toString());
try { try {
Process process = prcBuilder.start(); Process process = prcBuilder.start();
@@ -472,20 +373,15 @@ public class main{
//printColor(path,"yellow",true);//for test purposes //printColor(path,"yellow",true);//for test purposes
if (path.contains(checkfile)) { if (path.contains(checkfile)) {
return true; return true;
} } else {
else{
int exitCode = process.waitFor(); int exitCode = process.waitFor();
return false; return false;
//System.out.println("\nExited with error code : " + exitCode); //System.out.println("\nExited with error code : " + exitCode);
} }
} } catch (IOException e) {
catch (IOException e) { printColor("err1", "red", true);
printColor("err1","red",true); //e.toString(); } catch (InterruptedException e) {
} printColor("err2", "red", true);
catch (InterruptedException e) {
printColor("err2","red",true); //e.toString();
} }
return false; return false;
@@ -494,11 +390,9 @@ public class main{
public static boolean isNumeric(String toCheck) { public static boolean isNumeric(String toCheck) {
try { try {
double d = Double.parseDouble(toCheck); double d = Double.parseDouble(toCheck);
} } catch (NumberFormatException nsfw) {
catch(NumberFormatException nsfw){
return false; return false;
} } catch (NullPointerException npe) {
catch(NullPointerException npe){
return false; return false;
} }
return true; return true;
@@ -506,7 +400,6 @@ public class main{
} }
static boolean printColor(String text, String colorvar, boolean lineBreak) {// maybe rainbow?? static boolean printColor(String text, String colorvar, boolean lineBreak) {// maybe rainbow??
//takes two Strings and one boolean that specify the text to print, the color and if there should be a linebreak (ie print or println) //takes two Strings and one boolean that specify the text to print, the color and if there should be a linebreak (ie print or println)
@@ -549,14 +442,15 @@ public class main{
color = ANSI_GREEN; color = ANSI_GREEN;
break; break;
default: returnBool = false; default:
returnBool = false;
} }
System.out.print(color + text + ANSI_RESET); System.out.print(color + text + ANSI_RESET);
if (lineBreak) { if (lineBreak) {
System.out.println(""); System.out.println();
} }
return returnBool; return returnBool;
} }
@@ -572,13 +466,12 @@ public class main{
} }
return changed; return changed;
} else {
return args;
} }
else{return args;}
} }
} }