API tools faq
paste
PixelatedStarfish

v115 Doc

PixelatedStarfish
Jan 26th, 2022 (edited)
104
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.67 KB | None | 0 0
raw download clone embed print report
  1. =MacroBeep Documentation v 1.1.5=
  2.  
  3. Thank you for using MacroBeep! A language by @PixelatedStarfish on esolangs.org (Andrew Vella)
  4. This documentation provides a reference for use, and fully defines an interpreter for the language.
  5.  
  6. File Extension .mcbe
  7.  
  8. Comments and and Questions can be left on this page:
  9. https://esolangs.org/wiki/Talk:MacroBeep
  10.  
  11.  
  12. ==Contents==
  13.  
  14. Acknowledgements
  15. Introduction to MacroBeep
  16. Language Paradigm and Memory
  17. Instruction Set
  18. The Preprocessor
  19. Program Examples
  20. Error Codes
  21. Turing Machines and the MacroBeep Tape
  22. Proof of Turing Completeness
  23. Grammar in EBNF
  24. Interpreter Test Cases in Java
  25. ASCII Table Reference
  26. Change LogSources
  27.  
  28.  
  29. ==Acknowledgements==
  30.  
  31. I certainly would like to thank family, friends, and of course, mademoiselle for their support and care.
  32. Thank you to the Skidmore College faculty, O'Connell, Dufour, Eckmann, Read, Reiley, and Prasad. I am
  33. so glad to have my degree in computer science!
  34. I would also like to thank Bringas, Kravsky, and Lee for their tutelage, patience, and inspiration.
  35. MacroBeep would not exist without the esolangs wiki and the work of youtuber Truttle1.
  36.  
  37.  
  38. ==Introduction to MacroBeep==
  39.  
  40. Macrobeep is designed in response to common problems people face when learning to code in more conventional
  41. programming languages. The syntax is designed to communicate what the computer is doing in a clear and
  42. concise manner. For every MacroBeep program, there is an equivalent MacroBeep program that can described
  43. as a sequence of native instructions in a specific order.
  44.  
  45. A MacroBeep programmer does not have to search for the missing punctuation. They do not need to find
  46. the unmatched parenthesis, or count their braces. They do not need to deal with the particularities of
  47. data types or the difference between objects, classes, structs, and interfaces.
  48.  
  49. This language is not without cons. A programmer needs to manage program memory themselves. Data cannot
  50. be protected. It is up to the programmer to make sure that something is not overwritten before it should
  51. be. A MacroBeep programmer should also be familiar with Turing machines and the ASCII table.
  52. This document covers everything you need to program in MacroBeep.
  53.  
  54.  
  55. ==Language Paradigm and Memory==
  56.  
  57. MacroBeep is an assembly style language with an instruction set, such that the programmer can define
  58. macros in order to describe and implement more complex operations.
  59. MacroBeep is not a language in the functional language paradigm. There is no part of a MacroBeep program
  60. that can be considered stateless, and there are no functions in MacroBeep. Instead, a program modifies
  61. bytes on a tape using a pointer in a manner similar to bf, such that each cell on the tape can store
  62. a value between 0 and 255 inclusive.
  63. A program in MacroBeep will always run the main macro before any other macro. This language has a call
  64. stack, and the main macro is the first item on that call stack.
  65.  
  66.  
  67. ==Instruction Set==
  68.  
  69. Each operation can take an identifier or an integer value as an argument.
  70. A macro cannot be a reserved word or operation name.
  71. Operations are separated by a newline, and arguments by a space.
  72.  
  73. macro (define macro; takes an identifier)
  74.  
  75. do (do macro identified in arg, call macro)
  76.  
  77. rt (return to macro call an execute next instruction)
  78.  
  79. null (set cell to 0)
  80.  
  81. str (store value of current cell in next cell; store value of cell in right adjacent cell)
  82.  
  83. rand (set cell a random from 0 to arg or 0 to 255)
  84.  
  85. add (add to cell; 1 if no arg)
  86.  
  87. sub (take from cell; 1 if no arg)
  88.  
  89. right (move pointer to the right; by 1 if no arg is given)
  90.  
  91. left (move pointer to the left; by 1 if no arg is given)
  92.  
  93. head (go to head of tape)
  94.  
  95. pos (get position of cell pointer on tape and print it)
  96.  
  97. inp (get input; char int or string)
  98.  
  99. out (print cell or arg)
  100.  
  101. cout (print char on cell or arg as char)
  102.  
  103. pr (print any value given as a string with a newline, newline if nothing. Use '[]' to print a space
  104. and '{}'' to print a tab)
  105.  
  106. beep (it goes beep, use an argument to specify frequency in hertz. Default is 1000)
  107.  
  108. solar (jump the specified number of instructions if cell is greater than 0)
  109.  
  110. lunar (jump the specified number of instructions if cell is 0)
  111.  
  112. halt (end program)
  113.  
  114. wait (adds a delay of 100ms, or as specified by an argument)
  115.  
  116. include (include file at path identified)
  117.  
  118. # (comment)
  119.  
  120.  
  121. ==The Preprocessor==
  122.  
  123. The Preprocessor formats source code so that it can run appropriately. All leading whitespace before
  124. an instruction is removed. All blank lines are removed. If needed, all null lines are replaced with empty
  125. comments. (Comments are ignored at runtime and do not need to be removed.) Additionally, all include
  126. statements are processed. The contents of each included file are concatinated into a single set of source.
  127.  
  128. While 'include' is listed as an instruction in the instruction set, it is not technically correct to
  129. call them include instructions. Include statements are processed by the preprocessor but not executed.
  130. This is because they are not executable instructions, but placeholders. Comments are also listed in the
  131. instruction set, even though they are also not technically executable instructions. This is so a programmer
  132. can read the set and understand everything that the language can do. It is not particularily wise to
  133. have some edge case somewhere else. This would not be an effective reference document if a programmer
  134. could not find information about how to write comments or include files in their programs. Knick-knacks
  135. are not books, but they sit on the bookshelf anyway, where they can be seen and appreciated. The bookshelf
  136. does not mind, and the books like the company.
  137.  
  138.  
  139. ==Program Examples==
  140.  
  141. It is good practice to indicate the scope of an instruction with tabs or spaces. This can be useful to
  142. indicate which instructions are part of a macro. Leading white space is not required. New lines are the
  143. only significant white space characters.
  144.  
  145. ===Hello World===
  146. macro main
  147. pr Hello[]World
  148. # Note that the [] is printed as a space
  149.  
  150. ===Truth Machine===
  151. macro main
  152. pr Type[]a[]0[]or[]1[]into[]the[]truth[]machine.
  153. inp 1
  154. solar 3
  155. pr 0
  156. halt
  157. pr 1
  158. wait
  159. solar -3
  160.  
  161. ===False Machine===
  162. macro main
  163. pr Type[]a[]0[]or[]1[]into[]the[]false[]machine.
  164. inp 1
  165. lunar 3
  166. pr 1
  167. halt
  168. pr 0
  169. wait
  170. lunar -3
  171.  
  172. ===Cat===
  173. macro main
  174. pr Give[]me[]a[]word[]and[]I[]will[]say[]it[]back!
  175. inp 2
  176. head
  177. cout
  178. right
  179. solar -3
  180.  
  181. ===C scale===
  182. macro main
  183. beep 262
  184. beep 294
  185. beep 330
  186. beep 349
  187. beep 392
  188. beep 440
  189. beep 494
  190. beep 523
  191.  
  192. Note that the main macros do not include a return statement 'rt'. This is becuase the program ends when
  193. the macro does. A 'rt' can be added to the main macro but it is not required. A macro without an 'rt'
  194. will continue to execute until it reaches an 'rt' somewhere or gets to an End Of File. So...
  195.  
  196. macro main
  197. beep
  198. macro sub
  199. beep 555
  200. rt
  201.  
  202. ...will execute. 'do sub' will execute the macro 'sub'. 'do main' will execute from the top to the 'rt'.
  203. However, any statements after the 'rt' would not execute, since macro 'main' has finished.
  204.  
  205.  
  206. ==Error Codes==
  207.  
  208. Error (0)
  209. The Generic Error Message, for errors not described below.
  210.  
  211. Undefined Instruction (1)
  212. Thrown when the interpreter encounters an instruction that is not defined in the instruction set.
  213.  
  214. File Not Found (2)
  215. Either the file does not exist, or it is in the wrong directory.
  216.  
  217. Undefined Macro (3)
  218. The macro called by "do" has no matching definition, or "macro" instruction
  219.  
  220. Missing Main Macro (4)
  221. "macro main" is missing, the program cannot start.
  222.  
  223. Stack Overflow (5)
  224. This error is most commonly caused by an infinite recursion. Too many macro calls on the call stack.
  225.  
  226. Not a Cell Error (6)
  227. Occurs when a program tries to modify a cell that does not exist, such as cell -1 or cell infinity.
  228.  
  229. Include Statement in Macro (7)
  230. An include statement cannot be written into a macro definition.
  231.  
  232. Preproccesor Error (8)
  233. A preproccesor error that is not caught by any other error code. Check include statements carefully.
  234.  
  235. Duplicate Macro Definition (9)
  236. A macro is defined more than once in the program. Calls to macro ambiguous.
  237.  
  238. Argument Error. Integer Expected (10)
  239. An instruction that only takes an integer argument was not given an integer argument.
  240.  
  241. Bad Argument (11)
  242. This is the error thrown when the interpreter reads statements that are syntactically correct, but incomputable
  243. in this language, such as "wait -100". Esoteric models of time notwithstanding, instructions that require
  244. negative time to compute would throw this error.
  245.  
  246. Astrological Error (12)
  247. This error occurs when the next instruction to execute is located outside source entirely. It can only
  248. be thrown by the "solar" and "lunar" operators, which allow the instruction pointer to jump around (an
  249. ability critical for logical operators and conditional statements, or branching). It is as if you gave
  250. the interpreter a To-Do list of 10 or so items in an order, and then said "Hey, no need to do that fifth
  251. thing, go do item 24, or -5 instead." Confusion would be understandable, and nothing would get done!
  252.  
  253.  
  254. ==Turing Machines and the MacroBeep Tape==
  255.  
  256. ===What is a Turing Machine?===
  257.  
  258. The Turing Machine is a theoretical machine first described by Alan Turing. It consists of a tape divided
  259. into cells and a pointer that can modify cells on the tape. The tape extends without bound, so the machine
  260. never runs out of cells. (In practice, this is not possible, but such a limitation is usually ignored).
  261. A Turing machine can do the following:
  262.  
  263. Shift the pointer left or right
  264. Read the value on the cell
  265. Write a value to a cell
  266.  
  267. The pointer can point to one cell at any given time, and it can only act on the cell at which it points.
  268. To act on another cell the pointer has to move to that cell. The pointer of a Turing Machine is programmable.
  269. It can be given instructions like: "Set the current cell to 0", or "If the current cell is one, go one
  270. cell to the right". These instructions describe something called a Finite State Machine, which a machine
  271. that knows its current state, and decides what to do next according to its instructions.
  272. In the case of "If the current cell is one, go one cell to the right", the pointer can read the current
  273. cell, and decide whether or not it should go to next cell on the right. If the current cell is one, the
  274. pointer goes right (which changes its state), and if not, it stays put.
  275.  
  276. The typical Turing machine has cells that can be set to 0 or 1 (sometimes 'blank' or 'null' is included,
  277. meaning no data is on this cell). Here is a crude, plain text visual, with the pointer pointing to the
  278. second cell on the tape:
  279.  
  280.  
  281. 1 | 1 | 0 | 1 | 0 | 0 | 1
  282. ^
  283.  
  284. The first cell of the tape is called the head of the tape, all other cells are positioned right of the
  285. head.
  286.  
  287. The Turing Machine can compute anything that is computable, and anything that can simulate a Turing Machine
  288. can compute anything that is computable. To put it another way, such a machine can decide any decidable
  289. problem, or solve any solvable math problem if it is programmed to do so. Something that can simulate
  290. a Turing Machine is Turing Complete, and any Turing Complete system can simulate any other Turing Complete
  291. system.
  292.  
  293. ===The MacroBeep Tape===
  294.  
  295. MacroBeep makes use of a Turing Machine for computation, but cells on this machine can store any integer
  296. value from 0 to 255 inclusive. In other words, each cell stores a byte of information, equivalent to
  297. 8 cells in the tape above. Many esoteric programming languages use a tape like this one. The most notable
  298. example is none other than one of the earliest, a language by Urban M??¼ller with a swear word in the
  299. name,
  300. which will be referred to as bf. Here is a visual of the byte tape used in bf and MacroBeep:
  301.  
  302. 000 | 255 | 023 | 150 | 045 | 213 | 010
  303. ^
  304.  
  305. Note that, as with a Turing machine, the tape extends to the right without bound. Also note that the
  306. pointer can do all of the things a pointer on a Turing machine can. Furthermore this pointer can modify
  307. bytes, adding or subtracting from them such that they can be at any integer value from 0 to 255.
  308. The initial state of the tape is such that every cell is set to 0.
  309.  
  310. In MacroBeep, 'pos' gives the pointer postion, 'out' gives the current cell value; 'left' and 'right'
  311. move the pointer, 'add' and 'sub' modify cell values. Note that 'pos' and 'out' are excellent debugging
  312. operations. See the Instruction Set for more information.
  313.  
  314.  
  315. ==Proof of Turing Completeness==
  316.  
  317. bf is Turing complete, and consists of only eight instructions.
  318. Given the above, by translating each bf command to MacroBeep, it can be shown that MacroBeep is also
  319. Turing complete.
  320. This table provides a means to translate between MacroBeep and bf.
  321.  
  322. MacroBeep bf Description
  323.  
  324. right > increment
  325.  
  326. left < decrement
  327.  
  328. add + add 1 to cell
  329.  
  330. sub - take 1 from cell
  331.  
  332. cout . Output ASCII value at cell
  333.  
  334. inp , Take input at cell
  335.  
  336. lunar (by some positive number of instructions) [ jump past ' ] ' if cell is 0
  337.  
  338. solar (by some negative number of instructions) ] goto ' [ ' if cell is greater than 0
  339.  
  340.  
  341. ==Grammar in EBNF==
  342.  
  343. Extended Backus-Naur Form is a metasyntax that can describe the syntax of a programming language.
  344. It is useful for understanding how the language is parsed for interpretation.
  345.  
  346. Key:
  347. ::= assignment, equivalence
  348. | or
  349. (group)
  350. {repeated at least one time}
  351. [optional]
  352. 'string literal'
  353. symbol
  354. , symbol concatination
  355. ; symbol terminator
  356. (*comment*)
  357.  
  358. Program ::= {statement}
  359. statement ::= macro | command
  360. macro ::= 'macro', s, alnum, n, {command}, ['rt']; (*be careful when leaving out 'rt'*)
  361. command ::= word, s, [arg], n;
  362. arg ::= alnum | inte
  363. alnum ::= {(lett | digit)};
  364. word ::= {lett};
  365. inte ::= {digit};
  366. s ::= ' ';
  367. n ::= '\n';
  368. digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
  369. lett ::= 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' |
  370. 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' |
  371. 'y' | 'z';
  372.  
  373.  
  374. ==Interpreter Test Cases in Java==
  375.  
  376. public class Tests {
  377.  
  378. //Note that each instruct needs to be tested with and without parameters
  379.  
  380. //Input and Output Tests
  381. //macro main is tested in every test in this category
  382.  
  383. //Tests pr, comment, space, newline, then tab
  384. public static String HelloWorld = "macro main\n"
  385. + "pr Hello[]Worlds!\n # include SUDDENLY A COMMENT WOAH!!\n\npr\npr Hello{}World";
  386.  
  387. //Tests pr, solar, halt, wait, inp 1
  388. public static String TruthMachine = "macro main\n"
  389. + "pr Type[]a[]0[]or[]1[]into[]the[]truth[]machine.\n"
  390. + "inp 1\n"
  391. + "solar 3\n"
  392. + "pr 0\n"
  393. + "halt\n"
  394. + "pr 1\n"
  395. + "wait\n"
  396. + "solar -3";
  397.  
  398. public static String FalseMachine = "macro main\n"
  399. + " pr Type[]a[]0[]or[]1[]into[]the[]false[]machine.\n"
  400. + " inp 1\n"
  401. + " lunar 3\n"
  402. + " pr 1\n"
  403. + " halt\n"
  404. + " pr 0\n"
  405. + " wait\n"
  406. + " lunar -3\n";
  407.  
  408. //Tests inp 2, head, cout, right, solar
  409. public static String Cat = "macro main\n"
  410. + "pr Give[]me[]a[]word[]and[]I[]will[]say[]it[]back!\ninp 2\nhead\n"
  411. + "cout\nright\nsolar -3";
  412.  
  413. //Tests beep //should beep at 1000, 3300 mod 2501, and 500 hertz
  414. public static String Beep = "macro main\n beep\n beep 3300\n beep 500";
  415.  
  416. //Should print the integer value of the given ASCII char
  417. public static String StdIO = "macro main\n inp \n out";
  418.  
  419. //Should print the integer value of the given ASCII char
  420. public static String WhyIO = "macro main\n inp 7 \n out";
  421.  
  422.  
  423. public static String Outs = "macro main\nout\n out 75\n add 72\n cout\n sub 10\n cout 72\n";
  424.  
  425. //Should output 3
  426. public static String posTest = "macro main\n right 5\n left 2\n right\n left\n pos";
  427.  
  428. //Error Tests
  429.  
  430. Should throw Err 1
  431. public static String BadInst = "macro main\n foo";
  432.  
  433. Should throw Err 2
  434. public static String FNF = "include foo\n macro main";
  435.  
  436. Err 2, get content of non-existant dir
  437. public static String PrepErr = "include this_directory_does_not_exist\*";
  438.  
  439. Should throw Err 3
  440. public static String UndefMacro = "macro main\n do foo";
  441.  
  442. Should throw Err 4
  443. public static String Null = "";
  444.  
  445. . Throws 5. print stack length for this test, it throws an OutOfMemoryError
  446. public static String StackOverflow = "macro store\n do store\n \nmacro main\n do store";
  447.  
  448. Should throw Err 6, tests left
  449. public static String NegCel = "macro main\nleft\nadd 50";
  450.  
  451. Should throw Err 6, tests right
  452. public static String EndTape = "macro main\nright\nadd 2\n solar -3";
  453.  
  454. Err 7 test
  455. public static String IncMac = "macro main\ninclude foo";
  456.  
  457. Err 8 test
  458. public static String PrepErr = "include\n\nmacro main\n";
  459.  
  460. Err 8, get content of empty dir
  461. public static String PrepErr = "include this_directory_is_empty\*";
  462.  
  463. Err 9 test
  464. public static String DupM = "macro main\n macro foo\n macro foo";
  465.  
  466. Throws 10
  467. public static String NonIntArg = "macro main\n wait foo";
  468.  
  469. , tests wait, throws 11
  470. public static String BadArg = "macro main\n wait -100";
  471.  
  472. err12
  473. public static String e12 = "macro main
  474. lunar -10";
  475.  
  476. //Remaining Instruction Tests
  477.  
  478. //The Solar and Lunar tests should output 0, PASSED
  479. public static String Solar = "macro main\n add 1\n pos\nsolar";
  480. public static String Lunar = "macro main\n pos\nlunar";
  481.  
  482. Expected Output:
  483. //23
  484. //0
  485. public static String twthze = "macro thing\n"
  486. + " add\n"
  487. + " add 25\n"
  488. + " sub\n"
  489. + " sub 2\n"
  490. + " rt\n"
  491. + "macro main\n"
  492. + " do thing\n"
  493. + " out\n"
  494. + " pr\n"
  495. + " null\n"
  496. + " out\n"
  497. + " rt";
  498.  
  499. outputs HH
  500. public static String Store = "macro main\n add 72\n str\n right\n cout\n str 5\n right 5\n cout";
  501. . Not a cell Error.
  502. public static String noStore = "macro main\n str -10";
  503.  
  504. //Note each rand test should be done a few times
  505. outputs a random number from 0 - 255
  506. public static String Rand1 = "macro main\n rand\n out";
  507.  
  508. rand from 0 - 10
  509. public static String Rand2 = "macro main\n rand 10\n out";
  510.  
  511. output between 245 to 255
  512. public static String Rand3 = "macro main\n rand -10\n out";
  513.  
  514.  
  515.  
  516. //Include Tests
  517.  
  518. //There are four such tests, each test uses 3 files: MAIN, A, and B respectively.
  519. //Each test should produce the same output, a beep at 1000 and a beep at 500;
  520. //excluding the first test, which should only output a beep.
  521.  
  522. //Test 1
  523. //MAIN
  524.  
  525. //include a.mcbe
  526. //macro main
  527. //do b
  528.  
  529. //A
  530.  
  531. //macro b
  532. //beep
  533. //rt
  534.  
  535. //Test 2
  536. //MAIN
  537.  
  538. //include a.mcbe
  539. //include b.mcbe
  540. //macro main
  541. //do b
  542. //do c
  543.  
  544. //A
  545.  
  546. //macro b
  547. //beep
  548. //rt
  549.  
  550. //B
  551.  
  552. //macro c
  553. //beep 500
  554. //rt
  555.  
  556. //Test 3
  557. //MAIN
  558.  
  559. //include dir/a.mcbe
  560. //include dir/b.mcbe
  561. //macro main
  562. //do b
  563. //do c
  564.  
  565. //A
  566.  
  567. //macro b
  568. //beep
  569. //rt
  570.  
  571. //B
  572.  
  573. //macro c
  574. //beep 500
  575. //rt
  576.  
  577. //Test 4
  578. //MAIN
  579.  
  580. //include a.mcbe
  581. //macro main
  582. //do b
  583. //do c
  584.  
  585. //A
  586.  
  587. //include b.mcbe
  588. //macro b
  589. //beep
  590. //rt
  591.  
  592. //B
  593.  
  594. //macro c
  595. //beep 500
  596. //rt
  597.  
  598. //Test 5
  599. //MAIN
  600.  
  601. //include run\foo\*
  602.  
  603. //macro main
  604. //do that
  605. //do this
  606.  
  607.  
  608. //A (in run/foo)
  609.  
  610. //macro that
  611. //beep
  612. //rt
  613.  
  614. //B (in run/foo/bar)
  615.  
  616. //macro this
  617. //beep 500
  618. //rt
  619. }
  620.  
  621.  
  622.  
  623. ==ASCII Table Reference==
  624.  
  625. Characters on the ASCII table correspond to integer values. For example, "H" is equal to 72. In MacroBeep
  626. "cout 72" prints an H.
  627.  
  628. Null 0
  629.  
  630. Beep 7
  631.  
  632. Tab 9
  633.  
  634. New Line 10
  635.  
  636. Space 32
  637.  
  638. ! 33
  639.  
  640. " 34
  641.  
  642. # 35
  643.  
  644. $ 36
  645.  
  646. % 37
  647.  
  648. & 38
  649.  
  650. ' 39
  651.  
  652. ( 40
  653.  
  654. ) 41
  655.  
  656. * 42
  657.  
  658. + 43
  659.  
  660. , 44
  661.  
  662. - 45
  663.  
  664. . 46
  665.  
  666. / 47
  667.  
  668. 0 48
  669.  
  670. 1 49
  671.  
  672. 2 50
  673.  
  674. 3 51
  675.  
  676. 4 52
  677.  
  678. 5 53
  679.  
  680. 6 54
  681.  
  682. 7 55
  683.  
  684. 8 56
  685.  
  686. 9 57
  687.  
  688. : 58
  689.  
  690. ; 59
  691.  
  692. < 60
  693.  
  694. = 61
  695.  
  696. > 62
  697.  
  698. ? 63
  699.  
  700. @ 64
  701.  
  702. A 65
  703.  
  704. B 66
  705.  
  706. C 67
  707.  
  708. D 68
  709.  
  710. E 69
  711.  
  712. F 70
  713.  
  714. G 71
  715.  
  716. H 72
  717.  
  718. I 73
  719.  
  720. J 74
  721.  
  722. K 75
  723.  
  724. L 76
  725.  
  726. M 77
  727.  
  728. N 78
  729.  
  730. O 79
  731.  
  732. P 80
  733.  
  734. Q 81
  735.  
  736. R 82
  737.  
  738. S 83
  739.  
  740. T 84
  741.  
  742. U 85
  743.  
  744. V 86
  745.  
  746. W 87
  747.  
  748. X 88
  749.  
  750. Y 89
  751.  
  752. Z 90
  753.  
  754. [ 91
  755.  
  756. \ 92
  757.  
  758. ] 93
  759.  
  760. ^ 94
  761.  
  762. _ 95
  763.  
  764. ` 96
  765.  
  766. a 97
  767.  
  768. b 98
  769.  
  770. c 99
  771.  
  772. d 100
  773.  
  774. e 101
  775.  
  776. f 102
  777.  
  778. g 103
  779.  
  780. h 104
  781.  
  782. i 105
  783.  
  784. j 106
  785.  
  786. k 107
  787.  
  788. l 108
  789.  
  790. m 109
  791.  
  792. n 110
  793.  
  794. o 111
  795.  
  796. p 112
  797.  
  798. q 113
  799.  
  800. r 114
  801.  
  802. s 115
  803.  
  804. t 116
  805.  
  806. u 117
  807.  
  808. v 118
  809.  
  810. w 119
  811.  
  812. x 120
  813.  
  814. y 121
  815.  
  816. z 122
  817.  
  818. { 123
  819.  
  820. | 124
  821.  
  822. } 125
  823.  
  824. ~ 126
  825.  
  826.  
  827.  
  828. ==Change Log==
  829.  
  830. - Added "run" directory.
  831.  
  832. - Expanded criteria for errors 0 and 2 (Runtime Error 0 and Directory Error 2).
  833.  
  834. - Added recursive file search.
  835.  
  836. - Added option to list runnable files.
  837.  
  838. - Added ability to add an asterisk to include statements to signify the inclusion of a directories entire contents.
  839.  
  840. - Added new test cases for the feature above.
  841.  
  842. - Updated Help and Tests classes.
  843.  
  844. - Updated documentation.
  845.  
  846. - Added this change log, as this is the first revision.
  847.  
  848.  
  849. ==Sources==
  850.  
  851. ASCII table. ASCII Table - ASCII Character Codes, HTML, Octal, Hex, Decimal. (n.d.). Retrieved January 16, 2022, from https://www.asciitable.com/
  852.  
  853. Bf. Esolang. (n.d.). Retrieved January 16, 2022, from https://esolangs.org/wiki/Bf (Swear word removed.)
  854.  
  855. Macrobeep. Esolang. (n.d.). Retrieved January 16, 2022, from https://esolangs.org/wiki/MacroBeep
  856.  
  857. Wikimedia Foundation. (2021, December 25). Extended backus-naur form. Wikipedia. Retrieved January 17, 2022, from https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form#Table_of_Symbols
  858.  
  859. Wikimedia Foundation. (2022, January 4). Turing completeness. Wikipedia. Retrieved January 16, 2022, from https://en.wikipedia.org/wiki/Turing_completeness
  860.  
  861. Wikimedia Foundation. (2022, January 14). Turing machine. Wikipedia. Retrieved January 16, 2022, from https://en.wikipedia.org/wiki/Turing_machine
  862.  
  863. ==Contents==
  864.  
  865. Acknowledgements
  866. Introduction to MacroBeep
  867. Language Paradigm and Memory
  868. Instruction Set
  869. The Preprocessor
  870. Program Examples
  871. Error Codes
  872. Turing Machines and the MacroBeep Tape
  873. Proof of Turing Completeness
  874. Grammar in EBNF
  875. Interpreter Test Cases in Java
  876. ASCII Table Reference
  877. Change Log
  878. Sources
  879.  
  880. =End of Documentation (Scroll Up)=
  881.  
  882.  
  883.  
  884.  
Add Comment
Please, Sign In to add comment
Public Pastes
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!