API tools faq
paste
PixelatedStarfish

Documentation

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