Hi!
neos universal compiler is successfully running the tokenization stage tokenizing a program written in the neos reference language. #cpp #coding #compiler #compsci #gamedev
On 3/14/2025 8:11 PM, Mr Flibble wrote:
Hi!
neos universal compiler is successfully running the tokenization stage
tokenizing a program written in the neos reference language. #cpp
#coding #compiler #compsci #gamedev
#gamedev? What is that?
On Sat, 15 Mar 2025 13:46:20 -0700, Chris M. Thomasson wrote:
On 3/14/2025 8:11 PM, Mr Flibble wrote:
Hi!
neos universal compiler is successfully running the tokenization stage
tokenizing a program written in the neos reference language. #cpp
#coding #compiler #compsci #gamedev
#gamedev? What is that?
Video game development.
On 3/15/2025 6:13 PM, Mr Flibble wrote:
On Sat, 15 Mar 2025 13:46:20 -0700, Chris M. Thomasson wrote:
On 3/14/2025 8:11 PM, Mr Flibble wrote:
Hi!
neos universal compiler is successfully running the tokenization stage >>>> tokenizing a program written in the neos reference language. #cpp
#coding #compiler #compsci #gamedev
#gamedev? What is that?
Video game development.
Do you have support for HLSL and GLSL shaders in there?
Introducing the universal compiler, neos, that can compile ANY
programming language.
The following schema (grammar) file is an input to the compiler:
%{
meta: {
language: "neoscript"
description: "Default neoGFX scripting language"
source.file.extension: ".neo"
source.package.specification.file.extension: ".neo"
source.package.implementation.file.extension: ".neo"
copyright: "Copyright (C) 2024 Leigh Johnston"
version: "1.0.0"
}
stages: {
tokenizer : {
text : [ "#{" "}#" ]
}
parser : {
text : [ "*{" "}*" ]
root : program
}
}
pipeline: [
tokenizer parser
]
libraries: [
neos.core neos.math.universal
]
discard: [
whitespace comment WS
]
infix: [
math.operator.add math.operator.subtract math.operator.multiply
math.operator.divide
]
}%
#{
character literal ::=
( '\'' , ( ( ' ' .. '\xFF' - ( '\\' | '\"' | '\'' ) ) | escaped character ) $ string.utf8.character, '\'' ) ;
string literal ::=
{ '\"' , { ( ( ' ' .. '\xFF' - ( '\\' | '\"' | '\'' ) ) |
escaped
character ) } $ string.utf8 , '\"' , [ whitespace ] } + ;
escaped character $ string.utf8.character.LF ::= "\\n" ;
escaped character $ string.utf8.character.CR ::= "\\r" ;
escaped character $ string.utf8.character.tab ::= "\\t" ;
escaped character $ string.utf8.character.singlequote ::= "\\\'" ;
escaped character $ string.utf8.character.doublequote ::= "\\\"" ;
escaped character $ string.utf8.character.backslash ::= "\\\\" ;
using $ language.keyword ::= potential keyword ::= "using" ;
import $ language.keyword ::= potential keyword ::= "import" ;
namespace $ language.keyword ::= potential keyword ::= "namespace" ;
public $ language.keyword ::= potential keyword ::= "public" ;
protected $ language.keyword ::= potential keyword ::= "protected" ;
private $ language.keyword ::= potential keyword ::= "private" ;
override $ language.keyword ::= potential keyword ::= "override" ;
final $ language.keyword ::= potential keyword ::= "final" ;
mutable $ language.keyword ::= potential keyword ::= "mutable" ;
is $ language.keyword ::= potential keyword ::= "is" ;
extends $ language.keyword ::= potential keyword ::= "extends" ;
implements $ language.keyword ::= potential keyword ::= "implements"
;
struct $ language.keyword ::= potential keyword ::= "struct" ;
class $ language.keyword ::= potential keyword ::= "class" ;
interface $ language.keyword ::= potential keyword ::= "interface" ;
auto $ language.type.auto ::= potential keyword ::= "auto" ;
def $ language.keyword ::= potential keyword ::= "def" ;
fn $ language.keyword ::= potential keyword ::= "fn" ;
proc $ language.keyword ::= potential keyword ::= "proc" ;
in $ language.keyword $ language.function.parameter.in ::= potential keyword ::= "in" ;
out $ language.keyword $ language.function.parameter.out ::=
potential
keyword ::= "out" ;
inout $ language.keyword $ language.function.parameter.inout ::= potential keyword ::= "inout" ;
if $ language.keyword ::= potential keyword ::= "if" ;
else $ language.keyword ::= potential keyword ::= "else" ;
for $ language.keyword ::= potential keyword ::= "for" ;
while $ language.keyword ::= potential keyword ::= "while" ;
do $ language.keyword ::= potential keyword ::= "do" ;
return $ language.keyword ::= potential keyword ::= "return" ;
number $ math.universal.number ::=
digit sequence , [ '.' , digit sequence , [ ( "e" | "E" ) , [
"+"
| "-" ] , digit sequence ] ] ;
digit sequence ::=
digit , { digit } ;
digit ::=
"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
isize $ language.type.object.size.signed ::= potential keyword ::= "isize" ;
usize $ language.type.object.size.unsigned ::= potential keyword ::= "usize" ;
bool $ language.type.boolean ::= potential keyword ::= "bool" ;
i8 $ language.type.i8 ::= potential keyword ::= "i8" ;
u8 $ language.type.u8 ::= potential keyword ::= "u8" ;
i16 $ language.type.i16 ::= potential keyword ::= "i16" ;
u16 $ language.type.u16 ::= potential keyword ::= "u16" ;
i32 $ language.type.i32 ::= potential keyword ::= "i32" ;
u32 $ language.type.u32 ::= potential keyword ::= "u32" ;
i64 $ language.type.i64 ::= potential keyword ::= "i64" ;
u64 $ language.type.u64 ::= potential keyword ::= "u64" ;
float $ language.type.float ::= potential keyword ::= "float" ;
double $ language.type.double ::= potential keyword ::= "double" ;
character $ language.type.character ::= potential keyword ::= "char"
;
string $ language.type.string ::= potential keyword ::= "string" ;
true $ language.object.boolean.true ::= potential keyword ::= "true"
;
false $ language.object.boolean.false ::= potential keyword ::=
"false" ;
identifier ::= { namespace , namespace separator } , ( alpha ,
{ alphanumeric | '_' } ) $ language.identifier ;
namespace $ language.namespace ::= alpha , { alphanumeric | '_' } ;
package name ::= alpha , { alpha | ( "." , alpha ) } ;
potential keyword ::= { alphanumeric } + ;
alpha ::= 'A' .. 'Z' | 'a' .. 'z' ;
alphanumeric ::= alpha | '0' .. '9' ;
open expression ::= "(" ;
close expression ::= ")" ;
open scope $ language.scope.open ::= "{" ;
close scope $ language.scope.close ::= "}" ;
comma ::= "," ;
colon ::= ":" ;
semicolon ::= ";" ;
arrow ::= "->" ;
namespace separator ::= "::" ;
assign ::= "=" ;
not ::= "!" ;
or ::= "||" ;
and ::= "&&" ;
equal ::= "==" ;
notequal ::= "!=" ;
lessthan ::= "<" ;
greaterthan ::= ">" ;
lessthanorequal ::= "<=" ;
greaterthanorequal ::= ">=" ;
plus ::= "+" ;
minus ::= "-" ;
multiply ::= "*" ;
divide ::= "/" ;
comment $ language.comment ::= "--" , { ! '\n' .. '\n' } , ( '\n' |
?
eof ? ) ;
whitespace $ language.whitespace ::= { ' ' | '\n' | '\r' | '\t' |
comment | ? eof ? } + ;
}#
*{
program $ language.program ::= { WS , ( using directive | import directive | namespace scope ) , WS } ;
using directive $ source.package.import ::= ( using , WS ,
( identifier | package name ) $ source.package.name , WS , semicolon ) ;
import directive $ language.function.import ::= ( import , WS , fn ,
WS , fn sig , WS , semicolon ) ;
import directive $ language.function.import ::= ( import , WS , proc
,
WS , proc sig , WS , semicolon ) ;
namespace scope $ language.namespace.scope ::=
{ comment | function | procedure | namespace def } ;
namespace def $ language.namespace ::=
identifier $ language.namespace.name , WS , open scope , WS , namespace scope , WS , close scope ;
function $ language.function ::= ( fn , WS , fn sig , WS , fn body )
;
procedure $ language.function ::= ( proc , WS , proc sig , WS , proc locals , WS , proc body ) ;
fn sig $ language.function.signature ::= ( identifier , WS , open expression , WS , fn parameters , WS , close expression , WS , arrow ,
WS , type ) ;
proc sig $ language.function.signature ::= ( identifier , WS , open expression , WS , proc parameters , WS , close expression ) ;
fn parameters $ language.function.parameters ::= [ fn parameter
block , { WS , semicolon , WS , fn parameter block } ] ;
proc parameters $ language.function.parameters ::= [ proc parameter
block , { WS , semicolon , WS , proc parameter block } ] ;
fn parameter block ::= [ parameter , { WS , comma , WS , parameter }
,
WS , colon , WS , type ] ;
proc parameter block ::= [ parameter , { WS , comma , WS ,
parameter } , WS , colon , WS , ( in | out | inout ) , WS , type ] ;
parameter $ language.function.parameter ::= identifier ;
proc locals ::= ( proc local block , { WS , semicolon , WS , proc
local block } ) ;
proc local block ::= [ local , { WS , comma , WS , local } , WS ,
colon , WS , type ] ;
local $ language.function.local ::= identifier ;
fn body $ language.function.body ::= scope ;
proc body $ language.function.body ::= scope ;
scope $ language.function.scope ::= ( open scope , { WS ,
statement } , WS , close scope ) ;
statement $ language.statement ::=
( expression , WS , semicolon ) | ( assignment , WS , semicolon
)
| return statement | if statement | for loop | while loop | do while
loop ;
assignment $ language.assignment ::=
( object , WS , assign , WS , expression ) ;
expression $ language.expression ::=
function call | numeric expression | boolean expression ;
function call $ language.expression.call ::=
identifier $ language.function.name , WS , open expression , WS
,
arguments , WS , close expression ;
arguments ::= [ expression , { WS , comma , WS , expression } ] ;
boolean expression $ language.expression.boolean ::=
boolean term , { WS , or , WS , boolean term } $ boolean.logic.operator.or ;
boolean term ::=
boolean factor , { WS , and , WS , boolean factor } $ boolean.logic.operator.and ;
boolean factor ::=
true
| false | ( not , WS , boolean factor ) $
boolean.logic.operator.not | ( open expression , WS , boolean
expression , WS , close
expression )
| comparison expression ;
comparison expression ::=
numeric expression , WS , comparison operator , WS , numeric expression ;
comparison operator ::=
equal $ boolean.operator.relational.equal
| notequal $ boolean.operator.relational.notequal | lessthan $
boolean.operator.relational.lessthan | greaterthan $
boolean.operator.relational.greaterthan | lessthanorequal $
boolean.operator.relational.lessthanorequal | greaterthanorequal
$
boolean.operator.relational.greaterthanorequal ;
numeric expression $ math.expression ::=
term , { WS , ( plus $ math.operator.add | minus $ math.operator.subtract ) , WS , term } ;
term ::=
factor , { WS , ( multiply $ math.operator.multiply | divide $ math.operator.divide ) , WS , factor } ;
factor ::=
[ minus $ math.operator.negate , WS ] , primary ;
primary ::=
( open expression , WS , expression , WS , close expression ) | function call | number | identifier | character literal | string literal
;
return statement $ language.statement.return ::=
( return , WS , expression , WS , semicolon ) ;
if statement $ language.statement.if ::=
if , ( WS , open expression , WS , boolean expression , WS ,
close
expression , WS , ( scope | statement ) ) $ logic.operator.if , { WS ,
else if statement } , [ WS , else statement ] ;
else if statement $ language.statement.elseif ::=
else if , ( WS , open expression , WS , boolean expression , WS
,
close expression , WS , ( scope | statement ) ) $ logic.operator.elseif
;
else statement $ language.statement.else ::=
else , WS , ( scope | statement ) $ logic.operator.else ;
for loop $ language.statement.loop ::=
for clause , WS , scope ;
for clause ::=
for , WS , open expression , WS , [ local , WS , colon , WS ,
type , WS , assign , WS , expression ] $ language.assignment , WS ,
semicolon , WS , boolean expression , WS , semicolon , WS ,
( expression | assignment ) , WS , close expression ;
while loop $ language.statement.loop ::=
while clause , WS , scope ;
while clause ::=
while , WS , open expression , WS , boolean expression , WS ,
close expression ;
do while loop $ language.statement.loop ::=
do , WS , scope, WS , while clause ;
type ::= bool | i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64 | float
|
double | character | string | object ;
WS ::= [ whitespace ] ;
}*
which is used to compile the following program:
-- neoscript example: Fibonacci
using neo.string;
using neo.stream;
-- functions are pure fn add(x, y : i32) -> i32 {
return x + y;
}
fn fib(x : i32) -> i32 {
if (x < 2)
return 1;
else
return add(fib(x-1), fib(x-2));
}
-- procedures are impure proc main()
s : string;
{
neo::print("Enter a positive "
"integer: ");
neo::input(s);
neo::print("Fibonacci(" + s + ") = " + neo::to_string(fib(neo::to_integer(s))) + "\n");
}
which generates the following AST (semantics):
source.package.import = [using neo.string;]
language.keyword = [using]
source.package.name = [neo.string]
source.package.import = [using neo.stream;]
language.keyword = [using]
source.package.name = [neo.stream]
language.namespace.scope = [fn add(x, y : i32) -> i32\r\n{\r\n
return
x + y;\r\n}]
language.function = [fn add(x, y : i32) -> i32\r\n{\r\n return x +
y;
\r\n}]
language.keyword = [fn]
language.function.signature = [add(x, y : i32) -> i32]
language.identifier = [add]
language.function.parameters = [x, y : i32]
language.function.parameter = [x]
language.identifier = [x]
language.function.parameter = [y]
language.identifier = [y]
language.type.i32 = [i32]
language.type.i32 = [i32]
language.function.body = [{\r\n return x + y;\r\n}]
language.function.scope = [{\r\n return x + y;\r\n}]
language.scope.open = [{]
language.statement = [return x + y;]
language.statement.return = [return x + y;]
language.keyword = [return]
language.expression = [x + y]
math.expression = [x + y]
language.identifier = [x]
math.operator.add = [+]
language.identifier = [y]
language.scope.close = [}]
language.namespace.scope = [fn fib(x : i32) -> i32 \r\n{\r\n if (x <
2) \r\n return 1; \r...]
language.function = [fn fib(x : i32) -> i32 \r\n{\r\n if (x < 2)
\r\n return 1; \r...]
language.keyword = [fn]
language.function.signature = [fib(x : i32) -> i32]
language.identifier = [fib]
language.function.parameters = [x : i32]
language.function.parameter = [x]
language.identifier = [x]
language.type.i32 = [i32]
language.type.i32 = [i32]
language.function.body = [{\r\n if (x < 2) \r\n return 1;
\r\n else\r\n return...]
language.function.scope = [{\r\n if (x < 2) \r\n return 1;
\r\n else\r\n return...]
language.scope.open = [{]
language.statement = [if (x < 2) \r\n return 1; \r\n
else\r\n return add(fi...]
logic.operator.if = [if (x < 2) \r\n return 1; \r\n
else\r\n return add(fi...]
language.keyword = [if]
language.expression.boolean = [x < 2]
math.expression = [x]
language.identifier = [x]
boolean.operator.relational.lessthan = [<]
math.expression = [2]
math.universal.number = [2]
language.statement = [return 1;]
language.statement.return = [return 1;]
language.keyword = [return]
language.expression = [1]
math.expression = [1]
math.universal.number = [1]
language.statement.else = [else\r\n return add(fib(x-1), fib(x-2));]
language.keyword = [else]
language.statement = [return add(fib(x-1), fib(x-2));]
language.statement.return = [return add(fib(x-1), fib(x-2));]
language.keyword = [return]
language.expression = [add(fib(x-1), fib(x-2))]
language.expression.call = [add(fib(x-1), fib(x-2))]
language.function.name = [add]
language.expression = [fib(x-1)]
language.expression.call = [fib(x-1)]
language.function.name = [fib] language.expression = [x-1]
math.expression = [x-1]
language.identifier = [x] math.operator.subtract = [-]
math.universal.number = [1]
language.expression = [fib(x-2)]
language.expression.call = [fib(x-2)]
language.function.name = [fib] language.expression = [x-2]
math.expression = [x-2]
language.identifier = [x] math.operator.subtract = [-]
math.universal.number = [2]
language.scope.close = [}]
language.namespace.scope = [proc main()\r\n s : string;\r\n{\r\n neo::print("Enter a positive...]
language.function = [proc main()\r\n s : string;\r\n{\r\n neo::print("Enter a positive...]
language.keyword = [proc]
language.function.signature = [main()]
language.identifier = [main]
language.function.parameters = []
language.function.local = [s]
language.identifier = [s]
language.type.string = [string]
language.function.body = [{\r\n neo::print("Enter a positive
"\r\n "integer: ");\r\n...]
language.function.scope = [{\r\n neo::print("Enter a positive
"\r\n "integer: ");\r\n...]
language.scope.open = [{]
language.statement = [neo::print("Enter a positive "\r\n
"integer: ");]
language.expression = [neo::print("Enter a positive "\r\n
"integer: ")]
language.expression.call = [neo::print("Enter a positive
"\r\n "integer: ")]
language.function.name = [neo::print]
language.namespace = [neo]
language.expression = ["Enter a positive "\r\n
"integer:
"]
math.expression = ["Enter a positive "\r\n "integer:
"]
string.utf8 = [Enter a positive ]
string.utf8 = [integer: ]
language.statement = [neo::input(s);]
language.expression = [neo::input(s)]
language.expression.call = [neo::input(s)]
language.function.name = [neo::input]
language.namespace = [neo]
language.expression = [s]
math.expression = [s]
language.identifier = [s]
language.statement = [neo::print("Fibonacci(" + s + ") = " + neo::to_string(fib(neo::t...]
language.expression = [neo::print("Fibonacci(" + s + ") = " + neo::to_string(fib(neo::t...]
language.expression.call = [neo::print("Fibonacci(" + s + ") = "
+
neo::to_string(fib(neo::t...]
language.function.name = [neo::print]
language.namespace = [neo]
language.expression = ["Fibonacci(" + s + ") = " + neo::to_string(fib(neo::to_integer(s...]
math.expression = ["Fibonacci(" + s + ") = " + neo::to_string(fib(neo::to_integer(s...]
string.utf8 = [Fibonacci(]
math.operator.add = [+]
language.identifier = [s]
math.operator.add = [+]
string.utf8 = [) = ]
math.operator.add = [+]
language.expression.call = [neo::to_string(fib(neo::to_integer(s)))]
language.function.name = [neo::to_string]
language.namespace = [neo]
language.expression = [fib(neo::to_integer(s))]
language.expression.call = [fib(neo::to_integer(s))]
language.function.name = [fib] language.expression =
[neo::to_integer(s)]
language.expression.call = [neo::to_integer(s)]
language.function.name = [neo::to_integer]
language.namespace = [neo]
language.expression = [s]
math.expression = [s]
language.identifier = [s]
math.operator.add = [+]
string.utf8 = [\n]
string.utf8.character.LF = [\n]
language.scope.close = [}]
language.namespace.scope = []
language.namespace.scope = []
/Flibble
On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY
programming language.
On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble <flibble@reddwarf.jmc.corp> wibbled:
On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY
programming language.
I hope you're going to write a auto generator for that mess possibly
based on written instructions in english/french/whatever. Its
unreadable.
On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
wibbled:
On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY
programming language.
I hope you're going to write a auto generator for that mess possibly
based on written instructions in english/french/whatever. Its
unreadable.
eh? the neos grammar is based on EBNF so is human friendly.
On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble <flibble@reddwarf.jmc.corp> wibbled:
On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
<flibble@reddwarf.jmc.corp>
wibbled:
On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY
programming language.
I hope you're going to write a auto generator for that mess possibly
based on written instructions in english/french/whatever. Its
unreadable.
eh? the neos grammar is based on EBNF so is human friendly.
Its almost a solid slab of text.
On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
wibbled:
On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
<flibble@reddwarf.jmc.corp>
wibbled:
On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY
programming language.
I hope you're going to write a auto generator for that mess possibly
based on written instructions in english/french/whatever. Its
unreadable.
eh? the neos grammar is based on EBNF so is human friendly.
Its almost a solid slab of text.
It is based on EBNF so is human friendly.
On 19/03/2025 14:44, Mr Flibble wrote:
On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble
<flibble@reddwarf.jmc.corp>
wibbled:
On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
<flibble@reddwarf.jmc.corp>
wibbled:
On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY
programming language.
I hope you're going to write a auto generator for that mess possibly >>>>> based on written instructions in english/french/whatever. Its
unreadable.
eh? the neos grammar is based on EBNF so is human friendly.
Its almost a solid slab of text.
It is based on EBNF so is human friendly.
It's human friendly because Flibber says so. Flibber is never wrong, not
even when he's wrong.
And because magic, neos can (present tense) compile any programming
language, even though most languages have no schema at present. We know
this because Flibber is never wrong.
On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
wibbled:
On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
<flibble@reddwarf.jmc.corp>
wibbled:
On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY
programming language.
I hope you're going to write a auto generator for that mess possibly
based on written instructions in english/french/whatever. Its
unreadable.
eh? the neos grammar is based on EBNF so is human friendly.
Its almost a solid slab of text.
It is based on EBNF so is human friendly.
On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
And because magic, neos can (present tense) compile any programming
language, even though most languages have no schema at present. We know
this because Flibber is never wrong.
I am occassionally wrong but in this instance, dear, it is you that is >wrong.
Just because a language doesn't yet have a schema it doesn't follow that >neos couldn't compile it if a schema was created for it.
On Wed, 19 Mar 2025 15:16:50 GMT Mr Flibble <flibble@reddwarf.jmc.corp> wibbled:
On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
And because magic, neos can (present tense) compile any programming
language, even though most languages have no schema at present. We
know this because Flibber is never wrong.
I am occassionally wrong but in this instance, dear, it is you that is >>wrong.
Just because a language doesn't yet have a schema it doesn't follow that >>neos couldn't compile it if a schema was created for it.
Create one for C++ then. Imagine the plaudits, the groupies, the fame, appearing on Good Morning, the difficult 2nd schema, the drug years, the comeback. Etc etc.
On Wed, 19 Mar 2025 15:46:01 +0000, Muttley wrote:
On Wed, 19 Mar 2025 15:16:50 GMT Mr Flibble <flibble@reddwarf.jmc.corp>
wibbled:
On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
And because magic, neos can (present tense) compile any programming
language, even though most languages have no schema at present. We
know this because Flibber is never wrong.
I am occassionally wrong but in this instance, dear, it is you that is >>>wrong.
Just because a language doesn't yet have a schema it doesn't follow that >>>neos couldn't compile it if a schema was created for it.
Create one for C++ then. Imagine the plaudits, the groupies, the fame,
appearing on Good Morning, the difficult 2nd schema, the drug years, the
comeback. Etc etc.
You're good.
On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
On 19/03/2025 14:44, Mr Flibble wrote:
On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble
<flibble@reddwarf.jmc.corp>
wibbled:
On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
<flibble@reddwarf.jmc.corp>
wibbled:
On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY >>>>>>>> programming language.
I hope you're going to write a auto generator for that mess possibly >>>>>> based on written instructions in english/french/whatever. Its
unreadable.
eh? the neos grammar is based on EBNF so is human friendly.
Its almost a solid slab of text.
It is based on EBNF so is human friendly.
It's human friendly because Flibber says so. Flibber is never wrong, not
even when he's wrong.
And because magic, neos can (present tense) compile any programming
language, even though most languages have no schema at present. We know
this because Flibber is never wrong.
I am occassionally wrong but in this instance, dear, it is you that is
wrong.
Just because a language doesn't yet have a schema it doesn't follow that
neos couldn't compile it if a schema was created for it.
See?On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble
wrote:
Introducing the universal compiler, neos, that
can compile ANY programming language.
On 19/03/2025 15:16, Mr Flibble wrote:
On Wed, 19 Mar 2025 15:07:09 +0000, Richard Heathfield wrote:
On 19/03/2025 14:44, Mr Flibble wrote:
On Wed, 19 Mar 2025 14:41:34 +0000, Muttley wrote:
On Wed, 19 Mar 2025 14:35:59 GMT Mr Flibble
<flibble@reddwarf.jmc.corp>
wibbled:
On Wed, 19 Mar 2025 08:41:18 +0000, Muttley wrote:
On Wed, 19 Mar 2025 04:59:22 GMT Mr Flibble
<flibble@reddwarf.jmc.corp>
wibbled:
On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY >>>>>>>>> programming language.
I hope you're going to write a auto generator for that mess
possibly based on written instructions in english/french/whatever. >>>>>>> Its unreadable.
eh? the neos grammar is based on EBNF so is human friendly.
Its almost a solid slab of text.
It is based on EBNF so is human friendly.
It's human friendly because Flibber says so. Flibber is never wrong,
not even when he's wrong.
And because magic, neos can (present tense) compile any programming
language, even though most languages have no schema at present. We
know this because Flibber is never wrong.
I am occassionally wrong but in this instance, dear, it is you that is
wrong.
You won't be surprised to hear that I disagree.
Just because a language doesn't yet have a schema it doesn't follow
that neos couldn't compile it if a schema was created for it.
I have not made that claim. You, however, made the claim that neos can (present tense) compile ANY language. It's still in the quoted
materials:
See?On Mon, 17 Mar 2025 17:21:34 +0000, Mr Flibble wrote:
Introducing the universal compiler, neos, that can compile ANY >>>>>>>>> programming language.
But I note that you are now opting for the subjunctive, which is an altogether more sensible claim and perhaps offers a hint that you're
edging towards realising why your original claim was mistaken. Indeed,
you put me in mind of the Fonz in Happy Days, trying to admit he's wrong
but unable to use the word of himself.
"I was wr... I was wr... I was wrwrwrwrwr... I was, not, right."
The ability to admit error when you're wrong is an important one to
acquire on the path to adulthood. Keep going as you are, and you'll get there... one day.
On Wed, 19 Mar 2025 17:20:31 +0000, Richard Heathfield wrote:
The ability to admit error when you're wrong is an important one to
acquire on the path to adulthood. Keep going as you are, and you'll get
there... one day.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,029 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 182:15:14 |
| Calls: | 13,337 |
| Calls today: | 4 |
| Files: | 186,574 |
| D/L today: |
5,448 files (1,505M bytes) |
| Messages: | 3,356,610 |