dplassgit/d2lang

D2 is a strongly-typed, statically-typed, (mostly) inferred-type compiled language.

d2lang

D2 (d2lang) is a strongly-typed, statically-typed, inferred-type compiled language. Its syntax draws from C, Java and Python.

The D2 compiler currently compiles to X64 assembly language only. It uses nasm and gcc to assemble and link, respectively, to Windows executables.

There are hooks to support other architectures; the intermediate language is (mostly) target-agnostic and a 8085 backend is partially implemented.

See the overview for a more comprehensive description of the types, control structures, operators and statements in D2.

NOTE: D2 is not related in ANY way to "The D Programming Language" except by coincidence of name.

A PLASS Program

Contributing

See the contributor's guide.

Installing

The following 4 are required:

1. bazel

2. nasm

3. gcc

4. Java 11 or higher

5. Optional: Eclipse and git bash shell (mingw64)

Running Tests

Run bazel test ... from the root directory.

Running the compiler

See docs/running.md.

Caveats

Only compiles to Intel x64. Only links against the Windows version of the gcc C Runtime Library. Can only use nasm and gcc.

There are various bugs.

Language sample

Canonical hello world:

println "Hello world"

Tower of Hanoi

// Ported from toy (http://www.graysage.com/cg/Compilers/Toy/hanoi.toy)

PEGS = ["", "left", "center", "right"]

printPeg: proc(peg: int) {
  print PEGS[peg]
}

hanoi: proc(n: int, fromPeg: int, usingPeg: int, toPeg: int) {
  if n != 0 {
    hanoi(n - 1, fromPeg, toPeg, usingPeg)
    print "Move disk from "
    printPeg(fromPeg)
    print " peg to "
    printPeg(toPeg)
    println " peg"
    hanoi(n - 1, usingPeg, fromPeg, toPeg)
  }
}

n = 5 // defines global
hanoi(n, 1, 2, 3)

See more samples

Why did I build D2?

See docs/history

d2lang's Issues

Replace `returns` keyword with colon

It's the same pattern as elsewhere:

a:int
b:proc() {}
c:proc():int {return 3}

Strength reduction

If op is multiply and one operand is a power of 2, replace by operand+operand or operand<<1 (DONE)

Visitor method names are wrong

1. the visitor interface method names should be visit(node)
2. the node visit method should be called accept(visitor)

Infer types of formal parameters

Support multi-dimensional arrays

First iteration will be 1D arrays.

Support input

Via a SysCall?

Single line? Single character?

Support string type

And concatenation (done), formatting, length (done), substring

Generate 386 asm (or JVM bytecode)

Arrays

Literal constants (done), length (done), indexing (done)!

Static Checker erroneously allows array+array

d2lang/src/com/plasstech/lang/d2/type/StaticChecker.java

Line 249 in ae71e04

} else if (left.varType().isArray() && node.operator() == Token.Type.LBRACKET) {

not checking other operators

Infer return type of procedures

Add "println", same as "print" but with a newline.

Keywords are type-insensitive, but variables are type-sensitive.

Is this a bug or a feature?

Implement declarations

e.g., a:int which will add an entry in the symbol table.

Implement functions

Try to reduce the casting in the parser

e.g., Node.asIntNode returns the casted value.
or something like that.

Unify type enums?

INT, BOOL, STRING are in 3 places now.

Implement `input` keyword

E.g.,

f=input

input returns a string after the user hits enter.

Allow underscore as a variable character!

Interpreter (and possibly codegen) cannot set value of a global from within a proc

The IL doesn't have an annotation to indicate the scope where the type checker found the variable declaration, so the interpreter doesn't try to modify the variable in a parent environment.

Add an `error` or `exit` keyword/command

For rudimentary exceptions

Write a shell script to run a driver with the right classpath

If you java -cp . com.plsastech.lang.d2.ParserDriver filename it crashes because it doesn't have guava in the default classpath

Allow commas in print, println

E.g.,

println "The answer is:", answer

Delete `AtomNode`

It's never used.

Relax parsing `while` to allow any statement in the `do`

Instead of just an assignment

Extract loop invariants

1. Detect loops lol
2. Detect that an assignment is not related to anything else that changes inside the loop lol
3. Move the assignment before the loop
4. ???
5. Profit!

Implement "while" loops

while <condition> [do <update>] {block]

Support character type

Unroll short loops

1. Detect loop
2. Figure out what the loop bound (condition) is
3. copy/paste, including the increment. use 'remap' to remap temps
4. ???
5. profit!

Figure out how to implement `return void`

Because we don't have semicolons, the next token after a return keyword is started to be interpreted as an expression.

The saving grace is that we can detect this in the static checker

Dead code detection

E.g.,
Any sibling statement after a "return" done
Any sibling statement after a "continue" or "break" (these are just "ifs", see below)
(Re?)Assignment of variable without use

Implement `main` function

Static check for redundant elif blocks

Support forward-calls of procedures

Implement if/elif/else

Rename directories

src->java
test->javatests

Because you know.

Add the rest of the operators

As subject: %, comparisons, and/or, unary operators

Support comments

Probably #-to-end-of-line

Make sure int constants don't get too big

Maybe change to longs (but still called "int"?) But stlil need to check.

Get rid of Node.Type

It's not really needed

Inline small procedures

1. decide - say, if less than 10 OPs, and no branches
2. inline - create temps for each actual/formal and re-map each actual to the new temp
3. delete original
4. ???
5. Profit!

"Use before assigned" test is too strict

If there's a global, when a method references that global it should assume it's been initialized.

Add debugging/verbosity flags

Delete println now that we have \n

Refactor true & false to be BoolToken instead of KeywordToken

Will require changes to Lexer & Parser at least

Return statement is re-using the temp

See attached; line 302 is reusing __temp2. But the optimizer assumes temps are never changed, so it propagated its initial value thorughout the code.

tostring.log

Move token to common, token.type to its own class?

Separate Token.Type from "Operator type"

Fix error propagation in type checker

It's half-hearted right now; should use the token's location in the node.

Unify BoolNode, IntNode, StringNode?

into ConstNode