bbcode v0.1

[bbcode]
[title="Hello World"]
[author="Anonymous"]

[main]
  [let="a"]5[/let]
  [while]a>0[do]
  [let="a"]a-1[/let]
  Hello, World!
  [val="a"]
  [/do]
  [/while]
  [call="test"]
[/main]

[test]
hihihi world!
[/test]

[/bbcode]

suggest and improve.

That looks like BASIC.
I'm willing to write a BBCode parser as long as someone comes up with good syntax.

Maybe use an ENTERPRISE TEXT FORMATING ALGORITHM to show off your true understanding of BBCode.

How about this
To define a tag you write [:hello].
Example

[:expert][b][u][o][][/o][/u][/b][/:]

[expert]I AM AN EXPERT PROGRAMMER[/expert]
You can explicity specify how many arguments a bbcode tag can have

[0:2br][br][br][/:]
So [2br] => [br][br]
[2br]wtf[/2br] produces an error by the parser/compiler.

For this to work, we need a good standard tag library.

>>4
Oh yeah, and [] is the array of arguments, while [n] is that certain argument.

To call a function you simply [function_name] not that [call="function_name"] crap

[bbcode]

[int=a][/int]
[for=a, 1 to 100]
 [print]a[/print]
 [if=0]mod a 3[append]"fizz"[/append][/if]
 [if=0]mod a 5[append]"buzz"[/append][/if]
 [+=a]1[/+]
[/for step=1]

[/bbcode]

Thank god you people don't design languages

should look more like, b isnt used, but just to demonstrate

[include="path_if_not_in_same_directory_as_compiler"]
stdio.h, stdlib.h
[/include]

[main]

[var=int]a, b[/var]

[for=1:100; a, b]
  [print=a, b][/print]
  [if=0; a]mod a 3 this is comment[print="fizz"][/print][/if]
  [if=0; a]mod a 5 this is comment[print="buzz"][/print][/if]
  [op=add; a 1][/op]
[/for]

[/main]

>>8
Do you seriosuly want to write 'add' each time you want addition?
How about
[op=+; a 1]
Or even [+ a 1]

>>9

just make it [+:a, 1] with no [/+] because that looks retarded

>>10
Orly? Wtf is +: supposed to mean?
Fuck, we need to write a BBCode standard, and then the compiler/interpreter.

Proposed syntax:

[cοde]
for i in range(1, 10):
    print 'OMG BBCode!!!'
[/cοde]

screw you people, i've already started defining a syntax, and it is superior to yours.
e.g:

[BBCPL]
[DEF = "EXPERT"][b][o][u]^[/u][/o][/b][/DEF]
[DEF = "LINK"]<a href ="$1">^</a>
[FOR = " [INT = "i"]o[/INT]:[i]<5:[+[i],1]]
[LOL]
[/FOR]
[/BBCPL]

[FUNC = "LOL"]
     [PRINT]Hello world!
     [EXPERT]EXPERT BBCODE PROGRAMMING![/EXPERT]
     [LINK ="http://mitpress.mit.edu/sicp/"]READ SICP![/LINK][/PRINT]
[/FUNC]

as you can see, this is EXPERT BBCODE

>>13
I wouldn't trust the defining of BBCode syntax to someone who can't write well-formed BBCode.

Enjoy your fucking endless rendering loops

I propose Scheme with square brackets, adding a few functions to the standard library, namely:

[define [b] "<B>"]
[define [/b] "</B>"]

etc.

I laughed reading this thread.
Also, >>7 is an awesome post.

srsy, how going to make the compiler?

There needs to be a decent language specification first.

[define add[+ a b]]
[add 3 4]

Output : 7

Perfect lisp-like syntax

>>20
ewwwww. lisp.

>>20
That's much better than those steaming piles of crap suggested by the imperative fuckwits, but still that's only lisp with parentheses replaced with square braces. That doesn't make it any more interesting.

>>22
Not at all. Note, for example, how he cleverly disposed of explicit argument declaration, and instead went for simple automatic argument assignment to a b c ...

[definition]
[name]factorial[/name]
[style]function[/style]
[computation]0,0[/computation]
[computation]x,x*[factorial]x-1[/factorial][/computation]
[/definition]

[factorial]4[/factorial]


24

>>24
Too [b]ENTERPRISE[/b].

fail


[?bbcode
function expertProgrammer[ $$$ ][
    unshift[__$__]
    goto[return] swap : [unshift . $]
]
getFunctionByTagName[`expertProgrammer'][0].__call__
?]

>>20
Pretty good, but we should take advantage of the ability to name or not name blocks as we wish.

[define]
  add-pair
  [+]a b[/+]
[/define]

# [add-pair]1 5[/add-pair]6
# [add-pair]1 5 [atom name=lol]``code''[/atom][/add-pair]6
Numbers and strings written alone are shorthand for [atom]value[/atom]. If they are given as parameters to a function, they get the names a, b, c, etc. The symbol "args" is a list of all unnamed arguments. When a function foo (e.g. [foo]) is followed by one or more parameters of the form n=x (e.g. [foo n=x]), those symbols are bound to those values in the environment that function is evaluated in. They go out of scope when it ends. However, a function may also return a named value which enters the environment "the next level up". So, in the last example, [add-pair] is evaluated, then its arguments 1 and 5 are evaluated and assigned the symbols a and b, respectively. Then the next argument is evaluated. Atom's environment contains the binding 'name = "lol"', and creates the binding 'lol = 7' in its caller's environment. If we were to add the code [when][boundp]lol[/][return]``idk, 60 million lol''[/return][/when] to add-pair, then the second example would return the string ``idk, 60 milion lol'' in the second example, rather then the correct answer of 6. Also note that [/] may be used to close a block if your typing finger is tired, and that quotes are written ``'' for enterprise-grade nestability.

>>28
I like your idea, except for this:

Also note that [/] may be used to close a block if your typing finger is tired

>>28,29

How about [<tab>?

>>30
Actually, that'd be an editor feature and it doesn't have anything to do with the actual language

>>31 despite your moot comment I acknowledge your awesome ID.

Holy fuck

>>33
Not quite as awesome as sunp0mer, but awesome nonetheless.

I already have a BBCode specification, it's called R5RS + >>16

>>31,33 has one of the best IDs I've seen

Actually, the ``Scheme with square brackets'' is not that great. It doesn't follow the traditional BBCode syntax very well. >>28 has the right idea.

>>36
Why? It's backwards compatible with existing BBCode, as long as you make b, /b, etc. functions that return HTML.

>>38
It doesn't follow the semantics. In scheme, you do (foo a b c) where in BBCode you need to write [foo]a b c[/foo] to keep it consistent with how the pre-existing tags work.

>>39
I propose that anything at top level that is not a function call should be treated as literal (and HTML-escaped). This way:
[b]a b c[/b]
would be treated as (display "<B>") (display (html-escape "a b c")) (display "</B>") yet
[foo a b c]
would be treated as (foo a b c).

The problem with [foo]a b c[/foo] is how to treat what's outside the square brackets. Is it three symbols? A string? Is whitespace significant? Etc. We'd have to treat everything outside [] as a whitespace-sensitive string, and all functions would have to be functions of one string argument returning one string. And this means we can't return functions. And this means we can't fix the one arg limit as you would in Lambda Calculus. Unless you allow nesting [], which would be piss ugly... (add 1 2) would become:
[[add]1[/add]]2[/[add]1[/add]]

All of this means we'd be getting something worse than Tcl. So I propose a Lisp, with the toplevel exception I described.