645 lines
14 KiB
V
645 lines
14 KiB
V
module main
|
|
|
|
struct Table {
|
|
mut:
|
|
types []Type
|
|
consts []Var
|
|
fns []Fn
|
|
obf_ids map_int // obf_ids 'myfunction'] == 23
|
|
packages []string // List of all modules registered by the application
|
|
imports []string // List of all imports
|
|
flags []string // ['-framework Cocoa', '-lglfw3']
|
|
fn_cnt int atomic
|
|
obfuscate bool
|
|
}
|
|
|
|
enum AccessMod {
|
|
PRIVATE // private immutable
|
|
PRIVET_MUT // private mutable
|
|
PUBLIC // public immmutable (readonly)
|
|
PUBLIC_MUT // public, but mutable only in this module
|
|
PUBLIC_MUT_MUT // public and mutable both inside and outside (not recommended to use, that's why it's so verbose)
|
|
}
|
|
|
|
enum TypeCategory {
|
|
TYPE_STRUCT
|
|
T_CAT_FN
|
|
}
|
|
|
|
struct Type {
|
|
mut:
|
|
pkg string
|
|
name string
|
|
fields []Var
|
|
methods []Fn
|
|
parent string
|
|
cat TypeCategory
|
|
gen_types []string
|
|
func Fn // For cat == FN (type kek fn())
|
|
is_c bool // C.FILE
|
|
is_interface bool
|
|
is_enum bool
|
|
// This field is used for types that are not defined yet but are known to exist.
|
|
// It allows having things like `fn (f Foo) bar()` before `Foo` is defined.
|
|
// This information is needed in the first pass.
|
|
is_placeholder bool
|
|
}
|
|
|
|
// For debugging types
|
|
fn (t Type) str() string {
|
|
mut s := 'type "$t.name" {'
|
|
if t.fields.len > 0 {
|
|
// s += '\n $t.fields.len fields:\n'
|
|
for field in t.fields {
|
|
s += '\n $field.name $field.typ'
|
|
}
|
|
s += '\n'
|
|
}
|
|
if t.methods.len > 0 {
|
|
// s += '\n $t.methods.len methods:\n'
|
|
for method in t.methods {
|
|
s += '\n ${method.str()}'
|
|
}
|
|
s += '\n'
|
|
}
|
|
s += '}\n'
|
|
return s
|
|
}
|
|
|
|
const (
|
|
CReserved = [
|
|
'exit',
|
|
'unix',
|
|
'print',
|
|
// 'ok',
|
|
'error',
|
|
'malloc',
|
|
'calloc',
|
|
'char',
|
|
'free',
|
|
'panic',
|
|
'register'
|
|
]
|
|
|
|
)
|
|
|
|
// This is used in generated C code
|
|
fn (f Fn) str() string {
|
|
t := Table{}
|
|
str_args := f.str_args(t)
|
|
return '$f.name($str_args) $f.typ'
|
|
}
|
|
|
|
// fn (types array_Type) print_to_file(f string) {
|
|
// }
|
|
const (
|
|
NUMBER_TYPES = ['number', 'int', 'i8', 'u8', 'i16', 'u16', 'i32', 'u32', 'byte', 'i64', 'u64', 'long', 'double', 'float', 'f32', 'f64']
|
|
FLOAT_TYPES = ['double', 'float', 'f32', 'f64']
|
|
)
|
|
|
|
fn is_number_type(typ string) bool {
|
|
return NUMBER_TYPES.contains(typ)
|
|
}
|
|
|
|
fn is_float_type(typ string) bool {
|
|
return FLOAT_TYPES.contains(typ)
|
|
}
|
|
|
|
fn new_table(obfuscate bool) *Table {
|
|
mut t := &Table {
|
|
obf_ids: map[string]int{}
|
|
obfuscate: obfuscate
|
|
}
|
|
t.register_type('int')
|
|
t.register_type('size_t')
|
|
t.register_type_with_parent('i8', 'int')
|
|
t.register_type_with_parent('u8', 'int')
|
|
t.register_type_with_parent('i16', 'int')
|
|
t.register_type_with_parent('u16', 'int')
|
|
t.register_type_with_parent('i32', 'int')
|
|
t.register_type_with_parent('u32', 'int')
|
|
t.register_type_with_parent('byte', 'int')
|
|
// t.register_type_with_parent('i64', 'int')
|
|
t.register_type('i64')
|
|
t.register_type_with_parent('u64', 'int')
|
|
t.register_type('long')
|
|
t.register_type('byteptr')
|
|
t.register_type('intptr')
|
|
t.register_type('double')// TODO remove
|
|
t.register_type('float')// TODO remove
|
|
t.register_type('f32')
|
|
t.register_type('f64')
|
|
t.register_type('rune')
|
|
t.register_type('bool')
|
|
t.register_type('void')
|
|
t.register_type('voidptr')
|
|
t.register_type('va_list')
|
|
t.register_const('stdin', 'int', 'main', false)
|
|
t.register_const('stderr', 'int', 'main', false)
|
|
t.register_type_with_parent('map_string', 'map')
|
|
t.register_type_with_parent('map_int', 'map')
|
|
return t
|
|
}
|
|
|
|
// If `name` is a reserved C keyword, returns `v_name` instead.
|
|
fn (t mut Table) var_cgen_name(name string) string {
|
|
if CReserved.contains(name) {
|
|
return 'v_$name'
|
|
}
|
|
else {
|
|
return name
|
|
}
|
|
}
|
|
|
|
fn (t mut Table) register_package(pkg string) {
|
|
if t.packages.contains(pkg) {
|
|
return
|
|
}
|
|
t.packages << pkg
|
|
}
|
|
|
|
fn (table &Table) known_pkg(pkg string) bool {
|
|
return pkg in table.packages
|
|
}
|
|
|
|
fn (t mut Table) register_const(name, typ string, pkg string, is_imported bool) {
|
|
t.consts << Var {
|
|
name: name
|
|
typ: typ
|
|
is_const: true
|
|
is_import_const: is_imported
|
|
pkg: pkg
|
|
}
|
|
}
|
|
|
|
// Only for translated code
|
|
fn (p mut Parser) register_global(name, typ string) {
|
|
p.table.consts << Var {
|
|
name: name
|
|
typ: typ
|
|
is_const: true
|
|
is_global: true
|
|
pkg: p.pkg
|
|
}
|
|
}
|
|
|
|
// TODO PERF O(N) this slows down the comiler a lot!
|
|
fn (t mut Table) register_fn(f Fn) {
|
|
// Avoid duplicate fn names TODO why? the name should already be unique?
|
|
for ff in t.fns {
|
|
if ff.name == f.name {
|
|
return
|
|
}
|
|
}
|
|
t.fns << f
|
|
}
|
|
|
|
fn (table &Table) known_type(typ string) bool {
|
|
// 'byte*' => look up 'byte', but don't mess up fns
|
|
if typ.ends_with('*') && !typ.contains(' ') {
|
|
typ = typ.left(typ.len - 1)
|
|
}
|
|
for t in table.types {
|
|
if t.name == typ && !t.is_placeholder {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// TODO PERF O(N) this slows down the comiler a lot!
|
|
fn (t &Table) find_fn(name string) Fn {
|
|
for f in t.fns {
|
|
if f.name == name {
|
|
return f
|
|
}
|
|
}
|
|
return Fn{}
|
|
}
|
|
|
|
// TODO PERF O(N) this slows down the comiler a lot!
|
|
fn (t &Table) known_fn(name string) bool {
|
|
for f in t.fns {
|
|
if f.name == name {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn (t &Table) known_const(name string) bool {
|
|
v := t.find_const(name)
|
|
// TODO use optional
|
|
return v.name.len > 0
|
|
}
|
|
|
|
fn (t mut Table) register_type(typ string) {
|
|
if typ.len == 0 {
|
|
return
|
|
}
|
|
// println('REGISTER TYPE $typ')
|
|
for typ2 in t.types {
|
|
if typ2.name == typ {
|
|
return
|
|
}
|
|
}
|
|
// if t.types.filter( _.name == typ.name).len > 0 {
|
|
// return
|
|
// }
|
|
datyp := Type {
|
|
name: typ
|
|
}
|
|
t.types << datyp
|
|
}
|
|
|
|
fn (p mut Parser) register_type_with_parent(strtyp, parent string) {
|
|
typ := Type {
|
|
name: strtyp
|
|
parent: parent
|
|
pkg: p.pkg
|
|
}
|
|
p.table.register_type2(typ)
|
|
}
|
|
|
|
fn (t mut Table) register_type_with_parent(typ, parent string) {
|
|
if typ.len == 0 {
|
|
return
|
|
}
|
|
// if t.types.filter(_.name == typ) > 0
|
|
for typ2 in t.types {
|
|
if typ2.name == typ {
|
|
return
|
|
}
|
|
}
|
|
/*
|
|
mut pkg := ''
|
|
if parent == 'array' {
|
|
pkg = 'builtin'
|
|
}
|
|
*/
|
|
datyp := Type {
|
|
name: typ
|
|
parent: parent
|
|
}
|
|
t.types << datyp
|
|
}
|
|
|
|
fn (t mut Table) register_type2(typ Type) {
|
|
if typ.name.len == 0 {
|
|
return
|
|
}
|
|
// println('register type2 $typ.name')
|
|
for typ2 in t.types {
|
|
if typ2.name == typ.name {
|
|
return
|
|
}
|
|
}
|
|
t.types << typ
|
|
}
|
|
|
|
fn (t mut Type) add_field(name, typ string, is_mut bool, attr string, access_mod AccessMod) {
|
|
// if t.name == 'Parser' {
|
|
// println('adding field $name')
|
|
// }
|
|
v := Var {
|
|
name: name
|
|
typ: typ
|
|
is_mut: is_mut
|
|
attr: attr
|
|
access_mod: access_mod
|
|
}
|
|
t.fields << v
|
|
}
|
|
|
|
fn (t &Type) has_field(name string) bool {
|
|
field := t.find_field(name)
|
|
return (field.name != '')
|
|
}
|
|
|
|
fn (t &Type) find_field(name string) Var {
|
|
for field in t.fields {
|
|
if field.name == name {
|
|
return field
|
|
}
|
|
}
|
|
return Var{}
|
|
}
|
|
|
|
fn (table &Table) type_has_field(typ &Type, name string) bool {
|
|
field := table.find_field(typ, name)
|
|
return (field.name != '')
|
|
}
|
|
|
|
fn (table &Table) find_field(typ &Type, name string) Var {
|
|
field := typ.find_field(name)
|
|
if field.name.len == 0 && typ.parent.len > 0 {
|
|
parent := table.find_type(typ.parent)
|
|
return parent.find_field(name)
|
|
}
|
|
return field
|
|
}
|
|
|
|
fn (t mut Type) add_method(f Fn) {
|
|
// if t.name.contains('Parser') {
|
|
// println('!!!add_method() $f.name to $t.name len=$t.methods.len cap=$t.methods.cap')
|
|
// }
|
|
t.methods << f
|
|
// println('end add_method()')
|
|
}
|
|
|
|
fn (t &Type) has_method(name string) bool {
|
|
method := t.find_method(name)
|
|
return (method.name != '')
|
|
}
|
|
|
|
fn (table &Table) type_has_method(typ &Type, name string) bool {
|
|
method := table.find_method(typ, name)
|
|
return (method.name != '')
|
|
}
|
|
|
|
// TODO use `?Fn`
|
|
fn (table &Table) find_method(typ &Type, name string) Fn {
|
|
// println('TYPE HAS METHOD $name')
|
|
method := typ.find_method(name)
|
|
if method.name.len == 0 && typ.parent.len > 0 {
|
|
parent := table.find_type(typ.parent)
|
|
return parent.find_method(name)
|
|
// println('parent = $parent.name $res')
|
|
// return res
|
|
}
|
|
return method
|
|
}
|
|
|
|
fn (t &Type) find_method(name string) Fn {
|
|
// println('$t.name find_method($name) methods.len=$t.methods.len')
|
|
for method in t.methods {
|
|
// println('method=$method.name')
|
|
if method.name == name {
|
|
return method
|
|
}
|
|
}
|
|
return Fn{}
|
|
}
|
|
|
|
fn (t mut Type) add_gen_type(type_name string) {
|
|
// println('add_gen_type($s)')
|
|
if t.gen_types.contains(type_name) {
|
|
return
|
|
}
|
|
t.gen_types << type_name
|
|
}
|
|
|
|
fn (p &Parser) find_type(name string) *Type {
|
|
typ := p.table.find_type(name)
|
|
if typ.name.len == 0 {
|
|
return p.table.find_type(p.prepend_pkg(name))
|
|
}
|
|
return typ
|
|
}
|
|
|
|
fn (t &Table) find_type(name string) *Type {
|
|
if name.ends_with('*') && !name.contains(' ') {
|
|
name = name.left(name.len - 1)
|
|
}
|
|
// TODO PERF use map
|
|
for i, typ in t.types {
|
|
if typ.name == name {
|
|
return &t.types[i]
|
|
}
|
|
}
|
|
return &Type{}
|
|
}
|
|
|
|
fn (p mut Parser) _check_types(got, expected string, throw bool) bool {
|
|
p.log('check types got="$got" exp="$expected" ')
|
|
if p.translated {
|
|
return true
|
|
}
|
|
// Allow ints to be used as floats
|
|
if got.eq('int') && expected.eq('float') {
|
|
return true
|
|
}
|
|
if got.eq('int') && expected.eq('f64') {
|
|
return true
|
|
}
|
|
if got == 'f64' && expected == 'float' {
|
|
return true
|
|
}
|
|
if got == 'float' && expected == 'f64' {
|
|
return true
|
|
}
|
|
// Allow ints to be used as longs
|
|
if got.eq('int') && expected.eq('long') {
|
|
return true
|
|
}
|
|
if got == 'void*' && expected.starts_with('fn ') {
|
|
return true
|
|
}
|
|
if got.starts_with('[') && expected == 'byte*' {
|
|
return true
|
|
}
|
|
// Todo void* allows everything right now
|
|
if got.eq('void*') || expected.eq('void*') {
|
|
// if !p.builtin_pkg {
|
|
if p.is_play {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
// TODO only allow numeric consts to be assigned to bytes, and
|
|
// throw an error if they are bigger than 255
|
|
if got.eq('int') && expected.eq('byte') {
|
|
return true
|
|
}
|
|
if got.eq('int') && expected.eq('byte*') {
|
|
return true
|
|
}
|
|
// byteptr += int
|
|
if got.eq('int') && expected.eq('byteptr') {
|
|
return true
|
|
}
|
|
if got == 'Option' && expected.starts_with('Option_') {
|
|
return true
|
|
}
|
|
// lines := new_array
|
|
if got == 'array' && expected.starts_with('array_') {
|
|
return true
|
|
}
|
|
// Expected type "Option_os__File", got "os__File"
|
|
if expected.starts_with('Option_') && expected.ends_with(got) {
|
|
return true
|
|
}
|
|
// NsColor* return 0
|
|
if !p.is_play {
|
|
if expected.ends_with('*') && got == 'int' {
|
|
return true
|
|
}
|
|
// if got == 'T' || got.contains('<T>') {
|
|
// return true
|
|
// }
|
|
// if expected == 'T' || expected.contains('<T>') {
|
|
// return true
|
|
// }
|
|
// Allow pointer arithmetic
|
|
if expected.eq('void*') && got.eq('int') {
|
|
return true
|
|
}
|
|
}
|
|
expected = expected.replace('*', '')
|
|
got = got.replace('*', '')
|
|
if got != expected {
|
|
// Interface check
|
|
if expected.ends_with('er') {
|
|
if p.satisfies_interface(expected, got, throw) {
|
|
return true
|
|
}
|
|
}
|
|
if !throw {
|
|
return false
|
|
}
|
|
else {
|
|
p.error('expected type `$expected`, but got `$got`')
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// throw by default
|
|
fn (p mut Parser) check_types(got, expected string) bool {
|
|
return p._check_types(got, expected, true)
|
|
}
|
|
|
|
fn (p mut Parser) check_types_no_throw(got, expected string) bool {
|
|
return p._check_types(got, expected, false)
|
|
}
|
|
|
|
fn (p mut Parser) satisfies_interface(interface_name, _typ string, throw bool) bool {
|
|
int_typ := p.table.find_type(interface_name)
|
|
typ := p.table.find_type(_typ)
|
|
for method in int_typ.methods {
|
|
if !typ.has_method(method.name) {
|
|
// if throw {
|
|
p.error('Type "$_typ" doesnt satisfy interface "$interface_name" (method "$method.name" is not implemented)')
|
|
// }
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn type_default(typ string) string {
|
|
if typ.starts_with('array_') {
|
|
typ = typ.right(6)
|
|
return 'new_array(0, 1, sizeof($typ))'
|
|
}
|
|
// Always set pointers to 0
|
|
if typ.ends_with('*') {
|
|
return '0'
|
|
}
|
|
// ?
|
|
if typ.contains('__') {
|
|
return ''
|
|
}
|
|
// Default values for other types are not needed because of mandatory initialization
|
|
switch typ {
|
|
case 'int': return '0'
|
|
case 'string': return 'tos("", 0)'
|
|
case 'void*': return '0'
|
|
case 'byte*': return '0'
|
|
case 'bool': return '0'
|
|
}
|
|
return ''
|
|
}
|
|
|
|
// TODO PERF O(n)
|
|
fn (t &Table) is_interface(name string) bool {
|
|
for typ in t.types {
|
|
if typ.is_interface && typ.name == name {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Do we have fn main()?
|
|
fn (t &Table) main_exists() bool {
|
|
for f in t.fns {
|
|
if f.name == 'main' {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// TODO use `?Var`
|
|
fn (t &Table) find_const(name string) Var {
|
|
for c in t.consts {
|
|
if c.name == name {
|
|
return c
|
|
}
|
|
}
|
|
return Var{}
|
|
}
|
|
|
|
fn (table mut Table) cgen_name(f &Fn) string {
|
|
mut name := f.name
|
|
if f.is_method {
|
|
name = '${f.receiver_typ}_$f.name'
|
|
name = name.replace(' ', '')
|
|
name = name.replace('*', '')
|
|
name = name.replace('+', 'plus')
|
|
name = name.replace('-', 'minus')
|
|
}
|
|
// Avoid name conflicts (with things like abs(), print() etc).
|
|
// Generate b_abs(), b_print()
|
|
// TODO duplicate functionality
|
|
if f.pkg == 'builtin' && CReserved.contains(f.name) {
|
|
return 'v_$name'
|
|
}
|
|
// Obfuscate but skip certain names
|
|
// TODO ugly, fix
|
|
if table.obfuscate && f.name != 'main' && f.name != 'WinMain' && f.pkg != 'builtin' && !f.is_c &&
|
|
f.pkg != 'darwin' && f.pkg != 'os' && !f.name.contains('window_proc') && f.name != 'gg__vec2' &&
|
|
f.name != 'build_token_str' && f.name != 'build_keys' && f.pkg != 'json' &&
|
|
!name.ends_with('_str') && !name.contains('contains') {
|
|
mut idx := table.obf_ids[name]
|
|
// No such function yet, register it
|
|
if idx == 0 {
|
|
table.fn_cnt++
|
|
table.obf_ids[name] = table.fn_cnt
|
|
idx = table.fn_cnt
|
|
}
|
|
old := name
|
|
name = 'f_$idx'
|
|
println2('$old ==> $name')
|
|
}
|
|
return name
|
|
}
|
|
|
|
// ('s', 'string') => 'string s'
|
|
// ('nums', '[20]byte') => 'byte nums[20]'
|
|
// ('myfn', 'fn(int) string') => 'string (*myfn)(int)'
|
|
fn (table &Table) cgen_name_type_pair(name, typ string) string {
|
|
// Special case for [10]int
|
|
if typ.len > 0 && typ[0] == `[` {
|
|
tmp := typ.all_after(']')
|
|
size := typ.all_before(']')
|
|
return '$tmp $name $size ]'
|
|
}
|
|
// fn()
|
|
else if typ.starts_with('fn (') {
|
|
T := table.find_type(typ)
|
|
if T.name == '' {
|
|
os.exit1('this should never happen')
|
|
}
|
|
str_args := T.func.str_args(table)
|
|
return '$T.func.typ (*$name)( $str_args /*FFF*/ )'
|
|
}
|
|
// TODO tm hack, do this for all C struct args
|
|
else if typ == 'tm' {
|
|
return 'struct tm $name'
|
|
}
|
|
return '$typ $name'
|
|
}
|
|
|