mirror of
https://github.com/exaloop/codon.git
synced 2025-06-03 15:03:52 +08:00
* Initial refactor commit * Support external vars * Simplify refactor; Python scoping [wip] * Python scoping [wip] * Python scoping [fix loops; wip] * Fix lambdas * Python scoping [test fixes; wip] * Fix scoping [wip] * Fix basic tests [no-ci] * Fix tests * CallExpr refactoring [wip] * CallExpr refactoring [wip] * Remove activeUnbounds tracking * Add core.codon * Move Function and other core types to core.codon; Revamp Function and Callable types * Refactor IntExpr, FloatExpr and CallExpr * Refactor ClassStmt * Refactor context, IdExpr and DotExpr * Refactor DotExpr and AssignStmt * Refactor ImportStmt * Refactor FunctionStmt * Refactor * Remove UpdateStmt * Refactor AssignReplacementVisitor * Make SimplifyVisitor in-place * Fix new scoping * Fix import type alias handling * Add docstrings; Complete Simplify refactoring * Fixes for seqtest * Refactor typecheck [wip] * Refactor typecheck [wip] * Refactor typecheck/access; Remove void anduse NoneType; Fix #18 * Refactor typecheck/assign * clang-format and cmake-format * Fix none types in IR * Multi-error support in simplify * Fix IR tests for new void * Simplify ClassStmt * Refactor cond.cpp * Refactor error.cpp * Refactor function.cpp and simplify unbounds * Refactor op.cpp * Refactor call.cpp [wip] [no-ci] * seqassertn updates [noci] * Refactor call.cpp * Refactor call.cpp * Refactor call.cpp * Refactor typecheck * clang-tidy updates [noci] * Refactor infer.cpp [wip] * Refactor infer.cpp * Refactor wrapExpr * Remove visitedAsts * Remove old base logic * Refactor typecheck ctx * Fix JIT bug * Fix JIT tests * Scoping fixes [wip] [noci] * Fix ImperativeForFlow var store * Add newlines [noci] * Dump IR module with log flag * Fix scoping bugs; Add &, ^ and | static operations; Address stylistic review issues * Fix side effect analysis for for-loops * Add support for class variables and ClassVar * Refactor special dot-member cases * Add codon app tests * Fix class variables; clang-tidy * Fix __argv__ * Add datetime constants and update tests * Fix #25; Add Py_None, Py_True and Py_False; External var support [wip] * External var support [wip] * Dump LLVM IR when debug flags are active * clang-format * Fix arg var construction * Extern var fixes * Undo extern var changes related to stdout etc. * Fix tuple magics * Fix extern vars and tuple magics * Fix duplicate var name error * Fix extern vars * Fix #16 * Fix side-effect analysis for try-catch * Move test C var to test executable * Add staticmethod * Fix var status for try-catch * Fix tests * Fix shell var name * Fix test * Fix app test * Fix scoping issue (remove dominated identifier from stack) * Fix no-pie issue * Use PIC when building library object * Don't use -no-pie when building library [noci] * Use -relocation-model=pic in test * Fix lib build on Linux * Fix lib build * Update exceptions to use subclasses vs. header * Fix __repr__ * Fix tests * Fix exceptions test * Don't build docs Co-authored-by: A. R. Shajii <ars@ars.me>
339 lines
9.2 KiB
Python
339 lines
9.2 KiB
Python
# (c) 2022 Exaloop Inc. All rights reserved.
|
|
|
|
from internal.gc import free
|
|
|
|
|
|
@pure
|
|
@C
|
|
def seq_check_errno() -> str:
|
|
pass
|
|
|
|
|
|
from C import seq_print(str)
|
|
from C import exit(int)
|
|
|
|
|
|
@extend
|
|
class __internal__:
|
|
@pure
|
|
@derives
|
|
@llvm
|
|
def class_raw(obj) -> Ptr[byte]:
|
|
ret i8* %obj
|
|
|
|
@pure
|
|
@derives
|
|
@llvm
|
|
def _tuple_getitem_llvm(t: T, idx: int, T: type, E: type) -> E:
|
|
%x = alloca {=T}
|
|
store {=T} %t, {=T}* %x
|
|
%p0 = bitcast {=T}* %x to {=E}*
|
|
%p1 = getelementptr {=E}, {=E}* %p0, i64 %idx
|
|
%v = load {=E}, {=E}* %p1
|
|
ret {=E} %v
|
|
|
|
def tuple_fix_index(idx: int, len: int) -> int:
|
|
if idx < 0:
|
|
idx += len
|
|
if idx < 0 or idx >= len:
|
|
raise IndexError(f"tuple index {idx} out of range 0..{len}")
|
|
return idx
|
|
|
|
def tuple_getitem(t: T, idx: int, T: type, E: type) -> E:
|
|
return __internal__._tuple_getitem_llvm(
|
|
t, __internal__.tuple_fix_index(idx, staticlen(t)), T, E
|
|
)
|
|
|
|
@pure
|
|
@derives
|
|
@llvm
|
|
def fn_new(ptr: Ptr[byte], T: type) -> T:
|
|
%0 = bitcast i8* %ptr to {=T}
|
|
ret {=T} %0
|
|
|
|
@pure
|
|
@derives
|
|
@llvm
|
|
def fn_raw(fn: T, T: type) -> Ptr[byte]:
|
|
%0 = bitcast {=T} %fn to i8*
|
|
ret i8* %0
|
|
|
|
@pure
|
|
@llvm
|
|
def int_sext(what, F: Static[int], T: Static[int]) -> Int[T]:
|
|
%0 = sext i{=F} %what to i{=T}
|
|
ret i{=T} %0
|
|
|
|
@pure
|
|
@llvm
|
|
def int_zext(what, F: Static[int], T: Static[int]) -> Int[T]:
|
|
%0 = zext i{=F} %what to i{=T}
|
|
ret i{=T} %0
|
|
|
|
@pure
|
|
@llvm
|
|
def int_trunc(what, F: Static[int], T: Static[int]) -> Int[T]:
|
|
%0 = trunc i{=F} %what to i{=T}
|
|
ret i{=T} %0
|
|
|
|
def seq_assert(file: str, line: int, msg: str) -> AssertionError:
|
|
s = f": {msg}" if msg else ""
|
|
s = f"Assert failed{s} ({file}:{line.__repr__()})"
|
|
return AssertionError(s)
|
|
|
|
def seq_assert_test(file: str, line: int, msg: str):
|
|
s = f": {msg}" if msg else ""
|
|
s = f"\033[1;31mTEST FAILED:\033[0m {file} (line {line}){s}\n"
|
|
seq_print(s)
|
|
|
|
def check_errno(prefix: str):
|
|
msg = seq_check_errno()
|
|
if msg:
|
|
raise OSError(prefix + msg)
|
|
|
|
@pure
|
|
@llvm
|
|
def opt_tuple_new(T: type) -> Optional[T]:
|
|
ret { i1, {=T} } { i1 false, {=T} undef }
|
|
|
|
@pure
|
|
@llvm
|
|
def opt_ref_new(T: type) -> Optional[T]:
|
|
ret i8* null
|
|
|
|
@pure
|
|
@derives
|
|
@llvm
|
|
def opt_tuple_new_arg(what: T, T: type) -> Optional[T]:
|
|
%0 = insertvalue { i1, {=T} } { i1 true, {=T} undef }, {=T} %what, 1
|
|
ret { i1, {=T} } %0
|
|
|
|
@pure
|
|
@derives
|
|
@llvm
|
|
def opt_ref_new_arg(what: T, T: type) -> Optional[T]:
|
|
ret i8* %what
|
|
|
|
@pure
|
|
@llvm
|
|
def opt_tuple_bool(what: Optional[T], T: type) -> bool:
|
|
%0 = extractvalue { i1, {=T} } %what, 0
|
|
%1 = zext i1 %0 to i8
|
|
ret i8 %1
|
|
|
|
@pure
|
|
@llvm
|
|
def opt_ref_bool(what: Optional[T], T: type) -> bool:
|
|
%0 = icmp ne i8* %what, null
|
|
%1 = zext i1 %0 to i8
|
|
ret i8 %1
|
|
|
|
@pure
|
|
@derives
|
|
@llvm
|
|
def opt_tuple_invert(what: Optional[T], T: type) -> T:
|
|
%0 = extractvalue { i1, {=T} } %what, 1
|
|
ret {=T} %0
|
|
|
|
@pure
|
|
@derives
|
|
@llvm
|
|
def opt_ref_invert(what: Optional[T], T: type) -> T:
|
|
ret i8* %what
|
|
|
|
@pure
|
|
@derives
|
|
@llvm
|
|
def to_class_ptr(ptr: Ptr[byte], T: type) -> T:
|
|
%0 = bitcast i8* %ptr to {=T}
|
|
ret {=T} %0
|
|
|
|
def _tuple_offsetof(x, field: Static[int]) -> int:
|
|
@pure
|
|
@llvm
|
|
def _llvm_offsetof(T: type, idx: Static[int], TE: type) -> int:
|
|
%a = alloca {=T}
|
|
%b = getelementptr inbounds {=T}, {=T}* %a, i64 0, i32 {=idx}
|
|
%base = ptrtoint {=T}* %a to i64
|
|
%elem = ptrtoint {=TE}* %b to i64
|
|
%offset = sub i64 %elem, %base
|
|
ret i64 %offset
|
|
|
|
return _llvm_offsetof(type(x), field, type(x[field]))
|
|
|
|
def raw_type_str(p: Ptr[byte], name: str) -> str:
|
|
pstr = p.__repr__()
|
|
# '<[name] at [pstr]>'
|
|
total = 1 + name.len + 4 + pstr.len + 1
|
|
buf = Ptr[byte](total)
|
|
where = 0
|
|
buf[where] = byte(60) # '<'
|
|
where += 1
|
|
str.memcpy(buf + where, name.ptr, name.len)
|
|
where += name.len
|
|
buf[where] = byte(32) # ' '
|
|
where += 1
|
|
buf[where] = byte(97) # 'a'
|
|
where += 1
|
|
buf[where] = byte(116) # 't'
|
|
where += 1
|
|
buf[where] = byte(32) # ' '
|
|
where += 1
|
|
str.memcpy(buf + where, pstr.ptr, pstr.len)
|
|
where += pstr.len
|
|
buf[where] = byte(62) # '>'
|
|
free(pstr.ptr)
|
|
return str(buf, total)
|
|
|
|
def tuple_str(strs: Ptr[str], names: Ptr[str], n: int) -> str:
|
|
total = 2 # one for each of '(' and ')'
|
|
i = 0
|
|
while i < n:
|
|
total += strs[i].len
|
|
if names[i].len:
|
|
total += names[i].len + 2 # extra : and space
|
|
if i < n - 1:
|
|
total += 2 # ", "
|
|
i += 1
|
|
buf = Ptr[byte](total)
|
|
where = 0
|
|
buf[where] = byte(40) # '('
|
|
where += 1
|
|
i = 0
|
|
while i < n:
|
|
s = names[i]
|
|
l = s.len
|
|
if l:
|
|
str.memcpy(buf + where, s.ptr, l)
|
|
where += l
|
|
buf[where] = byte(58) # ':'
|
|
where += 1
|
|
buf[where] = byte(32) # ' '
|
|
where += 1
|
|
s = strs[i]
|
|
l = s.len
|
|
str.memcpy(buf + where, s.ptr, l)
|
|
where += l
|
|
if i < n - 1:
|
|
buf[where] = byte(44) # ','
|
|
where += 1
|
|
buf[where] = byte(32) # ' '
|
|
where += 1
|
|
i += 1
|
|
buf[where] = byte(41) # ')'
|
|
return str(buf, total)
|
|
|
|
def undef(v, s):
|
|
if not v:
|
|
raise NameError(f"variable '{s}' not yet defined")
|
|
|
|
def set_header(e, func, file, line, col):
|
|
if not isinstance(e, BaseException):
|
|
compile_error("exceptions must derive from BaseException")
|
|
|
|
e.func = func
|
|
e.file = file
|
|
e.line = line
|
|
e.col = col
|
|
return e
|
|
|
|
# TODO: keep this commented until static for lands
|
|
# @pure
|
|
# @llvm
|
|
# def __raw__(self) -> Ptr[byte]:
|
|
# ret i8* %self
|
|
# def __iter__(self):
|
|
# for _, i in self.__static_list__:
|
|
# yield i
|
|
# def __contains__(self, what):
|
|
# for _, i in self.__static_list__:
|
|
# if isinstance(what, type(i)):
|
|
# if what == i:
|
|
# return True
|
|
# return False
|
|
# def __eq__(self, obj) -> bool:
|
|
# for ii, i in self.__static_list__:
|
|
# if not i == obj.__static_list__[ii]:
|
|
# return False
|
|
# return True
|
|
# def __ne__(self, obj) -> bool:
|
|
# return not self == obj
|
|
# def __lt__(self, obj) -> bool:
|
|
# for ii, i in self.__static_list__:
|
|
# if i < obj.__static_list__[ii]:
|
|
# return True
|
|
# elif not i == obj.__static_list__[ii]:
|
|
# return False
|
|
# return False
|
|
# def __le__(self, obj) -> bool:
|
|
# return self < obj or self == obj
|
|
# def __ge__(self, obj) -> bool:
|
|
# return not self < obj
|
|
# def __gt__(self, obj) -> bool:
|
|
# return not self < obj and not self == obj
|
|
# def __hash__(self) -> int:
|
|
# seed = 0
|
|
# for _, i in self.__static_list__:
|
|
# seed = seed ^ ((i.__hash__() + 2654435769) + ((seed << 6) + (seed >> 2)))
|
|
# return seed
|
|
# def __pickle__(self, dest: Ptr[byte]) -> None:
|
|
# for _, i in self.__static_list__:
|
|
# i.__pickle__(dest)
|
|
# # __unpickle
|
|
# def __len__(self):
|
|
# return staticlen(self)
|
|
# def __to_py__(self) -> cobj:
|
|
# o = pyobj._tuple_new(staticlen(self))
|
|
# for ii, i in self.__static_list__:
|
|
# pyobj._tuple_set(o, ii + 1, i.__to_py__())
|
|
# return o
|
|
# # __from_py__
|
|
# def __repr__(self) -> str:
|
|
# a = __array__[str](staticlen(self))
|
|
# n = __array__[str](staticlen(self))
|
|
# for ii, i in self.__static_list__:
|
|
# a.__setitem__(ii, i.__repr__())
|
|
# n.__setitem__(ii, i.__static_name__)
|
|
# return __internal__.tuple_str(a.ptr, n.ptr, staticlen(self))
|
|
# def __dict__(self) -> str:
|
|
# d = List[str](staticlen(self))
|
|
# for _, i in self.__static_list__:
|
|
# d.append(i.__static_name)
|
|
# return d
|
|
# def __add__(self, obj):
|
|
# return (*self, *obj)
|
|
|
|
|
|
@dataclass(init=True)
|
|
@tuple
|
|
class Import:
|
|
name: str
|
|
file: str
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<module '{self.name}' from '{self.file}'>"
|
|
|
|
@extend
|
|
class Function:
|
|
@pure
|
|
@llvm
|
|
def __new__(what: Ptr[byte]) -> Function[T, TR]:
|
|
%0 = bitcast i8* %what to {=Function[T, TR]}
|
|
ret {=Function[T, TR]} %0
|
|
|
|
def __new__(what: Function[T, TR]) -> Function[T, TR]:
|
|
return what
|
|
|
|
@pure
|
|
@llvm
|
|
def __raw__(self) -> Ptr[byte]:
|
|
%0 = bitcast {=Function[T, TR]} %self to i8*
|
|
ret i8* %0
|
|
|
|
def __repr__(self) -> str:
|
|
return __internal__.raw_type_str(self.__raw__(), "function")
|
|
|
|
@llvm
|
|
def __call__(self, *args) -> TR:
|
|
noop # compiler will populate this one
|