davidwatkins/dice

Java, but worse

dice's Issues

Write the Math class

Look at the java definition for Math and write the math class functions in our language
http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html

Move escape function into separate file

Duplicate function in parser and scanner

Update LRM: support addition of chars and ints

update LRM interspersed instance field and method declarations

We should evaluate whether we want to move variable declarations to stmts

Instead of being a vdecl

Exceptions, try, catch?

Just another food for thought

Add shakespeare and stephen number to tester

Remove '-' symbol from regex in floats and ints of LRM

Convert AST.expr to SAST.expr in Analyzer.convert_expr

evaluate what this binds to

update LRM these all result in runtime errors

index out of bounds, division by zero, operations on null

Special chars (tabs/newlines/etc) aren't getting tokenized properly

For the following line:
g = '\t';
the tab character should be tokenized as CHAR_LITERAL(\t); however, it's currently getting printed by the dice exec (with -tendl flag) as CHAR_LITERAL().

Evaluate whether to add new as a keyword to object initialization

Add file operator functions to Codegen

support addition of chars and ints

int a = 27;
char b = 93;
result of binop with mixed operand types has type corresponding to the leftmost operand in the expression
char c = b + a;
int a = a + b;

overflow for char addition
char c = b + a + 150;
c; (* 15 *)

Change parser array create type to type tag and not primitive

Should we switch the llvm package to ollvm?

Look at this https://github.com/OCamlPro/ollvm

Create symbol table for cdecls, fdecls, fields

Parse the ast and retrieve the names of all fields, functions, and classes so they can be used when ensuring the ast is correct. This way the names of the types can be ensured to be defined somewhere.

This should throw exception "UndefinedClass: Baz"

class Foo {}

class Bar {}

class test {
public void main(char[][] args) {
class Baz b;
}
}

Create OCamlDoc Documentation

Not sure how much work this requires, but is worthy of evaluating
http://caml.inria.fr/pub/docs/manual-ocaml/ocamldoc.html

Write the String class

http://docs.oracle.com/javase/7/docs/api/java/lang/String.html

Add class name and function name collission detection

Make sure that all defined classes have unique names as well as their functions with specific number of parameters.

Add testing for arrays

Write the File class

http://docs.oracle.com/javase/7/docs/api/java/io/File.html
http://docs.oracle.com/javase/7/docs/api/java/io/FileReader.html

Add support for utilizing line number and character number in Analyzer

Errors should be indicative of where they occurred in the source file. Add support to either the AST, Analyzer, or both in order to support this kind of operation

Consecutive print statements don't work. Compiler only outputs first print statement.

Convert AST.cdecl to SAST.cdecl

Correctly differentiate the access of functions into structs and functions for LLVM conversion to work correctly; pass class type as first param to all functions

Update LRM: interspersed vdecls in a function

Add annotation for source code position to AST

Every single node should also contain its location and line number

Analyzer.process_includes does not check absolute path

The string.map only adds the path provided by the programmer. Needs to be smarter about the actual path it is storing in its map

Implement basic primitive expressions for codegen

Needs to be done by 11/23

Complete pretty printing abstract syntax tree to Utils

update LRM single line decl and assignment

Recursive dependenices in constructors. Make sure we mention it is undefined.

Decide whether to promote all ints to floats in binops

Evaluate the type of an expression in Analyzer.get_expr_type

Write a function that gets the type of any expression. This will likely involve writing an environment map in the Analyzer module that contains all of the types of classes as well as function return types.

Main can be defined anywhere

Do we need to add an additional layer of abstraction from SAST to Codegen?

Perhaps our overloading of SAST and codegen data structure is too broad? We might have to do an additional transformation

Reorganize object accesses for functions

When a user calls a function like:
String a;
a.toString();

The reference to toString needs to be updated in the SAST to:
toString(a);

Should we add continuous checking even when an illegal character/parser error occurs like java?

Probably not but a cool thought exercise

object decl without assignment expr: This should throw no exceptions

class Foo {}

class Baz {}

class test {
public void main(char[][] args) {
class Baz b;
}
}

incorrect check for duplicate constructors

this is an incorrect check for duplicate constructors:

Dice/Compiler/analyzer.ml

Line 83 in 16491e2

let constructorfun = (fun m fdecl -> if (StringMap.mem (get_name fdecl) m) then raise(Exceptions.DuplicateConstructor) else (StringMap.add (get_name fdecl) fdecl m)) in

This code raises a DuplicateConstructor exception:
class Foo {
2 constructor(int a, bool b, char c, float f) {}
3 constructor(int a, bool b, char c) {}
4 }

Cause: this line doesn't concatenate string representations of all the formals in a given constructor:

Dice/Compiler/analyzer.ml

Line 67 in 16491e2

let params = List.fold_left (fun s -> (function Formal(t, s) -> s ^ "," ^ Utils.string_of_datatype t | _ -> "" )) "" fdecl.formals in

For example, for both constructors in class Foo above, it returns "a,int"

It also fails to raise the exception in this case, even though it should:
class Foo {
2 constructor(int a, bool b, char c, float f) {}
3 constructor(bool b, char c, float f, int a) {}
4 }

To resolve this particular case, we should define an order in which to hash the formals (i.e. all bool formals in alphabetical order by name, then all char formals in alphabetical order by name, then ...)

Do we want to define two constructors as being equal if all formals match on both type AND name, or just on type? In other words, should these two constructors be considered equal?
constructor(int a, bool x)
constructor(int a, bool y)

Add testing for extends

Parser issue with reading user-defined objects.

File "Compiler_Test_Suite/test-classExtends.dice", line 12, character 7, Syntax Error, token ID(a)

  public float xCoord;
  public float yCoord;
}

class circle extends shape {
  public float radius;
}

class test {
  public void main(char[][] args) {
      circle a = new circle(); 
      a.xCoord = 1.5;
      print(a.xCoord);
  }
}```

I also tried declaring and instantiating on different lines, still didn't work.

static analysis checks for variable access

• check if variables are accessed out of scope
• if variable is accessed, check if its access modifier (private/public) allows that access

Add mentioning of unary minus to LRM

float limit

Currently, code such as:
b = 0.0000000000000000000000000000000000000000000001;
is passed by the Scanner as FLOAT_LITERAL(1e-46) which is past our LRM's float limit of 1e-37. Floats as small as 1e-311 and as large as 1e+308 passed through successfully without overflow.

Strings with escape characters are not being displayed properly

Need to add escaped function to Parser to escape all string literals. Could alternatively add it to scanner

How does LLVM handle allocating on the heap

Create arith tests that have signed values

use `new` keyword for object and array instantiation

Foo a = new Foo();
int[][] a = new a[2][3];