Direct IR parsing

[Doomsk]

Objective

Testing a direct IR parsing approach (text -> IR -> execution), instead of AST parsing (text -> AST -> IR -> execution).

Points

Advantages

• It cuts through some double checks and double work from transforming text to AST and then from AST to IR
• Converts the text directly to the object that will be executed, making the interpreter faster
• Some code logics and structures can be checked during the parsing process, preventing further computation for faulty code

Disadvantages

• There are some complex checks and operations that need to be done during parsing
• Some checks can only be made after the whole code is parsed, making some double checks happening anyways (partially though)

Exploration

IR was initially built as a monolithic code. But caveats emerged from it, namely:

1. If different files have the same imports but using different labels, the code would break
2. If different files have different imports but with the same name (e.g. importing type plane from euclidian in file a.hat and importing type plane from non-euclidian in file b.hat, and both files being imported on main.hat), the code would break

A solution: independently parse and keep IR separated, making them related to the appropriate others, in the form of an IR graph:

Advantages

• Easier to parse
• Easier to maintain
• Easier to reason about relationships
• Code could be easily updatable in one IR
• Distributed computation-prepared

Disadvantages

• Updating code may become complex with the size of the source code and the internal relationship between files
• Not clear when to propagate a file update during evaluation/execution time
• Not clear how an error (on parsing or something else) should be shown or whether it will break the running code or just the new parsed one

[Doomsk]

Successful example code

each file included:

// file: src/main.hat

use (
  type:[
    geometry.{euclidian2.{line plane} differential2.normal}
    std.io.socket
  ]
  fn:math.{sin floor}
)

main {
  l:line =.{x=41}  // declare and assign
  p:plane
  p.{x=250 y=600}
  print(sin(0.0))
}

// file: src/math.hat

fn floor (x:f64) i64 {
  xi:i64 = x*i64
  ::if(and(ltz(x) ne(x xi*f64)):sub(xi 1) true:xi)
}

fn mod-2pi (theta:f64) f64 {
  two-pi:f64 = 6.283185307179586
  quot:i64 = floor(div(theta two-pi))
  ::sub(theta mul(two-pi quot*f64))
}

fn mod-pi (theta:f64) f64 {
  pi:f64 = 3.141592653589793
  two-pi:f64 = 6.283185307179586
  quot:i64 = floor(div(add(theta pi) two-pi))
  ::sub(theta mul(two-pi quot*f64))
}

fn abs (x:f64) f64 {
  bit63:u64 = 9223372036854775807 // sub(pow(2 63) 1), clear sign bit
  b:u64
  memcpy(b<ref> x<ref> sizeof(b))
  memcpy(x<ref> b-and(b bit63)<ref> sizeof(x))
  ::x
}

fn sin (theta:f64) f64 {
  pi:f64 = 3.141592653589793
  pi2:f64 = pow(pi 2.0)
  new-theta:f64 = mod-pi(theta)
  abs-theta:f64 = if(ltz(new-theta):neg(new-theta) true:new-theta)
  quad-approx:f64 = sub(div(4.0 pi) div(mul(4.0 abs(new-theta)) pi2))
  ::mul(new-theta quad-approx)
}

// file: src/hat_types/geometry/euclidian2.hat

type point:i64
type line {x:i32}
type surface:u64
type plane {x:i32 y:i32}

// file: src/hat_types/geometry/differential2.hat

type normal {dx:i32 dy:i32 dz:i32}

// file: src/hat_types/std/io.hat

type socket {raw:u32}

Final result as IR parsed code

