Execute Brain****/Java: Difference between revisions
m (Codespace doesn't overlap div boxes now) |
m (Fixed syntax highlighting.) |
||
(9 intermediate revisions by 5 users not shown) | |||
Line 1: | Line 1: | ||
{{implementation|Brainf***}}{{collection|RCBF}} |
{{implementation|Brainf***}}{{collection|RCBF}} |
||
In this implementation of [[Brainf***]], the code is read in all at once and checked for uneven brackets (unequal amounts of [ and ] commands). If that error occurs, the code will obviously not be run. |
In this implementation of [[Brainf***]] in [[Java]], the code is read in all at once and checked for uneven brackets (unequal amounts of [ and ] commands). If that error occurs, the code will obviously not be run. |
||
Under the hood, the program memory is an ArrayList of Integers which expands "infinitely" (limited by your system's memory) to the right (still [http://en.wikipedia.org/wiki/Turing_completeness Turing complete]). So, if the pointer moves past zero to the left, the program will exit and a "Pointer out of range" error message will be displayed. |
Under the hood, the program memory is an <tt>ArrayList</tt> of Integers which expands "infinitely" (limited by your system's memory) to the right (still [http://en.wikipedia.org/wiki/Turing_completeness Turing complete]). So, if the pointer moves past zero to the left, the program will exit and a "Pointer out of range" error message will be displayed. |
||
Due to the BufferedReader input class, return characters ([http://www.asciitable.com ASCII] 10 and 13) are ignored on input (the , command), but are not ignored on output (the . command). |
Due to the <tt>BufferedReader</tt> input class, return characters ([http://www.asciitable.com ASCII] 10 and 13) are ignored on input (the , command), but are not ignored on output (the . command). In order to input anything, you'll need to append a new line. |
||
Loops are handled in the <tt>jumpForward</tt> and <tt>jumpBack</tt> methods. In each method, the bracket that the code pointer is on is counted as 1 (the counter is initialized to 1). The method then moves the code pointer forward or back and counts other brackets along the way. If it finds a bracket of the same type, 1 is added to the counter; if it finds a bracket of the other type, 1 is subtracted from the counter. The search continues until the counter reaches 0. For jumping forward, the code pointer must be allowed to skip the ending bracket, or else it will jump back on the next execution iteration. For jumping back, the pointer can remain at the starting bracket. So, <tt>jumpBack</tt> offsets the next code pointer increment to make sure the check for 0 happens. |
Loops are handled in the <tt>jumpForward</tt> and <tt>jumpBack</tt> methods. In each method, the bracket that the code pointer is on is counted as 1 (the counter is initialized to 1). The method then moves the code pointer forward or back and counts other brackets along the way. If it finds a bracket of the same type, 1 is added to the counter; if it finds a bracket of the other type, 1 is subtracted from the counter. The search continues until the counter reaches 0. For jumping forward, the code pointer must be allowed to skip the ending bracket, or else it will jump back on the next execution iteration. For jumping back, the pointer can remain at the starting bracket. So, <tt>jumpBack</tt> offsets the next code pointer increment to make sure the check for 0 happens. |
||
More detailed information about the rest of the code can be found in the comments throughout it.<br clear=all> |
More detailed information about the rest of the code can be found in the comments throughout it.<br clear=all> |
||
{{works with|Java|1.5+}} |
|||
<syntaxhighlight lang="java5">import java.io.BufferedReader; |
|||
import java.io.FileNotFoundException; |
|||
import java.io.FileReader; |
|||
import java.io.IOException; |
|||
import java.io.InputStreamReader; |
|||
import java.util.ArrayList; |
|||
/** |
|||
import java.io.BufferedReader; |
|||
* Interprets Brainf**k source from std in or a file. |
|||
import java.io.FileNotFoundException; |
|||
* |
|||
import java.io.FileReader; |
|||
* @author Mike Neurohr |
|||
import java.io.IOException; |
|||
*/ |
|||
import java.io.InputStreamReader; |
|||
public class BF{ |
|||
import java.util.ArrayList; |
|||
private static int pointer;//memory pointer |
|||
private static int codeIndex;//instruction number |
|||
/** |
|||
private static final int INITIAL_SIZE= 1000;//initial size of memory |
|||
* Interprets Brainf**k source from std in or a file. |
|||
private static final String instChars= "[]<>,.+-";//valid code characters |
|||
* |
|||
* @author Mike Neurohr |
|||
/** |
|||
*/ |
|||
* The main program. Holds the input loop and error-handling. |
|||
public class BF{ |
|||
* |
|||
private static int pointer;//memory pointer |
|||
* @param args 0: Source file others: ignored |
|||
private static int codeIndex;//instruction number |
|||
*/ |
|||
private static final int INITIAL_SIZE= 1000;//initial size of memory |
|||
public static void main(String[] args){ |
|||
BufferedReader source; |
|||
try{ |
|||
/** |
|||
if(args.length == 0){//if no file specified |
|||
* The main program. Holds the input loop and error-handling. |
|||
source= new BufferedReader(new InputStreamReader(System.in)); |
|||
* |
|||
}else{ |
|||
* @param args 0: Source file others: ignored |
|||
source= new BufferedReader(new FileReader(args[0])); |
|||
*/ |
|||
} |
|||
public static void main(String[] args){ |
|||
char instruction; |
|||
BufferedReader source; |
|||
try{ |
|||
//holds the cleaned up code |
|||
if(args.length == 0){//if no file specified |
|||
StringBuilder code= new StringBuilder(); |
|||
source= new BufferedReader(new InputStreamReader(System.in)); |
|||
}else{ |
|||
//count for loop syntax errors |
|||
source= new BufferedReader(new FileReader(args[0])); |
|||
int bCnt= 0; |
|||
} |
|||
char instruction; |
|||
//read whole source in |
|||
for(instruction= (char)source.read(); source.ready(); instruction= |
|||
//holds the cleaned up code |
|||
(char)source.read()){ |
|||
StringBuilder code= new StringBuilder(); |
|||
//remove extra characters |
|||
if(instChars.contains(instruction + "")){ |
|||
//count for loop syntax errors |
|||
//add the instruction to the clean code |
|||
int bCnt= 0; |
|||
code.append(instruction); |
|||
if(instruction == '[') bCnt++; |
|||
//read whole source in |
|||
if(instruction == ']') bCnt--; |
|||
} |
|||
(char)source.read()){ |
|||
} |
|||
//remove extra characters |
|||
if(bCnt != 0){//if there is a bracket with no match |
|||
if(instChars.contains(instruction + "")){ |
|||
System.err.println("Error: Uneven brackets."); |
|||
//add the instruction to the clean code |
|||
return; |
|||
code.append(instruction); |
|||
} |
|||
if(instruction == '[') bCnt++; |
|||
if(instruction == ']') bCnt--; |
|||
//set up input for , |
|||
} |
|||
BufferedReader input= |
|||
} |
|||
new BufferedReader(new InputStreamReader(System.in)); |
|||
if(bCnt != 0){//if there is a bracket with no match |
|||
//set up memory |
|||
System.err.println("Error: Uneven brackets."); |
|||
ArrayList<Integer> memory= new ArrayList<Integer>(INITIAL_SIZE); |
|||
return; |
|||
memory.add(new Integer(0)); |
|||
} |
|||
pointer= 0; //initialize pointer |
|||
//set up input for , |
|||
//loop through the cleaned up code and execute |
|||
BufferedReader input= |
|||
for(codeIndex= 0;codeIndex < code.length();codeIndex++){ |
|||
new BufferedReader(new InputStreamReader(System.in)); |
|||
instruction= code.charAt(codeIndex); |
|||
//set up memory |
|||
switch(instruction){ |
|||
ArrayList<Integer> memory= new ArrayList<Integer>(INITIAL_SIZE); |
|||
case '+': |
|||
memory.add(new Integer(0)); |
|||
memory.set(pointer, memory.get(pointer) + 1); |
|||
break; |
|||
pointer= 0; //initialize pointer |
|||
case '-': |
|||
//loop through the cleaned up code and execute |
|||
memory.set(pointer, memory.get(pointer) - 1); |
|||
for(codeIndex= 0;codeIndex < code.length();codeIndex++){ |
|||
break; |
|||
instruction= code.charAt(codeIndex); |
|||
case '.': |
|||
switch(instruction){ |
|||
System.out.print((char)memory.get(pointer).intValue()); |
|||
case '+': |
|||
break; |
|||
memory.set(pointer, memory.get(pointer) + 1); |
|||
case ',': |
|||
input(memory, input); |
|||
case '-': |
|||
break; |
|||
memory.set(pointer, memory.get(pointer) - 1); |
|||
case '[': |
|||
if(memory.get(pointer) == 0){ |
|||
case '.': |
|||
//skip the code inside the loop |
|||
System.out.print((char)memory.get(pointer).intValue()); |
|||
jumpForward(code); |
|||
} |
|||
//if the loop can continue... |
|||
input(memory, input); |
|||
//we don't need to check other things |
|||
break; |
|||
break; |
|||
case ']': |
|||
if(memory.get(pointer) == 0){ |
|||
if(memory.get(pointer) != 0){ |
|||
//skip the code inside the loop |
|||
//go back to the corresponding [ to check |
|||
jumpForward(code); |
|||
jumpBack(code); |
|||
} |
|||
//if the loop can continue... |
|||
//if the loop should stop... |
|||
//we don't need to check other things |
|||
break; |
|||
break; |
|||
case '>': |
|||
//go back to the corresponding [ to check |
|||
pointer++; |
|||
//gets rid of NullPointerExceptions |
|||
break; |
|||
while(pointer + 1 > memory.size()) memory.add(0); |
|||
case '>': |
|||
break; |
|||
case '<': |
|||
//gets rid of NullPointerExceptions |
|||
if(--pointer < 0){ |
|||
//can't do it |
|||
System.err.println("Pointer out of range (negative)."); |
|||
case '<': |
|||
return; |
|||
} |
|||
default: |
|||
System.err.println("Pointer out of range (negative)."); |
|||
//No other characters left after the cleaning |
|||
return; |
|||
} |
|||
} |
|||
}catch(FileNotFoundException e){ |
|||
} |
|||
System.err.println("Error opening file: " + args[0] + "."); |
|||
} |
|||
}catch(IOException e){ |
|||
System.err.println("Error on input."); |
|||
} |
|||
}catch(IOException e){ |
|||
} |
|||
System.err.println("Error on input."); |
|||
} |
|||
public static void jumpBack(StringBuilder code){ |
|||
} |
|||
//initial count for the bracket we're on |
|||
int bracketCnt= 1; |
|||
public static void jumpBack(StringBuilder code){ |
|||
//count brackets until the corresponding [ |
|||
while(codeIndex >= 0 && bracketCnt != 0){ |
|||
codeIndex--; |
|||
//count brackets until the corresponding [ |
|||
char inst= code.charAt(codeIndex); |
|||
while(codeIndex >= 0 && bracketCnt != 0){ |
|||
if(inst == '[') bracketCnt--; |
|||
codeIndex--; |
|||
if(inst == ']') bracketCnt++; |
|||
} |
|||
if(inst == '[') bracketCnt--; |
|||
//"- 1" to offset the next "codeIndex++". |
|||
if(inst == ']') bracketCnt++; |
|||
codeIndex= codeIndex - 1; |
|||
} |
|||
} |
|||
//"- 1" to offset the next "codeIndex++". |
|||
codeIndex= codeIndex - 1; |
|||
public static void jumpForward(StringBuilder code){ |
|||
} |
|||
//initial count for the bracket we're on |
|||
int bracketCnt= 1; |
|||
public static void jumpForward(StringBuilder code){ |
|||
//count brackets until the corresponding ] |
|||
while(codeIndex < code.length() && bracketCnt != 0){ |
|||
codeIndex++; |
|||
//count brackets until the corresponding ] |
|||
char inst= code.charAt(codeIndex); |
|||
while(codeIndex < code.length() && bracketCnt != 0){ |
|||
if(inst == ']') bracketCnt--; |
|||
codeIndex++; |
|||
if(inst == '[') bracketCnt++; |
|||
} |
|||
if(inst == ']') bracketCnt--; |
|||
} |
|||
if(inst == '[') bracketCnt++; |
|||
} |
|||
public static void input(ArrayList<Integer> mem, BufferedReader input) |
|||
} |
|||
throws IOException{ |
|||
int val; |
|||
public static void input(ArrayList<Integer> mem, BufferedReader input) |
|||
//read until something comes in other than return chars |
|||
throws IOException{ |
|||
for(val= input.read(); val == 10 || val == 13; val= input.read()); |
|||
int val; |
|||
mem.set(pointer, new Integer(val)); |
|||
//read until something comes in other than return chars |
|||
for(val= input.read(); val == 10 || val == 13; val= input.read()); |
|||
mem.set(pointer, new Integer(val)); |
|||
} |
} |
||
}</syntaxhighlight> |
|||
} |
Latest revision as of 11:32, 1 September 2022
In this implementation of Brainf*** in Java, the code is read in all at once and checked for uneven brackets (unequal amounts of [ and ] commands). If that error occurs, the code will obviously not be run.
Under the hood, the program memory is an ArrayList of Integers which expands "infinitely" (limited by your system's memory) to the right (still Turing complete). So, if the pointer moves past zero to the left, the program will exit and a "Pointer out of range" error message will be displayed.
Due to the BufferedReader input class, return characters (ASCII 10 and 13) are ignored on input (the , command), but are not ignored on output (the . command). In order to input anything, you'll need to append a new line.
Loops are handled in the jumpForward and jumpBack methods. In each method, the bracket that the code pointer is on is counted as 1 (the counter is initialized to 1). The method then moves the code pointer forward or back and counts other brackets along the way. If it finds a bracket of the same type, 1 is added to the counter; if it finds a bracket of the other type, 1 is subtracted from the counter. The search continues until the counter reaches 0. For jumping forward, the code pointer must be allowed to skip the ending bracket, or else it will jump back on the next execution iteration. For jumping back, the pointer can remain at the starting bracket. So, jumpBack offsets the next code pointer increment to make sure the check for 0 happens.
More detailed information about the rest of the code can be found in the comments throughout it.
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
/**
* Interprets Brainf**k source from std in or a file.
*
* @author Mike Neurohr
*/
public class BF{
private static int pointer;//memory pointer
private static int codeIndex;//instruction number
private static final int INITIAL_SIZE= 1000;//initial size of memory
private static final String instChars= "[]<>,.+-";//valid code characters
/**
* The main program. Holds the input loop and error-handling.
*
* @param args 0: Source file others: ignored
*/
public static void main(String[] args){
BufferedReader source;
try{
if(args.length == 0){//if no file specified
source= new BufferedReader(new InputStreamReader(System.in));
}else{
source= new BufferedReader(new FileReader(args[0]));
}
char instruction;
//holds the cleaned up code
StringBuilder code= new StringBuilder();
//count for loop syntax errors
int bCnt= 0;
//read whole source in
for(instruction= (char)source.read(); source.ready(); instruction=
(char)source.read()){
//remove extra characters
if(instChars.contains(instruction + "")){
//add the instruction to the clean code
code.append(instruction);
if(instruction == '[') bCnt++;
if(instruction == ']') bCnt--;
}
}
if(bCnt != 0){//if there is a bracket with no match
System.err.println("Error: Uneven brackets.");
return;
}
//set up input for ,
BufferedReader input=
new BufferedReader(new InputStreamReader(System.in));
//set up memory
ArrayList<Integer> memory= new ArrayList<Integer>(INITIAL_SIZE);
memory.add(new Integer(0));
pointer= 0; //initialize pointer
//loop through the cleaned up code and execute
for(codeIndex= 0;codeIndex < code.length();codeIndex++){
instruction= code.charAt(codeIndex);
switch(instruction){
case '+':
memory.set(pointer, memory.get(pointer) + 1);
break;
case '-':
memory.set(pointer, memory.get(pointer) - 1);
break;
case '.':
System.out.print((char)memory.get(pointer).intValue());
break;
case ',':
input(memory, input);
break;
case '[':
if(memory.get(pointer) == 0){
//skip the code inside the loop
jumpForward(code);
}
//if the loop can continue...
//we don't need to check other things
break;
case ']':
if(memory.get(pointer) != 0){
//go back to the corresponding [ to check
jumpBack(code);
}
//if the loop should stop...
//we don't need to check other things
break;
case '>':
pointer++;
//gets rid of NullPointerExceptions
while(pointer + 1 > memory.size()) memory.add(0);
break;
case '<':
if(--pointer < 0){
//can't do it
System.err.println("Pointer out of range (negative).");
return;
}
default:
//No other characters left after the cleaning
}
}
}catch(FileNotFoundException e){
System.err.println("Error opening file: " + args[0] + ".");
}catch(IOException e){
System.err.println("Error on input.");
}
}
public static void jumpBack(StringBuilder code){
//initial count for the bracket we're on
int bracketCnt= 1;
//count brackets until the corresponding [
while(codeIndex >= 0 && bracketCnt != 0){
codeIndex--;
char inst= code.charAt(codeIndex);
if(inst == '[') bracketCnt--;
if(inst == ']') bracketCnt++;
}
//"- 1" to offset the next "codeIndex++".
codeIndex= codeIndex - 1;
}
public static void jumpForward(StringBuilder code){
//initial count for the bracket we're on
int bracketCnt= 1;
//count brackets until the corresponding ]
while(codeIndex < code.length() && bracketCnt != 0){
codeIndex++;
char inst= code.charAt(codeIndex);
if(inst == ']') bracketCnt--;
if(inst == '[') bracketCnt++;
}
}
public static void input(ArrayList<Integer> mem, BufferedReader input)
throws IOException{
int val;
//read until something comes in other than return chars
for(val= input.read(); val == 10 || val == 13; val= input.read());
mem.set(pointer, new Integer(val));
}
}