SHARE
TWEET

Inform 7 Brainf___ interpreter

a guest Sep 9th, 2011 100 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. Version 1 of Brainf___ by ralphmerridew begins here.
  2.  
  3. Use fixed allocation translates as (- Constant FIXED_SIZE 0; -).
  4. Use bf memory size of at least 5 translates as (- Constant FIXED_MEMORY_SIZE {N}; -).
  5. Use bf program size of at least 400 translates as (- Constant FIXED_PROGRAM_SIZE {N}; -).
  6.  
  7. Include (-
  8. #ifdef TARGET_ZCODE;
  9. Default FIXED_SIZE 0;
  10. #endif;
  11.  
  12. Global memory_pointer = 0;
  13. Global program_pointer = 0;
  14.  
  15. #Ifdef FIXED_SIZE;
  16. Constant MEMORY_SIZE = FIXED_MEMORY_SIZE;
  17. Constant PROGRAM_SIZE = FIXED_PROGRAM_SIZE;
  18. !Default MEMORY_SIZE = 30000;
  19. Array memory -> MEMORY_SIZE;
  20. !#Default PROGRAM_SIZE = 2000;
  21. Array program -> PROGRAM_SIZE;
  22. [ Realloc_mem ; print "Realloc_mem() called with FIXED_SIZE [BUG]^"; return 0; ];
  23. #endif;
  24.  
  25.  
  26.  
  27.  
  28. #Ifndef FIXED_SIZE;
  29. Global memory= 0;
  30. Global  MEMORY_SIZE= 0;
  31. Global program = 0;
  32. Global PROGRAM_SIZE = 0;
  33.  
  34. [ Realloc_mem new_size new_pointer i;
  35.         !print "Realloc_mem (), current size = ", MEMORY_SIZE, "^";
  36.         if (MEMORY_SIZE == 0) {
  37.                 new_size = 3;
  38.         } else {
  39.                 new_size = 2 * MEMORY_SIZE;
  40.         }
  41.         !print "Reallocating to ", new_size, "^";
  42.         @malloc new_size new_pointer;
  43.         if (new_pointer == 0) {
  44.                 !print "Error allocating memory";
  45.                 if (memory) {
  46.                         @mfree memory;
  47.                         memory_size = 0;
  48.                         memory = 0;
  49.                 }
  50.                 return 0;
  51.         }
  52.         !print "Allocated to ", new_size, ".^";
  53.  
  54.         if (memory == 0) {
  55.                 !print "Memory was unallocated^";
  56.                 memory_pointer = 0;
  57.         } else if (memory_pointer == 0) {
  58.                 !print "Pointer was at low end, copying^";
  59.                 for (i = 0: i < memory_size: ++ i)
  60.                         new_pointer->i = 0;
  61.                 for (i = 0: i < memory_size: ++ i)
  62.                         new_pointer->(i + memory_size) = memory->i;
  63.                 memory_pointer = memory_size;
  64.                 @mfree memory;
  65.         } else {
  66.                 !print "Pointer was at high end, copying^";
  67.                 for (i = 0: i < memory_size: ++ i)
  68.                         new_pointer->i = memory->i;
  69.                 for (: i < new_size: ++ i)
  70.                         new_pointer->i = 0;
  71.                 @mfree memory;
  72.         }
  73.         !print "Okay, returning^";
  74.         memory_size = new_size;
  75.         memory = new_pointer;
  76.         return 1;
  77. ];
  78. #endif;
  79.  
  80. #Message "BF: End of fixed / dynamic allocators";
  81.  
  82. Constant BF_SUCCESS                                     0;
  83. Constant BF_RUN_PAST_PROGRAM            1;
  84. Constant BF_MEMORY_ERROR                        2;
  85. Constant BF_UNMATCHED_BRACES    3;
  86.  
  87. #Message "BF: Declared constants";
  88.  
  89. [ Dump i;
  90.         print "Memory: ";
  91.         for (i = 0: i < 10: ++ i) {
  92.                 if (i == memory_pointer) { print "["; }
  93.                 print memory->i;
  94.                 if (i == memory_pointer) { print "]"; }
  95.                 print " ";
  96.         }
  97.         print "^";
  98. ];
  99.  
  100. #Message "Text to Dump()";
  101.  
  102. #Ifdef TARGET_ZCODE;
  103. #Message "FS:PS";
  104. Constant PROGRAM_STARTS 2;
  105. #Message "FS:PS2";
  106. #Ifnot;
  107. #Message "nFS:PS";
  108. Constant PROGRAM_STARTS 0;
  109. #Message "nFS:PS2";
  110. #Endif;
  111.  
  112. #Message "Program start places";
  113.  
  114. [  Run_Interpreter op depth  op_count;
  115.         !print "Run_Interpreter ()^";
  116.         #ifndef FIXED_SIZE;
  117.         if (MEMORY_SIZE == 0) Realloc_mem();
  118.         #endif;
  119.  
  120.         op_count = 0;
  121.        
  122.         for (::) {
  123.                 !print "Iteration ", op_count, "^"; dump();
  124.                 ++ op_count;
  125.                
  126.                 if (program_pointer == PROGRAM_SIZE) {
  127.                         !print "Run past end of program memory^";
  128.                         return BF_RUN_PAST_PROGRAM;
  129.                 }
  130.                 op = program->program_pointer;
  131.                 !print "program pointer is ", program_pointer, ", opcode is ", op, ", memory pointer is ", memory_pointer, "^";
  132.                 if (op == 0) { ! EOF
  133.                         !print "Ran successfully.^";
  134.                         return BF_SUCCESS;
  135.                 } else if (op == 91) { ! [
  136.                         ++ program_pointer;
  137.                         if (memory->memory_pointer == 0) {
  138.                                 depth = 1;
  139.                                 while (depth > 0 && program_pointer < PROGRAM_SIZE) {
  140.                                         op = program->program_pointer;
  141.                                         ++ program_pointer;
  142.                                         if (op == 0) {
  143.                                                 !print "Unmatched [ in program^";
  144.                                                 return BF_UNMATCHED_BRACES;
  145.                                         } else if (op == 93) {
  146.                                                 -- depth;
  147.                                         } else if (op == 91) {
  148.                                                 ++ depth;
  149.                                         }
  150.                                 }
  151.                         }
  152.                 } else if (op == 93) { ! ]
  153.                         if (memory->memory_pointer == 0) {
  154.                                 ++ program_pointer;
  155.                         } else {
  156.                                 depth = 1;
  157.                                 -- program_pointer;
  158.                                 while (depth > 0 && program_pointer >= PROGRAM_STARTS) {
  159.                                         op = program->program_pointer;
  160.                                         if (op == 93) {
  161.                                                 ++ depth;
  162.                                         } else if (op == 91) {
  163.                                                 -- depth;
  164.                                         }
  165.                                         -- program_pointer;
  166.                                 }
  167.                                 ++ program_pointer;
  168.                                 if (program_pointer < PROGRAM_STARTS)
  169.                                         return BF_UNMATCHED_BRACES;
  170.                         }
  171.                 } else {
  172.                         ++ program_pointer;
  173.                         if (op == 62) { ! >
  174.                                 ++ memory_pointer;
  175.                                 if (memory_pointer == MEMORY_SIZE) {
  176.                                         #ifdef FIXED_SIZE;
  177.                                         memory_pointer = 0;
  178.                                         #ifnot;
  179.                                         if (Realloc_mem () == 0) return BF_MEMORY_ERROR;
  180.                                         if (memory == 0) return BF_MEMORY_ERROR;
  181.                                         #endif;
  182.                                 }
  183.                         } else if (op == 60) { ! <
  184.                                 if (memory_pointer == 0) {
  185.                                         #ifdef FIXED_SIZE;
  186.                                         memory_pointer = MEMORY_SIZE;
  187.                                         #ifnot;
  188.                                         if (Realloc_mem() == 0) return BF_MEMORY_ERROR;
  189.                                         if (memory == 0) return BF_MEMORY_ERROR;
  190.                                         #endif;
  191.                                 }
  192.                                 -- memory_pointer;
  193.                         } else if (op == 43) { ! +
  194.                                 memory->memory_pointer = memory->memory_pointer + 1;
  195.                         } else if (op == 45) { ! -
  196.                                 memory->memory_pointer = memory->memory_pointer - 1;
  197.                         } else if (op == 46) { ! . (output)
  198.                                 !print (char) memory->memory_pointer;
  199.                                 OutputByte (memory->memory_pointer);
  200.                         } else if (op == 44) { ! , (input)
  201.                                 memory->memory_pointer = VM_KeyChar ();
  202.                         }
  203.                 }
  204.         }
  205. ];
  206.  
  207. [ OutputByte ch;
  208.         if (ch >= 32 && ch < 127) {
  209.                 print (char) ch;
  210.         } else if (ch == 10 || ch == 13) {
  211.                 print "^";
  212.         } else {
  213.                 print "?";
  214.         }
  215. ];
  216.  
  217. #ifndef FIXED_SIZE;
  218. Array dummy -> 4;
  219.  
  220. [ AllocateProgramSize len temp_alloc;
  221.         if (PROGRAM_SIZE > len) { return 1; }
  222.         @malloc len temp_alloc;
  223.         if (temp_alloc == 0) return 0;
  224.         if (program) { @mfree program; }
  225.         program = temp_alloc;
  226.         PROGRAM_SIZE = len;
  227. ];
  228. #endif;
  229.  
  230. [ SetProgram str len;
  231.         !print "SetProgram (", (string) str, ")^";
  232.  
  233. #ifdef TARGET_GLULX;
  234.         #ifndef FIXED_SIZE;
  235.         len = 5 + Glulx_PrintAnyToArray (dummy, 0, str);
  236.         if (AllocateProgramSize (len) == 0) return 0;
  237.         #endif;
  238.  
  239.         len = Glulx_PrintAnyToArray (program, PROGRAM_SIZE - 1, str);
  240.         !print "Read length was ", len, "^";
  241.         program_pointer = 0;
  242.         if (len < PROGRAM_SIZE - 1) {
  243.                 !program->len = 0;
  244.                 return 1;
  245.         }
  246. #ifnot;
  247.         !print "Setting program-->0 to ", PROGRAM_SIZE - 3, "^";
  248.         program-->0 = PROGRAM_SIZE - 3;
  249.         @output_stream 3 program;
  250.         print (string) str;
  251.         @output_stream -3;
  252.         len = program-->0;
  253.         !print "Read length was ", len, "^";
  254.         program_pointer = 2;
  255.         if (len < PROGRAM_SIZE - 3) {
  256.                 !program->(len+2) = 0;
  257.                 return 1;
  258.         }
  259. #endif;
  260.         return 0; ! Too long
  261. ];
  262.  
  263. [ substitute_parens i ch;
  264.         for (i = PROGRAM_STARTS; i < program_size; ++ i) {
  265.                 ch = program->i;
  266.                 if (ch == 40) { ! (
  267.                         program->i = 91; ! [
  268.                 } else if (ch == 41) { ! )
  269.                         program->i = 93; ! ]
  270.                 }
  271.         }
  272. ];
  273.  
  274. [ RunBFProgram str is_escaped rv;
  275.         !print "RunBFProgram (...)^";
  276.         if (SetProgram(str)) {
  277.                 !print "Okay, program set^";
  278.                 if (is_escaped) {
  279.                         substitute_parens();
  280.                         !print "Parens changed to brackets^";
  281.                 }
  282.                 rv = Run_Interpreter();
  283.                 style bold;
  284.                 switch (rv) {
  285.                         BF_SUCCESS: print "Run to completion";
  286.                         BF_RUN_PAST_PROGRAM: print "Run past end of program";
  287.                         BF_MEMORY_ERROR: print "Memory error";
  288.                         BF_UNMATCHED_BRACES: print "Unmatched braces";
  289.                         default: print "Unknown return code ", rv;
  290.                 }
  291.                 style roman;
  292.         } else {
  293.                 style bold;
  294.                 print "Error setting program";
  295.                 style roman;
  296.         }
  297.         print "^";
  298.         !print "RunBFP returning^";
  299.         return;
  300. ];
  301.  
  302.  
  303.  
  304. #Message "End of function";
  305. -).
  306.  
  307. To run the program (str - text): (- RunBFProgram ( {str}, 0 ); -).
  308. To run the escaped program (str - text): (- RunBFProgram ( {str}, 1 ); -).
  309.  
  310. Brainf___ ends here.
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top