Danicb

Danicb is a programming language which is based on many other programming languages. This language is most obviously based on a language called Danica made by someone who does not wish to be named, but its rules are noticeably different.
==User Code==
The user code can only consist of f and space. If any other characters are included, the error "f" is thrown. Groups of f's are separated by spaces.
There can only be groups of 1 to 6 f's, inclusive. If there are groups of more or less (i.e. two spaces in a row), the error "f" is thrown.
== Program Execution ==
First, all of the f's are turned into letters using the following correspondence.
 Letter to Code Correspondence
Letter	Representation
a 	f f
b 	f ff
c 	f fff
d 	f ffff
e 	f fffff
f 	ff f
g 	ff ff
h 	ff fff
i 	ff ffff
j 	ff fffff
k 	fff f
l 	fff ff
m 	fff fff
n 	fff ffff
o 	fff fffff
p 	ffff f
q 	ffff ff
r 	ffff fff
s 	ffff ffff
t 	ffff fffff
u 	fffff f
v 	fffff ff
w 	fffff fff
x 	fffff ffff
y 	fffff fffff
z 	ffffff
In all subsequent cases, the representation using letters instead of different numbers of f will be referred to as the wimpmode.
Then, some of these letters are turned into characters. Once the letters have accomplished their purpose, they either disappear or are replaced by the character they represent:
 Caption text