[ir/start]
  types:
      line<struct>{x:i32}
      plane<struct>{x:i32 y:i32}
      normal<struct>{dx:i32 dy:i32 dz:i32}
      socket<struct>{raw:u32}

  fns:
      fn(name=floor, args=(f64)):
         FN-DEF#:NAME#[floor] ARGS#[ARG-VALUE#[x:f64]] TYPE#[i64]
            IRFlag.DECLARE_ASSIGN(xi, i64, IRFlag.CAST(x, i64))
            RETURN#[IRFlag.CALL_WITH_OPTION(if, OPTION#[IRFlag.CALL(sub, xi 1:int):IRFlag.CALL(and, IRFlag.CALL(ltz, x) IRFlag.CALL(ne, x IRFlag.CAST(xi, f64)))])]

      fn(name=mod-2pi, args=(f64)):
         FN-DEF#:NAME#[mod-2pi] ARGS#[ARG-VALUE#[theta:f64]] TYPE#[f64]
            IRFlag.DECLARE_ASSIGN(two-pi, f64, 6.283185307179586:float)
            IRFlag.DECLARE_ASSIGN(quot, i64, IRFlag.CALL(floor, IRFlag.CALL(div, theta two-pi)))
            RETURN#[IRFlag.CALL(sub, theta IRFlag.CALL(mul, two-pi IRFlag.CAST(quot, f64)))]

      fn(name=mod-pi, args=(f64)):
         FN-DEF#:NAME#[mod-pi] ARGS#[ARG-VALUE#[theta:f64]] TYPE#[f64]
            IRFlag.DECLARE_ASSIGN(pi, f64, 3.141592653589793:float)
            IRFlag.DECLARE_ASSIGN(two-pi, f64, 6.283185307179586:float)
            IRFlag.DECLARE_ASSIGN(quot, i64, IRFlag.CALL(floor, IRFlag.CALL(div, IRFlag.CALL(add, theta pi) two-pi)))
            RETURN#[IRFlag.CALL(sub, theta IRFlag.CALL(mul, two-pi IRFlag.CAST(quot, f64)))]

      fn(name=abs, args=(f64)):
         FN-DEF#:NAME#[abs] ARGS#[ARG-VALUE#[x:f64]] TYPE#[f64]
            IRFlag.DECLARE_ASSIGN(bit63, u64, 9223372036854775807:int)
            IRFlag.DECLARE(b, u64)
            IRFlag.CALL(memcpy, b<ref> x<ref> IRFlag.CALL(sizeof, b))
            IRFlag.CALL(memcpy, x<ref> IRFlag.CALL(b-and, b bit63)<ref> IRFlag.CALL(sizeof, x))
            RETURN#[x]

      fn(name=sin, args=(f64)):
         FN-DEF#:NAME#[sin] ARGS#[ARG-VALUE#[theta:f64]] TYPE#[f64]
            IRFlag.DECLARE_ASSIGN(pi, f64, 3.141592653589793:float)
            IRFlag.DECLARE_ASSIGN(pi2, f64, IRFlag.CALL(pow, pi 2.0:float))
            IRFlag.DECLARE_ASSIGN(new-theta, f64, IRFlag.CALL(mod-pi, theta))
            IRFlag.DECLARE_ASSIGN(abs-theta, f64, IRFlag.CALL_WITH_OPTION(if, OPTION#[IRFlag.CALL(neg, new-theta):IRFlag.CALL(ltz, new-theta)]))
            IRFlag.DECLARE_ASSIGN(quad-approx, f64, IRFlag.CALL(sub, IRFlag.CALL(div, 4.0:float pi) IRFlag.CALL(div, IRFlag.CALL(mul, 4.0:float IRFlag.CALL(abs, new-theta)) pi2)))
            RETURN#[IRFlag.CALL(mul, new-theta quad-approx)]

  main:
       IRFlag.DECLARE_ASSIGN(l, line, ARG-VALUE#[x:41:int])
       IRFlag.DECLARE(p, plane)
       IRFlag.ASSIGN(p, ARG-VALUE#[x:250:int] ARG-VALUE#[y:600:int])
       IRFlag.CALL(print, IRFlag.CALL(sin, 0.0:float))

[ir/end]

A few things to improve, but so far it looks much better!

[Doomsk]

Rough structure for memory and IR so far

There are a few substantial changes that improve code structure, access and logic, but I will comment later, when the IR is tested.