mirror of
https://github.com/nim-lang/Nim.git
synced 2025-12-28 17:04:41 +00:00
816589b667
Theoretical Benefits / Plans: - Typed assembler-like language. - Allows for a CPS transformation. - Can replace the existing C backend by a new C backend. - Can replace the VM. - Can do more effective "not nil" checking and static array bounds checking. - Can be used instead of the DFA. - Easily translatable to LLVM. - Reasonably easy to produce native code from. - Tiny memory consumption. No pointers, no cry. **In very early stages of development.** Todo: - [x] Map Nim types to IR types. - [ ] Map Nim AST to IR instructions: - [x] Map bitsets to bitops. - [ ] Implement string cases. - [ ] Implement range and index checks. - [x] Implement `default(T)` builtin. - [x] Implement multi string concat. - [ ] Write some analysis passes. - [ ] Write a backend. - [x] Integrate into the compilation pipeline.
56 lines
1.4 KiB
Nim
56 lines
1.4 KiB
Nim
{.push stack_trace: off.}
|
|
|
|
const useLibC = not defined(nimNoLibc)
|
|
|
|
when useLibC:
|
|
import ansi_c
|
|
|
|
proc nimCopyMem*(dest, source: pointer, size: Natural) {.nonReloadable, compilerproc, inline.} =
|
|
when useLibC:
|
|
c_memcpy(dest, source, cast[csize_t](size))
|
|
else:
|
|
let d = cast[ptr UncheckedArray[byte]](dest)
|
|
let s = cast[ptr UncheckedArray[byte]](source)
|
|
var i = 0
|
|
while i < size:
|
|
d[i] = s[i]
|
|
inc i
|
|
|
|
proc nimSetMem*(a: pointer, v: cint, size: Natural) {.nonReloadable, inline.} =
|
|
when useLibC:
|
|
c_memset(a, v, cast[csize_t](size))
|
|
else:
|
|
let a = cast[ptr UncheckedArray[byte]](a)
|
|
var i = 0
|
|
let v = cast[byte](v)
|
|
while i < size:
|
|
a[i] = v
|
|
inc i
|
|
|
|
proc nimZeroMem*(p: pointer, size: Natural) {.compilerproc, nonReloadable, inline.} =
|
|
nimSetMem(p, 0, size)
|
|
|
|
proc nimCmpMem*(a, b: pointer, size: Natural): cint {.compilerproc, nonReloadable, inline.} =
|
|
when useLibC:
|
|
c_memcmp(a, b, cast[csize_t](size))
|
|
else:
|
|
let a = cast[ptr UncheckedArray[byte]](a)
|
|
let b = cast[ptr UncheckedArray[byte]](b)
|
|
var i = 0
|
|
while i < size:
|
|
let d = a[i].cint - b[i].cint
|
|
if d != 0: return d
|
|
inc i
|
|
|
|
proc nimCStrLen*(a: cstring): int {.compilerproc, nonReloadable, inline.} =
|
|
if a.isNil: return 0
|
|
when useLibC:
|
|
cast[int](c_strlen(a))
|
|
else:
|
|
var a = cast[ptr byte](a)
|
|
while a[] != 0:
|
|
a = cast[ptr byte](cast[uint](a) + 1)
|
|
inc result
|
|
|
|
{.pop.}
|