COBOLD

COBOLD (also known as YipYap) is a programming language for Kobolds (who are known to make Yip and Yap noises).
== Syntax ==
A COBOLD program must start with yip yap followed by whitespace-separated commands.
Comments are prefixed with owo and they continue until the following newline.
== Execution and Memory model ==
COBOLD memory model consists of three values:
Name 	Initial Value	Description
Hold Register 	1 	An 8-bit unsigned integer value, used by most command as operand
Memory Tape 	[0] 	A one dimensional array of 8 bit unsigned integers, that can grow as needed (new cells will be initialized with 0)
Memory Pointer	0 	A pointer to a cell in the Memory Tape, it can be increased or decreased
Decreasing the memory pointer below 0 will result in an error.
There is an opaque call stack used to call / return from functions that cannot be modified directly.
== Commands ==
For simplicity the pseudocode column will contain a C-like code referencing the Hold Register as hold, Memory Tape as memory, Memory Pointer as ptr.
Command	Pseudocode 	Description
yip 	ptr++ 	Increase tape pointer, adding new empty cells as needed
yap 	ptr-- 	Decrease tape pointer
yip? 	if (!hold) goto next yap!	Jump after the next yip! if hold is zero
yap? 	hold = min(*ptr, hold) 	Set hold to the current tape cell if it's less than hold
yip! 	hold -= *ptr 	Subtract the current tape cell from hold
yap! 	goto prev yip? 	Jump to the previous yip?
Yip 	print(chr(hold)) 	Output hold as character
Yap 	hold += *stack 	Add stack value to hold
Yip! 	print(hold) 	Output hold as a number
Yap! 	return 	Returns from a function to its invocation. If there is no function being called, terminates the program.
Yip? 	void func() {} 	Defines a function (or label) whose name is the next token
Yap? 	func() 	Invoke the function represented by the next token, pushing the position of the next command into the call stack
yipyip 	hold = *ptr 	Assign the current tape cell to hold
yipyap 	swap(hold, *ptr) 	Swap hold and current tape cell value. This is the only command that can modify the contents of the memory tape.
yapyip 	hold++ 	Increase hold value by 1
yapyap 	hold-- 	Decrease hold value by 1
== Functions ==
Functions are defined by Yip? followed by any valid token.
You can call a function by using Yap? followed by the corresponding function token. Doing so will push the current program location into the call stack.
Yap! will pop the call stack and resume execution from the invocation point.
== Examples ==
=== Hello World ===
yip yap owo Program header
yapyip owo increases hold by 1, setting it to 2 (it's initialized with 1)
yipyap owo swaps hold and tape cell
Yap Yap owo adds the tape cell onto hold twice, obtaining 4
yipyap owo swaps again, now the cell has 4 and hold has 2
Yap Yap Yap owo adds the cell onto hold 3 times, gettting 14
yipyap owo swaps, now cell has 14 and hold has 4
Yap Yap Yap Yap Yap owo adds the cell onto hold 5 times, getting 74
yapyap yapyap owo decreases hold twice, getting 72 (ASCII 'H')
Yip owo prints 'H'
Yap Yap yapyip owo adds 14 twice and increases by one to get 'e'
Yip owo prints 'e'
yipyap yipyip owo stores 'e' onto the tape (swap and load)
yip yipyap yip owo copies 'e' onto the next cell and moves
yapyip yapyip yipyap owo stores 2 onto the next cell
Yap Yap Yap yapyip 
yap Yap owo gets 'l' into hold 
Yip Yip owo prints 'l' twice
yip yip yip yipyap yipyip owo moves two cells right, stores 'l' and moves back
yap yap Yap yapyip Yip owo gets 'o' onto the tape and prints it 
yipyap yip yipyap yipyip Yap owo stores 4 onto the tape
yipyap yipyip Yap 
yipyap yipyip Yap
yipyap yipyip Yap owo adds 4 multiple times to get 32 on hold (space) and 16 on tape
Yip owo prints the space
yap yap yipyap owo swaps 'e' with 32 from the tape
yip yip yip! owo subtracts 10 from 'e' to get 'U' 
yapyip yapyip owo decreases twice to get 'W'
Yip owo prints 'W'
yap yipyap Yip owo get 'o' from the tape and prints it
yapyip yapyip yapyip Yip owo decreases 3 times to get 'r' and prints it
yip yip yipyap Yip owo gets 'l' from the tape and prints it
yap yap yap yap yipyap yapyap owo gets 'e' from the tape, decreases it to get 'd'
Yip owo prints 'd'
=== Duplicate String ===
The following example duplicates a NUL-terminated string, and defines some useful string-manipulating functions.
Note that the tape would need to be initialized with something for this to work.
yip yap
 
owo strlen
yip Yap? yap?
owo write length
yip yipyap yipyip
 
owo while length is != 0
yip?
  owo move to the next letter
  yap Yap? yip!
  owo move cell to the end
  yipyip Yap? yip yipyap yip Yap? yip
  owo find the length
  Yap? yap yip
  owo decrement length
  yipyip yapyap yipyap yapyap
yap!
 
Yap!
 
owo Swap adjacent cells
owo Pre [a<, b] hold=c
owo Post: [b<, a] hold=c
Yip? yipyap
  owo perform 3 swaps
  yipyap yip yipyap yap yipyap
  Yap!
 
owo Strlen
owo Pre [S<, t, r, i, n, g, 00]
owo Post[S, t, r, i, n, g, 00<] hold=strlen
Yip? yap?
  owo Clear hold
  yipyip yip!
 
  owo Load first cell
  yipyap
  owo while not 0
  yip?
  owo put it back
  yipyap
  owo increase size
  yapyip
  owo move and load next cell
  yip yipyap
  yap!
  owo swap back
  yipyap
 
  Yap!
 
owo Print nul-terminated string
owo Pre [S<, t, r, i, n, g, 00]
owo Post[S, t, r, i, n, g, 00<] hold=0, printed String
Yip? Yip
  yipyip
  yip? Yip yip yipyip yap!
  Yap!
 
owo Go to previous 00, preserving hold
owo Pre [00, ..., xx<] hold=a
owo Post [00<, ..., xx] hold=a
Yip? yap
  owo load first cell
  yipyap
  owo while not 0
  yip?
  owo swap back and move 1 behind
  yipyap yap yipyap
  yap!
  owo final swap
  yipyap
  Yap!
 
owo Move hold to next 00
owo Pre [xx<, ..., 00] hold=aa
owo Post [xx, ..., aa<] hold=0
Yip? yip
  owo load first cell
  yipyap
  owo while not 0
  yip?
  owo swap back and move 1 ahead
  yipyap yip yipyap
  yap!
 
  Yap!
 
owo Move back "hold" spaces
owo Pre [b1, ..., bn<] hold=n
owo Post [b1<, ..., bn] hold=0
Yip? yip!
  owo while not 0
  yip?
  owo decrement
  yapyap
  owo move 1 behind
  yap
  yap!
  Yap!
== External Links ==
* Glax's site contains a description of the and a web-based interpreter and debugger.
* yipyap.py Python-based interpreter of the language
Category:Cell-based 
Category:Implemented 
Category:Languages
Category:2024
Category:Turing complete
Category:Output only
Category:Thematic