1 // Core Part about an Interpreter for 

     2 // the Brainf***++ language

     3 //==============================================

     4 

     5 

     6 object CW10a {

     7 

     8 

     9 // representation of Bf memory 

    10 

    11 type Mem = Map[Int, Int]

    12 

    13 

    14 // (1) Write a function that takes a file name as argument and

    15 // and requests the corresponding file from disk. It Returns the

    16 // content of the file as a String. If the file does not exists,

    17 // the function should Return the empty string.

    18 

    19 import io.Source

    20 import scala.util._

    21 

    22 def load_bff(name: String) : String = ???

    23 

    24 

    25 

    26 // (2) Complete the functions for safely reading  

    27 // and writing brainf***++ memory. Safely read should

    28 // Return the value stored in the Map for a given memory

    29 // pointer, provided it exists; otherwise it Returns 0. The

    30 // writing function generates a new Map with the

    31 // same data, except at the given memory pointer the

    32 // value v is stored.

    33 

    34 

    35 def sread(mem: Mem, mp: Int) : Int = ???

    36 

    37 def write(mem: Mem, mp: Int, v: Int) : Mem = ???

    38 

    39 

    40 

    41 // (3) Implement the two jumping instructions in the 

    42 // brainf***++ language. In jumpRight, given a program and 

    43 // a program counter move the program counter to the right 

    44 // until after the *matching* ]-command. Similarly, 

    45 // jumpLeft implements the move to the left to just after

    46 // the *matching* [-command.

    47 

    48 def jumpRight(prog: String, pc: Int, level: Int) : Int = ???

    49 

    50 def jumpLeft(prog: String, pc: Int, level: Int) : Int = ???

    51 

    52 

    53 // testcases

    54 //jumpRight("""--[..+>--],>,++""", 3, 0)         // => 10

    55 //jumpLeft("""--[..+>--],>,++""", 8, 0)          // => 3

    56 //jumpRight("""--[..[+>]--],>,++""", 3, 0)       // => 12

    57 //jumpRight("""--[..[[-]+>[.]]--],>,++""", 3, 0) // => 18

    58 //jumpRight("""--[..[[-]+>[.]]--,>,++""", 3, 0)  // => 22 (outside)

    59 //jumpLeft("""[******]***""", 7, 0)              // => -1 (outside)

    60 

    61 

    62 

    63 // (4) Complete the compute function that interprets (runs) a brainf***++

    64 // program: the arguments are a program (represented as a string), a program 

    65 // counter, a memory counter and a brainf***++ memory. It Returns the

    66 // memory at the stage when the execution of the brainf***++ program

    67 // finishes. The interpretation finishes once the program counter

    68 // pc is pointing to something outside the program string.

    69 // If the pc points to a character inside the program, the pc, 

    70 // memory pointer and memory need to be updated according to 

    71 // rules of the brainf***++ language. Then, recursively, the compute 

    72 // function continues with the command at the new program

    73 // counter. 

    74 //

    75 // Implement the run function that calls compute with the program

    76 // counter and memory counter set to 0.

    77 

    78 

    79 def compute(prog: String, pc: Int, mp: Int, mem: Mem) : Mem = ???

    80 

    81 def run(prog: String, m: Mem = Map()) = ???

    82 

    83 

    84 

    85 // some sample bf/bf++-programs collected from the Internet

    86 //==========================================================

    87 

    88 

    89 // some contrived (small) programs

    90 //---------------------------------

    91 

    92 // clears the 0-cell

    93 //run("[-]", Map(0 -> 100))    // Map will be 0 -> 0

    94 

    95 // moves content of the 0-cell to 1-cell

    96 //run("[->+<]", Map(0 -> 10))  // Map will be 0 -> 0, 1 -> 10

    97 

    98 

    99 // copies content of the 0-cell to 2-cell and 4-cell

   100 //run("[>>+>>+<<<<-]", Map(0 -> 42))    // Map(0 -> 0, 2 -> 42, 4 -> 42)

   101 

   102 

   103 // prints out numbers 0 to 9

   104 //run("""+++++[->++++++++++<]>--<+++[->>++++++++++<<]>>++<<----------[+>.>.<+<]""")

   105 

   106 // bf++ program calculating the cube-function, 10 * 10 * 10 = 1000

   107 //run("""++++++++++#>+***#""")           // Map(0 -> 10, 1 -> 1000)

   108 

   109 

   110 // bf++ program copies 3 from 0-cell to to cells 1, 4, 5, 6 and 7

   111 // (note that because of how the program wprks cell 1 will contain 7) 

   112 //run("""+++>+@+@+@+@+@""")   // Map(0 -> 3, 1 -> 7, 4 -> 3, 5 -> 3, 6 -> 3, 7 -> 3)

   113 

   114 

   115 

   116 // some more "useful" programs

   117 //-----------------------------

   118 

   119 // hello world program 1

   120 //run("""++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++

   121 //       ..+++.>>.<-.<.+++.------.--------.>>+.>++.""")

   122 

   123 // hello world program 2

   124 //run("""++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>+

   125 //       +.<<+++++++++++++++.>.+++.------.--------.>+.>.""")

   126 

   127 // hello world program 3

   128 //run("""+++++++++[>++++++++>+++++++++++>+++++<<<-]>.>++.+++++++..

   129 //       +++.>-.------------.<++++++++.--------.+++.------.--------.>+.""")

   130 

   131  

   132 // draws the Sierpinski triangle

   133 //run(load_bff("sierpinski.bf"))

   134 

   135 

   136 //fibonacci numbers below 100

   137 //run("""+++++++++++

   138 //      >+>>>>++++++++++++++++++++++++++++++++++++++++++++

   139 //      >++++++++++++++++++++++++++++++++<<<<<<[>[>>>>>>+>

   140 //      +<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<[>++++++++++[-

   141 //      <-[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<[>>>+<<<

   142 //      -]>>[-]]<<]>>>[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]

   143 //      >[<<+>>[-]]<<<<<<<]>>>>>[+++++++++++++++++++++++++

   144 //      +++++++++++++++++++++++.[-]]++++++++++<[->-<]>++++

   145 //      ++++++++++++++++++++++++++++++++++++++++++++.[-]<<

   146 //      <<<<<<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<-[>>.>.<<<

   147 //      [-]]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+>-]>[<+>-]<<<-]""")

   148 

   149 //outputs the square numbers up to 10000

   150 //run("""++++[>+++++<-]>[<+++++>-]+<+[>[>+>+<<-]++>>[<<+>>-]>>>[-]++>[-]+

   151 //       >>>+[[-]++++++>>>]<<<[[<++++++++<++>>-]+<.<[>----<-]<]

   152 //       <<[>>>>>[>>>[-]+++++++++<[>-<-]+++++++++>[-[<->-]+[<<<]]<[>+<-]>]<<-]<<-]""")

   153 

   154 

   155 // calculates 2 to the power of 6 

   156 //(example from a C-to-BF compiler at https://github.com/elikaski/BF-it)

   157 //run(""">>[-]>[-]++>[-]++++++><<<>>>>[-]+><>[-]<<[-]>[>+<<+>-]>[<+>-]

   158 //       <><[-]>[-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]><<>>[-]>[-]<<<[>>[-]

   159 //       <[>+>+<<-]>[<+>-]+>[[-]<-<->>]<<<-]>>[<<+>>-]<<[[-]>[-]<<[>+>

   160 //       +<<-]>>[<<+>>-][-]>[-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]

   161 //       <<>>[-]>[-]<<<[>>>+<<<-]>>>[<<[<+>>+<-]>[<+>-]>-]<<<>[-]<<[-]

   162 //       >[>+<<+>-]>[<+>-]<><[-]>[-]<<<[>>+>+<<<-]>>>-[<<<+>>>-]<[-]>[-]

   163 //       <<<[>>+>+<<<-]>>>[<<<+>>>-][-]><<>>[-]>[-]<<<[>>[-]<[>+>+<<-]>

   164 //       [<+>-]+>[[-]<-<->>]<<<-]>>[<<+>>-]<<][-]>[-]<<[>+>+<<-]>>[<<+>

   165 //       >-]<<<<<[-]>>>>[<<<<+>>>>-]<<<<><>[-]<<[-]>[>+<<+>-]>[<+>-]<>

   166 //       <[-]>[-]>[-]<<<[>>+>+<<<-]>>>[<<<+>>>-]<<>>[-]>[-]>[-]>[-]>[-]>

   167 //       [-]>[-]>[-]>[-]>[-]<<<<<<<<<<>>++++++++++<<[->+>-[>+>>]>[+[-<+

   168 //       >]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<

   169 //       ]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++

   170 //       ++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]<<><<<""")

   171 

   172 

   173 

   174 // a Mandelbrot set generator in brainf*** written by Erik Bosman

   175 // (http://esoteric.sange.fi/brainfuck/utils/mandelbrot/)

   176 //

   177 //run(load_bff("mandelbrot.bf"))

   178 

   179 

   180 // a benchmark program (counts down from 'Z' to 'A')

   181 //

   182 //run(load_bff("benchmark.bf"))

   183 

   184 // calculates the Collatz series for numbers from 1 to 30

   185 //

   186 //run(load_bff("collatz.bf"))

   187 

   188 }