Word 	Result
First Pass (Important to Comprehension)	First Pass (Important to Comprehension)
cap 	Makes the following letter a capital letter
Second Pass (Important to Visuals) 	Second Pass (Important to Visuals)
amp 	Turns into the character &
ast 	Turns into the character *
bak 	Turns into the character \
car 	Turns into the character ^
cbc 	Turns into the character }
cbk 	Turns into the character ]
col 	Turns into the character :
com 	Turns into the character ,
cpr 	Turns into the character )
dot 	Turns into the character .
eight 	Turns into the character 8
eq 	Turns into the character =
exc 	Turns into the character !
five 	Turns into the character 5
four 	Turns into the character 4
gt 	Turns into the character >
lt 	Turns into the character <
new 	Turns into the character for a newline
nine 	Turns into the character 9
one 	Turns into the character 1
obc 	Turns into the character {
obk 	Turns into the character [
opr 	Turns into the character (
quot 	Turns into the character "
pipe 	
seven 	Turns into the character 7
six 	Turns into the character 6
slash 	Turns into the character /
space 	Turns into the character for a space
three 	Turns into the character 3
two 	Turns into the character 2
und 	Turns into the character _
Second Pass (Important to Code) 	Second Pass (Important to Code)
sar 	indicates a break between two separate arguments
tar 	indicates that arguments have either started being indicated or stopped being indicated, defaults to "not being indicated" at start of code
tst 	indicates that the text either is or is not a string, defaults to "not a string" at start of code
Final Pass (Important to Both) 	Final Pass (Important to Both)
del 	deletes the character before it
Then, the actual code starts working. Text can either be:
*an instruction, one of five specific words followed by tar
*an argument, after the tar which follows an instruction but before the next tar
*a string label, neither an instruction nor an argument, surrounded by tst on either side
*variable label, neither an instruction nor an argument, not surrounded by tst
There are five instructions: print, read, >jump, <jump, =jump.
 Caption text
Word 	Result 	Use of Second Pass
print 	
checks if there are any sars between the next two tars
throws the error "f" if so 
otherwise, prints output to console	tar used to surround all the arguments of this function, tst used to toggle between variables and strings or concatenate the value of the two variables around it by typing it twice
read 	assigns values from object given to one or multiple variables:
*assigns value of string if the first argument starts with tst
*takes in value from input otherwise
*checks that all the arguments other than the first are not strings
*throws the error "f" if any of them are strings
when there is more than one variable, the variables before the end will contain one character until either:
#there are no more characters (next variables will be empty)
#the last variable shows up (the rest of the characters will be in this variable)	tar used to surround all the arguments of this function, sar used to toggle between arguments, tst used before and after ends of string, or to surround the value of a variable in a string in order to
All the following commands throw the error "f" if they have more than two arguments.	All the following commands throw the error "f" if they have more than two arguments.	All the following commands throw the error "f" if they have more than two arguments.
greater 	checks whether the first string (or the string represented by that variable) is greater in length than the second string (or the string represented by that variable) 
if yes, checks the second argument.
*if it is a string
**jumps to the first instance of the string outside of any arguments
**throws the error "f" otherwise
*if it is a variable
**jumps to the first instance of the string represented by the variable outside of any arguments
**jumps to the first instance of the variable outside of any arguments if the represented string is not available
**throws the error "f" otherwise
if no, does not jump	tar used to surround all the arguments of this function, sar used between arguments, tst used within an argument to toggle between variables and strings or concatenate the value of the two variables around it by typing it twice
small 	checks whether the first string, or the string represented by that variable, is less in length than the second string, or the string represented by that variable 
if yes, checks the second argument.
*if it is a string
**jumps to the first instance of the string outside of any arguments
**throws the error "f" otherwise
*if it is a variable
**jumps to the first instance of the string represented by the variable outside of any arguments
**jumps to the first instance of the variable outside of any arguments if the represented string is not available
**throws the error "f" otherwise
if no, does not jump	tar used to surround all the arguments of this function, sar used between arguments, tst used within an argument to toggle between variables and strings or concatenate the value of the two variables around it by typing it twice
compare 	checks whether the first string (or the string represented by that variable) is the same as (not just equal in length to) the second string (or the string represented by that variable) 
if yes, checks the second argument.
*if it is a string
**jumps to the first instance of the string outside of any arguments
**throws the error "f" otherwise
*if it is a variable
**jumps to the first instance of the string represented by the variable outside of any arguments
**jumps to the first instance of the variable outside of any arguments if the represented string is not available
**throws the error "f" otherwise
if no, does not jump	tar used to surround all the arguments of this function, sar used between arguments, tst used within an argument to toggle between variables and strings or concatenate the value of the two variables around it by typing it twice
== Example Code ==
In some instances, the wimpmode code will be written in a way which puts functions and labels on their own lines. Keep in mind this is invalid code and will not run.
=== Hello, World! ===
ffff f ffff fff ff ffff fff ffff ffff fffff ffff fffff f f ffff fff ffff fffff ffff ffff ffff fffff f fff f f ffff f ff fff f fffff fff ff fff ff fff fffff f fff fff fffff fff fff ffff ffff ffff f f f f fff f fffff f fff f f ffff f fffff fff fff fffff ffff fff fff ff f ffff f fffff fffff ffff f fff ffff fffff ffff ffff ffff fffff ffff fffff f f ffff fff
prints Hello, World!
printtartstcaphellocomspacecapworldexctsttar
=== Cat Program ===
ffff fff f fffff f f f ffff ffff fffff f f ffff fff ffff fffff ffff ffff ffff fffff ffff fffff ffff ffff ffff fffff ffff ffff f f ffff fff f ff f fffff ff ff ff ffff fff ffff ffff fffff f f ffff fff f ff f fffff ff ff ff ffff fff ffff ffff fff f fffff f f f ffff ffff fffff f f ffff fff f f ffff fff ff ff ffff fffff f f ffff fff ffff f ffff fff ff ffff fff ffff ffff fffff ffff fffff f f ffff fff f f ffff fff ff ff ffff fffff f f ffff fff ff ff ffff fffff ff fffff fffff f fff fff ffff f ffff fffff f f ffff fff f f ffff fff ff ff ffff ffff f f ffff fff f ff f fffff ff ff ff ffff fff ffff ffff fffff f f ffff fff
readtartsttstsarbegintarbeginreadtarargtarprinttarargtargtjumptarargsarbegintar
readtartsttstsarbegintar (assigns the value of an empty string to "begin")
begin (this is the label, the variable which contains the empty string)
readtarargtar (reads a value into "arg")
printtarargtar (prints the value in "arg")
gtjumptarargsarbegintar (halts if "arg" is the empty string, otherwise jumps to "begin")
== Computational Class ==
This language should theoretically be Turing-complete.
==Implementation==
Category:Languages
Category:Unimplemented
Category:Unknown computational class
Category:2023