mirror of
https://github.com/vlang/v.git
synced 2025-09-14 23:12:33 +03:00
compiler: make compiler an ordinary vlib/compiler module
* Move compiler/ under vlib/compiler/ . * Add a minimal compiler/main.v driver program. * Cleanup compiler/main.v . * Make most compiler tests pass again. * Apply the fix by @joe-conigliaro , so that the rest of the compiler tests are fixed too. * Thanks to @avitkauskas, now the vlib/vcompiler/tests/str_gen_test.v test does not need to be special cased anymore. * Reapply @joe-conigliaro fix for vgen.
This commit is contained in:
Delyan Angelov
Alexander Medvednikov
parent
59d4535f84
commit
53c64abdeb
71 changed files with 1095 additions and 1080 deletions
|
|
@ -1,262 +0,0 @@
|
|||
// Copyright (c) 2019 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 main
|
||||
|
||||
import (
|
||||
strings
|
||||
os
|
||||
)
|
||||
|
||||
/*
|
||||
.vh generation logic.
|
||||
.vh files contain only function signatures, consts, and types.
|
||||
They are used together with pre-compiled modules.
|
||||
*/
|
||||
|
||||
// "fn foo(a int) string"
|
||||
fn (f &Fn) v_definition() string {
|
||||
//t :=time.ticks()
|
||||
mut sb := strings.new_builder(100)
|
||||
if f.is_public {
|
||||
sb.write('pub ')
|
||||
}
|
||||
sb.write('fn ')
|
||||
if f.is_c {
|
||||
sb.write('C.')
|
||||
}
|
||||
if f.is_method {
|
||||
recv := f.args[0]
|
||||
typ := v_type_str(recv.typ).replace('*', '')
|
||||
mut mu := if recv.is_mut { 'mut' } else { '' }
|
||||
if recv.ref {
|
||||
mu = '&'
|
||||
}
|
||||
sb.write('($recv.name $mu $typ) ')
|
||||
}
|
||||
if f.name.contains('__') {
|
||||
sb.write(f.name.all_after('__') + '(')
|
||||
} else {
|
||||
sb.write('$f.name(')
|
||||
}
|
||||
for i, arg in f.args {
|
||||
if i == 0 && f.is_method { // skip the receiver
|
||||
continue
|
||||
}
|
||||
typ := v_type_str(arg.typ).replace('*', '&')
|
||||
if arg.name == '' {
|
||||
sb.write(typ)
|
||||
} else {
|
||||
sb.write('$arg.name $typ')
|
||||
}
|
||||
if i != f.args.len - 1 {
|
||||
sb.write(', ')
|
||||
}
|
||||
}
|
||||
sb.write(')')
|
||||
if f.typ != 'void' {
|
||||
typ := v_type_str(f.typ).replace('*', '&')
|
||||
sb.write(' ')
|
||||
sb.write(typ)
|
||||
sb.writeln(' ')
|
||||
}
|
||||
//println('ms: ${time.ticks() - t}')
|
||||
return sb.str()
|
||||
}
|
||||
|
||||
fn v_type_str(typ_ string) string {
|
||||
mut typ := if typ_.ends_with('*') {
|
||||
'*' + typ_.left(typ_.len - 1)
|
||||
} else {
|
||||
typ_
|
||||
}
|
||||
typ = typ.replace('Option_', '?')
|
||||
// fn parent/alias?
|
||||
if typ.starts_with('fn ') {
|
||||
mut types := []string
|
||||
fi_lpar := typ.index_byte(`(`)
|
||||
li_rpar := typ.last_index_byte(`)`)
|
||||
ret_type := typ.right(li_rpar+1)
|
||||
for t in typ.substr(fi_lpar+1, li_rpar).split(',') {
|
||||
types << v_type_str(t)
|
||||
}
|
||||
return 'fn (' + types.join(', ') + ')$ret_type'
|
||||
}
|
||||
typ = typ.replace('Option_', '?')
|
||||
// multiple return
|
||||
if typ.contains('_V_MulRet') {
|
||||
words := typ.replace('_V_MulRet_', '').replace('_PTR_', '*').split('_V_')
|
||||
typ = '('
|
||||
for i in 0 .. words.len {
|
||||
typ += v_type_str(words[i])
|
||||
if i != words.len - 1 {
|
||||
typ += ','
|
||||
}
|
||||
}
|
||||
typ += ')'
|
||||
return typ
|
||||
}
|
||||
//println('"$typ"')
|
||||
if typ == '*void' {
|
||||
return 'voidptr'
|
||||
}
|
||||
if typ == '*byte' {
|
||||
return 'byteptr'
|
||||
}
|
||||
if typ.starts_with('array_') {
|
||||
return '[]' + typ.right(6)
|
||||
}
|
||||
if typ.contains('__') {
|
||||
opt := typ.starts_with('?')
|
||||
typ = typ.all_after('__')
|
||||
if opt {
|
||||
typ = '?' + typ
|
||||
}
|
||||
}
|
||||
return typ
|
||||
}
|
||||
|
||||
fn (v &V) generate_vh() {
|
||||
println('\n\n\n\nGenerating a V header file for module `$v.mod`')
|
||||
mod_path := v.mod.replace('.', os.path_separator)
|
||||
dir := if v.dir.starts_with('vlib') {
|
||||
'$v_modules_path${os.path_separator}$v.dir'
|
||||
} else {
|
||||
'$v_modules_path${os.path_separator}$mod_path'
|
||||
}
|
||||
path := dir + '.vh'
|
||||
pdir := dir.all_before_last(os.path_separator)
|
||||
if !os.dir_exists(pdir) {
|
||||
os.mkdir_all(pdir)
|
||||
// os.mkdir(os.realpath(dir))
|
||||
}
|
||||
file := os.create(path) or { panic(err) }
|
||||
// Consts
|
||||
mod_def := if v.mod.contains('.') { v.mod.all_after('.') } else { v.mod }
|
||||
file.writeln('// $v.mod module header \n')
|
||||
file.writeln('module $mod_def')
|
||||
file.writeln('// Consts')
|
||||
if v.table.consts.len > 0 {
|
||||
file.writeln('const (')
|
||||
for i, c in v.table.consts {
|
||||
if c.mod != v.mod {
|
||||
continue
|
||||
}
|
||||
// println('$i $c.name')
|
||||
//if !c.name.contains('__') {
|
||||
//continue
|
||||
//}
|
||||
name := c.name.all_after('__')
|
||||
typ := v_type_str(c.typ)
|
||||
file.writeln('\t$name $typ')
|
||||
}
|
||||
file.writeln(')\n')
|
||||
// Globals
|
||||
for var in v.table.consts {
|
||||
if var.mod != v.mod {
|
||||
continue
|
||||
}
|
||||
if !var.is_global {
|
||||
continue
|
||||
}
|
||||
name := var.name.all_after('__')
|
||||
typ := v_type_str(var.typ)
|
||||
file.writeln('__global $name $typ')
|
||||
}
|
||||
file.writeln('\n')
|
||||
}
|
||||
// Types
|
||||
file.writeln('// Types')
|
||||
for _, typ in v.table.typesmap {
|
||||
//println(typ.name)
|
||||
if typ.mod != v.mod && typ.mod != ''{ // int, string etc mod == ''
|
||||
// println('skipping type "$typ.name"')
|
||||
continue
|
||||
}
|
||||
if typ.name.contains('_V_MulRet') {
|
||||
continue
|
||||
}
|
||||
mut name := typ.name
|
||||
if typ.name.contains('__') {
|
||||
name = typ.name.all_after('__')
|
||||
}
|
||||
// type alias
|
||||
if typ.parent != '' && typ.cat == .alias {
|
||||
parent := v_type_str(typ.parent)
|
||||
file.writeln('type $typ.name $parent')
|
||||
}
|
||||
if typ.cat in [TypeCategory.struct_, .c_struct] {
|
||||
c := if typ.is_c { 'C.' } else { '' }
|
||||
file.writeln('struct ${c}$name {')
|
||||
// Private fields
|
||||
for field in typ.fields {
|
||||
if field.access_mod == .public {
|
||||
continue
|
||||
}
|
||||
field_type := v_type_str(field.typ).replace('*', '&')
|
||||
file.writeln('\t$field.name $field_type')
|
||||
}
|
||||
//file.writeln('pub:')
|
||||
mut public_str := ''
|
||||
for field in typ.fields {
|
||||
if field.access_mod == .private {
|
||||
continue
|
||||
}
|
||||
field_type := v_type_str(field.typ).replace('*', '&')
|
||||
public_str += '\t$field.name $field_type\n'
|
||||
//file.writeln('\t$field.name $field_type')
|
||||
}
|
||||
if public_str != '' {
|
||||
file.writeln('pub:' + public_str)
|
||||
}
|
||||
file.writeln('}\n')
|
||||
}
|
||||
}
|
||||
// Functions & methods
|
||||
file.writeln('// Functions')
|
||||
// Public first
|
||||
mut fns := []Fn
|
||||
// TODO fns := v.table.fns.filter(.mod == v.mod)
|
||||
for _, f in v.table.fns {
|
||||
if f.mod == v.mod || f.mod == ''{
|
||||
fns << f
|
||||
} else {
|
||||
//println('skipping fn $f.name mod=$f.mod')
|
||||
}
|
||||
}
|
||||
for _, f in fns {
|
||||
if !f.is_public {
|
||||
continue
|
||||
}
|
||||
file.writeln(f.v_definition())
|
||||
}
|
||||
// Private
|
||||
for _, f in fns {
|
||||
if f.is_public {
|
||||
continue
|
||||
}
|
||||
file.writeln(f.v_definition())
|
||||
}
|
||||
// Methods
|
||||
file.writeln('\n// Methods //////////////////')
|
||||
for _, typ in v.table.typesmap {
|
||||
if typ.mod != v.mod && !(v.mod == 'builtin' && typ.mod == '') {
|
||||
// println('skipping method typ $typ.name mod=$typ.mod')
|
||||
continue
|
||||
}
|
||||
for method in typ.methods {
|
||||
file.writeln(method.v_definition())
|
||||
}
|
||||
}
|
||||
file.close()
|
||||
|
||||
/*
|
||||
for i, p in v.parsers {
|
||||
if v.parsers[i].vh_lines.len > 0 {
|
||||
os.write_file(p.file_name +'.vh', v.parsers[i].vh_lines.join('\n'))
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue