Repository navigation
Language design #1
Description
moved from shitjs/meta/issues/2
Initial thoughts
informal description
- written in JavaScript
- no statements, only expressions
- no
var(variables are always declared in a global scope by default) - no
return– ShitScript returns the last evaluated expression - no floating point numbers (only integers)
- no unary operators (?)
- no classes, no
array's, noobject's (except forconsoleandwindow)
shitty ideas
- allow using
-,?,!in function names (no-camel-case) - super weird type coercions (or just some non-obvious implicit coercions result in string
'shit') ;->)))===->====,!==->!===(...)->[...]function->shit/fucktry->why-the-fuck-notcatch->fucked-upfinally->dont-fucking-care- say
pleaseto enable lexical scoping - you can't use a couple of numbers (e.g.
4and2) for no reason x / 0=Math.random()if->o-rly?then->ya-rlyelse->no-wayo-rly?-ya-rly-no-wayfor one-liners (without brackets).->->(works only forconsoleandwindow)
an example program:
fuck wat[] {
calculate!!![2, 0])))
}
shit calculate!!![y, x] please {
z = 5)))
why-the-fuck-not {
o-rly? z % 2 ==== 0 {
y / x)))
} no-way {
x / y)))
}
} fucked-up[e] {
console.lol[e])))
} dont-fucking-care {
0)))
}
}P.S.: Not sure about using words fuck and shit everywhere (may be considered offensive)
Activity
ghaiklor commentedon Dec 2, 2016
What ideas do you have comrades, for parser\tokens\etc ? Are we gonna to use some existing tools for writing our alphabet, lexical\semantic rules and so on ?
i.e. we can use Jison for parser.
vyorkin commentedon Dec 2, 2016
looks interesting, @ghaiklor, haven't seen it before, will definitely play with it tonight.
recently I had an experience with pegjs and I believe I know how to write LL(k) parser from scratch (I'm reading Language Implementation Patters by Terence Parr book), but yes, I think its better/easier to use existing tools (DSL + parser generator) for describing our shitty formal grammar and Jison looks promising from the first sight.
chicoxyzzy commentedon Dec 2, 2016
function -> shitI like this particularly because we can have some sort of a higher order shit
vyorkin commentedon Mar 6, 2017
ok, sorry for not doing anything for quite a while, I'll get back to it very soon, I hope!
ghaiklor commentedon Mar 9, 2017
@vyorkin played a little bit with LLVM... What if we will take LLVM as a compiler and write LLVM frontend for our ShitScript ?
vyorkin commentedon May 18, 2017
@ghaiklor good idea (I've just watched this talk https://www.youtube.com/watch?v=PauCAyVg348), I need to build smth very simple first (sorry still don't have enough time)
chicoxyzzy commentedon May 18, 2017
we definitely should target LLVM so we'll be able to use emascripten to target wasm
chicoxyzzy commentedon May 18, 2017
oops
ghaiklor commentedon May 18, 2017
@vyorkin here is my playground for llvm, but nothing special - https://github.com/ghaiklor/llvm-kaleidoscope
vyorkin commentedon Jun 23, 2017
how about using Rust + llvm-rs + lalrpop to build this? I'm going to start working on it these weekends, the time has come :)
my plan:
– build a very basic formal grammar
– generate a parser with lalrpop (we'll need to write a custom lexer & parser later for performance reasons), but it'll suffice for now
– write some tests to verify the resulting AST
– implement a visitor that will walk the AST and generate some LLVM IR
– provide a very basic REPL (to ease testing & playing with it) that will accept options like:
we could use docopt or clap crates for CLI args parsing
I'm still learning & playing with llvm-rs crate (the
Compilemodule is complex, a lot of macroses & metaprogramming stuff), but there aren't many alternatives, I've seen them all andllvm-rsseems to be the most mature, but its not under active developmentghaiklor commentedon Jun 24, 2017
@vyorkin I've started R&D in parsers written in JavaScript. Found
goodpossible solutions we can use.Lexical analysis - Jalex. You can describe rules via regular expressions and it will call a callback when match is found. So, we will be able to describe lexical rules via regular expressions and implement all needed actions for returning a stream of tokens.
Semantic analysis - Jison. It has its own simple built-in lexical analyzer, though, I'm thinking to use Jalex, since we will definitely write our own scanner in future.
Why I chose them? They are compatible with lex\yacc format. So you can describe definitions, translation rules in plain old-way as it was done in yacc.
For a grammar, we can try to found already implemented grammar for JavaScript and just modify it to fit our needs.
Though, still thinking about other lexical analyzers, but for semantic analysis I didn't found too much, so seems like Jison is our only options for semantic.
vyorkin commentedon Jun 24, 2017
@ghaiklor do you know any good LLVM bindings for nodejs? I've found only these 2:
both seem outdated :(
LLVM is hard, but I've already wasted so much time learning it, I think its too late to give up on it :)
ghaiklor commentedon Jun 24, 2017
@vyorkin I'm wondering why you stick to LLVM 😸
IMO, LLVM is over-engineering for our case. It's hard to support, it has a big learning curve. I understand, it will simplify code-generation phases for us, but not too much. Even, if you are going to implement it with LLVM, you still need to implement:
So steps are with LLVM will be close to defining a scanner with rules which returns tokens with inherited and synthetic attributes. Passing these tokens into a parser which has our grammar with semantic actions. During parsing of our tokens, parser will be able to call our semantic action where we are calling LLVM IR Builder. And, do not forgot about code-generation phase which we also need to implement with LLVM.
Anyway, we'll not get magical solution for ShitScript if we are stick to LLVM.
My initial idea is to examine existing generators for lexical and semantic parsers, so we can build our own grammars right from scratch and use generators to create parsers. Afterwards, I'm looking for a way to create our own code generator. Still thinking about it, but if we will have a grammar and a parse tree, that's not a big issue to generate code in SSA form. Aaaand, when we have SSA form, that's not a big issue to generate an Assembly code from it. To be honest, I even think about generating machine code from JavaScript, but that's just thoughts.
What you all think? @vyorkin @chicoxyzzy maybe and @bniwredyc
vyorkin commentedon Jun 24, 2017
Wow, thanks! I'll give a detailed answer today later, here is my latest unfinished playground in rust which I've started to work on after working through LLVM kaleidoscope tutorial series (same thing as you did, but I'm still not finished it yet:)). I've stopped here (LLVM IR Builder / Emitter visitor).
UPD:
I'm not sure about LLVM, but its very appealing: we get various backends (e.g. emscripten can be used to target WASM) and optimizations (traditional SSA-based, CFG-based, inteprocedural analysis & transformations) for free, JIT and a lot of other stuff. In addition, this is a very valuable experience that can be useful in the future to build something real. But the learning curve is high and I'm not sure if its worth the time wasted (and I've already spent too much).
ghaiklor commentedon Jun 25, 2017
@vyorkin
Agreed, though, you still need to implement the correct way of applying these optimizations.
We are creating a ShitScript here, do not forgot about it. And the question here is does it worth it to investigate so much time in LLVM for building a ShitScript ? 😸
May be, a language just with stupid code generation without optimization will be as a point why it's called ShitScript, you know...
ghaiklor commentedon Jun 25, 2017
@vyorkin also, I've just found LLVM compiled to JavaScript itself - https://github.com/kripken/llvm.js
Based on the demo, it looks like we will be able to compile LLVM bytecode via JavaScript.
I.e.
Worth note that it's just a playground and as author mentioned:
chicoxyzzy commentedon Jun 25, 2017
Sorry I'm too drunk for this kind of shit RN