vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity

parser: do not allow duplicate fns; cgen: move fn code to fn.v

pull/4394/head
Alexander Medvednikov 2020-04-13 19:59:57 +02:00
parent fb4cfa72cd
commit 24958df565
7 changed files with 193 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/tools/vpm.v
View File

@ -141,7 +141,7 @@ fn vpm_install(module_names []string) {
if vcs == '' {
vcs = supported_vcs_systems[0]
}
if !vcs in supported_vcs_systems {
if vcs !in supported_vcs_systems {
errors++
println('Skipping module "$name", since it uses an unsupported VCS {$vcs} .')
continue

7
vlib/json/json_primitives.v
View File

@ -13,11 +13,12 @@ struct C.cJSON {
}
pub fn decode() voidptr {
return 0
}
pub fn encode() voidptr {
pub fn encode(x voidptr) string {
// compiler implementation
return ''
}
fn jsdecode_int(root &C.cJSON) int {

6
vlib/v/checker/checker.v
View File

@ -890,6 +890,9 @@ fn (c mut Checker) stmt(node ast.Stmt) {
// c.warn('duplicate method `$it.name`', it.pos)
// }
// }
if f := c.table.find_fn(it.name) {
c.warn('redefinition of `$it.name`', it.pos)
}
c.expected_type = table.void_type
c.fn_return_type = it.return_type
c.stmts(it.stmts)
@ -1551,7 +1554,7 @@ pub fn (c mut Checker) error(message string, pos token.Position) {
fn (c mut Checker) warn_or_error(message string, pos token.Position, warn bool) {
// add backtrace to issue struct, how?
// if c.pref.is_verbose {
// print_backtrace()
// print_backtrace()
// }
if !warn {
c.nr_errors++
@ -1571,7 +1574,6 @@ fn (c mut Checker) warn_or_error(message string, pos token.Position, warn bool)
file_path: c.file.path
message: message
}
}
}

7
vlib/v/fmt/fmt.v
View File

@ -111,7 +111,8 @@ fn (f mut Fmt) imports(imports []ast.Import) {
// f.indent++
for imp in imports {
if !(imp.mod in f.used_imports) {
continue
// TODO bring back once only unused imports are removed
// continue
}
f.out_imports.write('\t')
f.out_imports.writeln(f.imp_stmt_str(imp))
@ -529,7 +530,7 @@ fn (f mut Fmt) expr(node ast.Expr) {
f.write('_')
} else {
name := short_module(it.name)
//f.write('<$it.name => $name>')
// f.write('<$it.name => $name>')
f.write(name)
if name.contains('.') {
f.mark_module_as_used(name)
@ -673,7 +674,7 @@ fn (f mut Fmt) expr(node ast.Expr) {
}
ast.StructInit {
type_sym := f.table.get_type_symbol(it.typ)
//f.write('<old name: $type_sym.name>')
// f.write('<old name: $type_sym.name>')
mut name := short_module(type_sym.name).replace(f.cur_mod + '.', '') // TODO f.type_to_str?
if name == 'void' {
name = ''

184
vlib/v/gen/cgen.v
View File

@ -7,11 +7,11 @@ import (
strings
v.ast
v.table
v.depgraph
v.token
v.pref
term
v.token
v.util
v.depgraph
term
)
const (
@ -21,6 +21,10 @@ const (
'void', 'volatile', 'while']
)
fn foo(t token.Token) {
util.full_hash()
}
struct Gen {
out strings.Builder
typedefs strings.Builder
@ -809,109 +813,6 @@ fn (g mut Gen) gen_clone_assignment(val ast.Expr, right_sym table.TypeSymbol, ad
return true
}
fn (g mut Gen) gen_fn_decl(it ast.FnDecl) {
if it.is_c {
// || it.no_body {
return
}
g.reset_tmp_count()
is_main := it.name == 'main'
if is_main {
if g.pref.os == .windows {
g.write('int wmain(int ___argc, wchar_t *___argv[], wchar_t *___envp[]')
} else {
g.write('int ${it.name}(int ___argc, char** ___argv')
}
} else {
mut name := it.name
c := name[0]
if c in [`+`, `-`, `*`, `/`, `%`] {
name = util.replace_op(name)
}
if it.is_method {
name = g.table.get_type_symbol(it.receiver.typ).name + '_' + name
}
if it.is_c {
name = name.replace('.', '__')
} else {
name = c_name(name)
}
// if g.pref.show_cc && it.is_builtin {
// println(name)
// }
// type_name := g.table.Type_to_str(it.return_type)
type_name := g.typ(it.return_type)
g.write('$type_name ${name}(')
g.definitions.write('$type_name ${name}(')
}
// Receiver is the first argument
/*
if it.is_method {
mut styp := g.typ(it.receiver.typ)
// if table.type_nr_muls(it.receiver.typ) > 0 {
// if it.rec_mut {
// styp += '*'
// }
g.write('$styp $it.receiver.name ')
// TODO mut
g.definitions.write('$styp $it.receiver.name')
if it.args.len > 0 {
g.write(', ')
g.definitions.write(', ')
}
}
*/
//
g.fn_args(it.args, it.is_variadic)
if it.no_body || (g.pref.is_cache && it.is_builtin) {
// Just a function header.
// Builtin function bodies are defined in builtin.o
g.definitions.writeln(');')
g.writeln(');')
return
}
g.writeln(') {')
if !is_main {
g.definitions.writeln(');')
}
if is_main {
g.writeln('\t_vinit();')
if g.is_importing_os() {
if g.autofree {
g.writeln('free(_const_os__args.data); // empty, inited in _vinit()')
}
if g.pref.os == .windows {
g.writeln('\t_const_os__args = os__init_os_args_wide(___argc, ___argv);')
} else {
g.writeln('\t_const_os__args = os__init_os_args(___argc, (byteptr*)___argv);')
}
}
}
g.stmts(it.stmts)
// ////////////
if g.autofree {
g.free_scope_vars(it.pos.pos - 1)
}
// /////////
if is_main {
if g.autofree {
g.writeln('\t_vcleanup();')
}
if g.is_test {
verror('test files cannot have function `main`')
}
}
if g.defer_stmts.len > 0 {
g.write_defer_stmts()
}
if is_main {
g.writeln('\treturn 0;')
}
g.writeln('}')
g.defer_stmts = []
g.fn_decl = 0
}
fn (g mut Gen) free_scope_vars(pos int) {
scope := g.file.scope.innermost(pos)
for _, obj in scope.objects {
@ -953,55 +854,6 @@ fn (g mut Gen) free_scope_vars(pos int) {
}
}
fn (g mut Gen) fn_args(args []table.Arg, is_variadic bool) {
no_names := args.len > 0 && args[0].name == 'arg_1'
for i, arg in args {
arg_type_sym := g.table.get_type_symbol(arg.typ)
mut arg_type_name := g.typ(arg.typ) // arg_type_sym.name.replace('.', '__')
is_varg := i == args.len - 1 && is_variadic
if is_varg {
varg_type_str := int(arg.typ).str()
if !(varg_type_str in g.variadic_args) {
g.variadic_args[varg_type_str] = 0
}
arg_type_name = 'varg_' + g.typ(arg.typ).replace('*', '_ptr')
}
if arg_type_sym.kind == .function {
info := arg_type_sym.info as table.FnType
func := info.func
if !info.is_anon {
g.write(arg_type_name + ' ' + arg.name)
g.definitions.write(arg_type_name + ' ' + arg.name)
} else {
g.write('${g.typ(func.return_type)} (*$arg.name)(')
g.definitions.write('${g.typ(func.return_type)} (*$arg.name)(')
g.fn_args(func.args, func.is_variadic)
g.write(')')
g.definitions.write(')')
}
} else if no_names {
g.write(arg_type_name)
g.definitions.write(arg_type_name)
} else {
mut nr_muls := table.type_nr_muls(arg.typ)
s := arg_type_name + ' ' + arg.name
if arg.is_mut {
// mut arg needs one *
nr_muls = 1
}
// if nr_muls > 0 && !is_varg {
// s = arg_type_name + strings.repeat(`*`, nr_muls) + ' ' + arg.name
// }
g.write(s)
g.definitions.write(s)
}
if i < args.len - 1 {
g.write(', ')
g.definitions.write(', ')
}
}
}
fn (g mut Gen) expr(node ast.Expr) {
// println('cgen expr() line_nr=$node.pos.line_nr')
match node {
@ -2406,7 +2258,7 @@ fn (g mut Gen) string_inter_literal(node ast.StringInterLiteral) {
}
g.write('%' + sfmt[1..])
} else if node.expr_types[i] in [table.string_type, table.bool_type, table.f32_type,
table.f64_type] || sym.kind in [.enum_, .array, .array_fixed] {
table.f64_type] || sym.kind in [.enum_, .array, .array_fixed] {
g.write('%.*s')
} else {
g.write('%d')
@ -2421,25 +2273,21 @@ fn (g mut Gen) string_inter_literal(node ast.StringInterLiteral) {
if fspec == `s` && node.expr_types[i] == table.string_type {
g.expr(expr)
g.write('.str')
}
else {
} else {
g.expr(expr)
}
}
else if node.expr_types[i] == table.string_type {
} else if node.expr_types[i] == table.string_type {
// `name.str, name.len,`
g.expr(expr)
g.write('.len, ')
g.expr(expr)
g.write('.str')
}
else if node.expr_types[i] == table.bool_type {
} else if node.expr_types[i] == table.bool_type {
g.expr(expr)
g.write(' ? 4 : 5, ')
g.expr(expr)
g.write(' ? "true" : "false"')
}
else {
} else {
sym := g.table.get_type_symbol(node.expr_types[i])
if sym.kind == .enum_ {
is_var := match node.exprs[i] {
@ -2472,9 +2320,8 @@ fn (g mut Gen) string_inter_literal(node ast.StringInterLiteral) {
g.enum_expr(expr)
g.write('"')
}
}
else if node.expr_types[i] in [table.f32_type, table.f64_type, table.array_type,
table.map_type] || sym.kind in [.array, .array_fixed] {
} else if node.expr_types[i] in [table.f32_type, table.f64_type, table.array_type,
table.map_type] || sym.kind in [.array, .array_fixed] {
styp := g.typ(node.expr_types[i])
g.write('${styp}_str(')
g.expr(expr)
@ -2483,8 +2330,7 @@ fn (g mut Gen) string_inter_literal(node ast.StringInterLiteral) {
g.write('${styp}_str(')
g.expr(expr)
g.write(').str')
}
else {
} else {
g.expr(expr)
}
}

162
vlib/v/gen/fn.v 100644
View File

@ -0,0 +1,162 @@
// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module gen
import (
v.ast
v.table
v.util
)
fn (g mut Gen) gen_fn_decl(it ast.FnDecl) {
if it.is_c {
// || it.no_body {
return
}
g.reset_tmp_count()
is_main := it.name == 'main'
if is_main {
if g.pref.os == .windows {
g.write('int wmain(int ___argc, wchar_t *___argv[], wchar_t *___envp[]')
} else {
g.write('int ${it.name}(int ___argc, char** ___argv')
}
} else {
mut name := it.name
c := name[0]
if c in [`+`, `-`, `*`, `/`, `%`] {
name = util.replace_op(name)
}
if it.is_method {
name = g.table.get_type_symbol(it.receiver.typ).name + '_' + name
}
if it.is_c {
name = name.replace('.', '__')
} else {
name = c_name(name)
}
// if g.pref.show_cc && it.is_builtin {
// println(name)
// }
// type_name := g.table.Type_to_str(it.return_type)
type_name := g.typ(it.return_type)
g.write('$type_name ${name}(')
g.definitions.write('$type_name ${name}(')
}
// Receiver is the first argument
/*
if it.is_method {
mut styp := g.typ(it.receiver.typ)
// if table.type_nr_muls(it.receiver.typ) > 0 {
// if it.rec_mut {
// styp += '*'
// }
g.write('$styp $it.receiver.name ')
// TODO mut
g.definitions.write('$styp $it.receiver.name')
if it.args.len > 0 {
g.write(', ')
g.definitions.write(', ')
}
}
*/
//
g.fn_args(it.args, it.is_variadic)
if it.no_body || (g.pref.is_cache && it.is_builtin) {
// Just a function header.
// Builtin function bodies are defined in builtin.o
g.definitions.writeln(');')
g.writeln(');')
return
}
g.writeln(') {')
if !is_main {
g.definitions.writeln(');')
}
if is_main {
g.writeln('\t_vinit();')
if g.is_importing_os() {
if g.autofree {
g.writeln('free(_const_os__args.data); // empty, inited in _vinit()')
}
if g.pref.os == .windows {
g.writeln('\t_const_os__args = os__init_os_args_wide(___argc, ___argv);')
} else {
g.writeln('\t_const_os__args = os__init_os_args(___argc, (byteptr*)___argv);')
}
}
}
g.stmts(it.stmts)
// ////////////
if g.autofree {
g.free_scope_vars(it.pos.pos - 1)
}
// /////////
if is_main {
if g.autofree {
g.writeln('\t_vcleanup();')
}
if g.is_test {
verror('test files cannot have function `main`')
}
}
if g.defer_stmts.len > 0 {
g.write_defer_stmts()
}
if is_main {
g.writeln('\treturn 0;')
}
g.writeln('}')
g.defer_stmts = []
g.fn_decl = 0
}
fn (g mut Gen) fn_args(args []table.Arg, is_variadic bool) {
no_names := args.len > 0 && args[0].name == 'arg_1'
for i, arg in args {
arg_type_sym := g.table.get_type_symbol(arg.typ)
mut arg_type_name := g.typ(arg.typ) // arg_type_sym.name.replace('.', '__')
is_varg := i == args.len - 1 && is_variadic
if is_varg {
varg_type_str := int(arg.typ).str()
if !(varg_type_str in g.variadic_args) {
g.variadic_args[varg_type_str] = 0
}
arg_type_name = 'varg_' + g.typ(arg.typ).replace('*', '_ptr')
}
if arg_type_sym.kind == .function {
info := arg_type_sym.info as table.FnType
func := info.func
if !info.is_anon {
g.write(arg_type_name + ' ' + arg.name)
g.definitions.write(arg_type_name + ' ' + arg.name)
} else {
g.write('${g.typ(func.return_type)} (*$arg.name)(')
g.definitions.write('${g.typ(func.return_type)} (*$arg.name)(')
g.fn_args(func.args, func.is_variadic)
g.write(')')
g.definitions.write(')')
}
} else if no_names {
g.write(arg_type_name)
g.definitions.write(arg_type_name)
} else {
mut nr_muls := table.type_nr_muls(arg.typ)
s := arg_type_name + ' ' + arg.name
if arg.is_mut {
// mut arg needs one *
nr_muls = 1
}
// if nr_muls > 0 && !is_varg {
// s = arg_type_name + strings.repeat(`*`, nr_muls) + ' ' + arg.name
// }
g.write(s)
g.definitions.write(s)
}
if i < args.len - 1 {
g.write(', ')
g.definitions.write(', ')
}
}
}

3
vlib/v/parser/fn.v
View File

@ -176,6 +176,9 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
} else {
name = p.prepend_mod(name)
}
if _ := p.table.find_fn(name) {
p.error('redefinition of `$name`')
}
p.table.register_fn(table.Fn{
name: name
args: args