Advertisement
Guest User

Inform 7 Brainf___ interpreter

a guest
Sep 9th, 2011
130
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.36 KB | None | 0 0
  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.
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement