carlcui / expressive Goto Github PK

"abc"

Currently only a small set of escape characters are allowed and have been parsed manually. It would be helpful to automate this part, as well as transferring them to golang escape characters. (e.g. In parsing, text would be \\n, but the value should be \n.

In the program, I should be able to do something like

let foo: float = 5;

instead of explicitly specifying

let foo: float = 5.0;

Need to add type conversion before this

In v0.0.1, assignmentNode has only identifier node on the lhs, but should be generalized to expressions that are addressable.

'a'

• fixed size array on stack
• dynamically allocated array
• indexing
• length
• slicing operations

setup LLVM IR codegen from ast.

1. Instruction (string. since LLVM IR instruction is not strictly opcode + operand)
2. Instruction fragments (a fragment of instructions)
3. macros (predefined sets of instructions)

Input handler:

1. Modify NextChar to NextRune
2. Add NextByte (Still does NextRune, but give error when the rune size is larger than 1)

byte:

1. size 1 (1 byte)
2. value as byte
3. scanByte should scan one byte instead of one whole utf-8 character.

char:

1. variable size
2. value as string
3. scanChar scan one utf-8 character

++, --

Basic type checking.

function as variable

Be able to scan comments

continue in loops

Currently, it costs too much effort writing tests for the parser in these ways:

1. Setting up mock scanner using token array is tedious
2. Can only call parser.Parse() (cannot call individual parsing functions)
3. Testing the results is complicated: need to manually call type assertion and lots of if nesting

Need better way of writing parser tests.

all except for in, since array implementation is not done yet.

compile input file to machine executable

1. llvm-as: generate llvm bitcode
2. llvm-link: link bitcode
3. llc: produce object file
4. gcc: create executable

Con:
Consider the following code:

...
frag1 := visitor.removeValueFragment(node.expr)

frag.Append(frag1)

...

Suppose frag1 is InstructionsFragment, and frag is BlocksFragment. If frag already has Term set, then by appending frag1 to frag, essentially the order of execution is altered, unless we create a Block for frag1 and then append the block to frag.

Pro:
Not sure. Currently every fragment is at least a BlocksFragment, even it only contains one block with one instruction. However, llvm will essentially strip out those blocks during optimization phase.

+=, -=, *=, /=, %=, ^^=

Should be able to generate ast for basic operations:

1. variable declaration/assignment
2. logic operation
3. arithmetic
4. print (can be a built-in printf for debugging purpose)

Be able to define custom types

Otherwise we won't be able to test the compiler as a whole in circleCI

Before:

[]*token.Token{
    &token.Token{TokenType: token.IF},
    &token.Token{TokenType: token.LEFT_PAREN}
}

// And

cur.Locator := locator.IndexLocation{scanner.pos}

Now:

[]*token.Token{
    {TokenType: token.IF}, // redundant type
    {TokenType: token.LEFT_PAREN}
}

cur.Locator := locator.IndexLocation{Index: scanner.pos} // disallow unnamed fields

• concat
• shallow comparison (#47)
• deep comparison (#47)
• indexing
• length

print "1+2 is %d\n", 3;