Bracket matching using an Array Deque and reading a text file

[Sofia Pineda]

Hi, I would appreciate your help on this assignment. I am trying to match brackets implementing an ArrayDeque for the iterative method. I have trouble with the following, and I have tried answering these questions within my code (most don't work).

1. within the method, should I open the file and read it even if it is already in main? If so, how do I do this again?
2. how to check that the present character read is equivalent to the type of open bracket?
3. how can I save the location of each open bracket (and corresponding closing bracket) such that if there is an error, I can provide a throw/exception indicating the place where the mismatch occurred.
4. how can I assimilate the opening and closing brackets, of the same type?!?!
5. if stack is not empty, I should also throw an exception, but shouldn't this be the same as 3?

I would greatly appreciate some help and insights on my problems! Thanks! =)

This is my code so far:

public void iterativeMatch (FileReader src) throws MatchFail
{
//create stack for brackets using ArrayDeque
ArrayDeque<Character> stack = new ArrayDeque<Character>();
//open file???
int charAsInt = getOneChar(src) ; //retrieves only one character from source code
//while more in file or the file is not empty?
while (charAsInt!=EOF){
//for each word in line
for (int i=0; i<= EOF; i++){
char openbracket1 = '(';
char openbracket2 = '{';
char openbracket3 = '[';
//character read from file
char presentChar = (char) charAsInt ;
//open bracket index
int open = 0;
//closed bracket index
int closed=0;
//if one of the open brackets is read, push into stack
if (openbracket1 == presentChar){
stack.push(openbracket1);
System.out.println(stack);
//save index where open bracket located
}
if (openbracket2 ==presentChar){
stack.push(openbracket2);
//also store index where open bracket located
}
if (openbracket3 == presentChar){
stack.push(openbracket3);
//store index where this open bracket is located
}
char closedbracket1 = ')';
char closedbracket2 = '}';
char closedbracket3 = ']';
//if one of closed bracket, pop
//if not the same/match throw exception that source has mis-matched brackets (give indeces
if (presentChar == closedbracket1){
stack.pop();//how to know if same type of bracket?!?!
//save index of location (in case there is an error?
}
if (presentChar == closedbracket2){
stack.pop();//how to know if same type of bracket?!?!
//save index of location (in case there is an error?
}
if (presentChar == closedbracket3){
stack.pop();//how to know if same type of bracket?!?!
//save index of location (in case there is an error?
}
}
}
//if stack is not empty, throw exception that source has mis-matched brackets
if (!stack.isEmpty()){
throw{
System.out.println("Source has mis-matched brackets from the open bracket"
+ open + "and the closing bracket at" + closed);
}
throw new MatchFail() ;
}
}

This is the code we have been provided for reading a character:

private int getOneChar (FileReader source)
{
int charAsInt = EOF ;
try {
charAsInt = source.read() ;
System.out.println("this is charAsInt= " + charAsInt);
} catch (IOException ex) {
System.out.println("Exception: " + ex) ;
charAsInt = EOF ;
}
return (charAsInt) ;
}

Code for how to use getOneCharacter and throw an exception:

int charAsInt = getOneChar(src) ;
if (charAsInt != EOF) {
char firstChar = (char) charAsInt ;
System.out.println(
"The first character of the file is '" + firstChar + "'.") ;
} else {
System.out.println("This file is empty!") ;
}
throw new MatchFail("You mu create stack of Character (used to save whicj type of open bracket was seen) Match!",42, //really don't know what this is for!!!
Character.toString('}'),42) ;
}

and finally, the main within myassignment class to open the files:

public static void main(String[] args) {
if (args.length <= 0) {
System.out.println("Usage: java Assign4 <filename>") ;
System.exit(1) ;
}
String fileName = args[0] ;
File handle = new File(fileName) ;
if (!(handle.exists() && handle.canRead())) {
System.out.println("Please check that file \"" + fileName
+ "\" exists and is readable.") ;
System.exit(2) ;
}
/*
* Create an input stream of type FileReader to read the file character
* by character.
*/
FileReader src = null ;
try {
src = new FileReader(handle) ;
} catch (IOException ex) {
System.out.println("Exception while opening file \"" +
fileName + "\" for read.") ;
System.out.println("Exception: " + ex) ;
try {
if (src != null) src.close() ;
} catch (IOException closeEx) {
System.out.println(
"Exception while closing file \"" + fileName + "\".") ;
System.out.println("Exception: " + closeEx) ;
}
System.exit(3) ;
}
/*
* We need to return to the beginning of the file to test the iterative
* match. For a FileReader, this requires closing and reopening the file.
*/
try {
System.out.println("Attempting close and reopen.") ;
src.close() ;
src = new FileReader(handle) ;
} catch (IOException ex) {
System.out.println("Exception while reopening file \"" + fileName
+ "\" for read.") ;
System.out.println("Exception: " + ex) ;
try {
if (src != null) src.close() ;
} catch (IOException closeEx) {
System.out.println(
"Exception while closing file \"" + fileName + "\".") ;
System.out.println("Exception: " + closeEx) ;
}
System.exit(3) ;
}
/*
* Try the iterative match method.
*/
try {
matcher.iterativeMatch(src) ;
System.out.println("Brackets match (iterative)!") ;
} catch (MatchFail ex) {
System.out.println("A bracket on its own is up to no good!") ;
System.out.println(ex) ;
} catch (Exception ex) {
System.out.println("Unexpected exception "+ex) ;
}
/*
* Close the file and we're done.
*/
try {
src.close() ;
} catch (IOException ex) {
System.out.println(
"Exception while closing file \"" + fileName + "\".") ;
System.out.println("Exception: " + ex) ;
System.exit(3) ;
}
return ;
}
}