1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/compiler/main.v

973 lines
24 KiB
V
Raw Normal View History

2019-06-23 05:21:30 +03:00
// 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.
2019-06-22 21:20:28 +03:00
module main
2019-08-29 01:52:32 +03:00
import (
os
time
strings
)
2019-06-22 21:20:28 +03:00
const (
2019-08-17 22:19:37 +03:00
Version = '0.1.18'
2019-06-22 21:20:28 +03:00
)
enum BuildMode {
// `v program.v'
// Build user code only, and add pre-compiled vlib (`cc program.o builtin.o os.o...`)
2019-07-12 08:23:16 +03:00
default_mode
2019-06-22 21:20:28 +03:00
// `v -embed_vlib program.v`
// vlib + user code in one file (slower compilation, but easier when working on vlib and cross-compiling)
2019-07-12 08:23:16 +03:00
embed_vlib
2019-06-22 21:20:28 +03:00
// `v -lib ~/v/os`
// build any module (generate os.o + os.vh)
2019-07-12 08:23:16 +03:00
build //TODO a better name would be smth like `.build_module` I think
2019-06-22 21:20:28 +03:00
}
const (
2019-08-17 22:19:37 +03:00
SupportedPlatforms = ['windows', 'mac', 'linux', 'freebsd', 'openbsd', 'netbsd', 'dragonfly', 'msvc']
2019-08-23 03:10:37 +03:00
ModPath = os.home_dir() + '/.vmodules/'
2019-06-22 21:20:28 +03:00
)
enum OS {
mac
linux
windows
2019-08-17 22:19:37 +03:00
freebsd
openbsd
netbsd
dragonfly
msvc
2019-06-23 07:34:41 +03:00
}
2019-06-22 21:20:28 +03:00
enum Pass {
2019-07-16 18:59:07 +03:00
// A very short pass that only looks at imports in the beginning of
// each file
imports
2019-07-16 18:59:07 +03:00
// First pass, only parses and saves declarations (fn signatures,
// consts, types).
2019-06-22 21:20:28 +03:00
// Skips function bodies.
2019-07-16 18:59:07 +03:00
// We need this because in V things can be used before they are
// declared.
decl
2019-06-22 21:20:28 +03:00
// Second pass, parses function bodies and generates C or machine code.
main
}
2019-06-22 21:20:28 +03:00
struct V {
mut:
os OS // the OS to build for
2019-06-22 21:20:28 +03:00
out_name_c string // name of the temporary C file
files []string // all V files that need to be parsed and compiled
dir string // directory (or file) being compiled (TODO rename to path?)
2019-09-01 22:51:16 +03:00
table &Table // table with types, vars, functions etc
cgen &CGen // C code generator
pref &Preferences // all the prefrences and settings extracted to a struct for reusability
lang_dir string // "~/code/v"
2019-06-22 21:20:28 +03:00
out_name string // "program.exe"
vroot string
2019-08-17 22:19:37 +03:00
mod string // module being built with -lib
//parsers []Parser
2019-06-22 21:20:28 +03:00
}
struct Preferences {
mut:
build_mode BuildMode
nofmt bool // disable vfmt
is_test bool // `v test string_test.v`
is_script bool // single file mode (`v program.v`), main function can be skipped
is_live bool // for hot code reloading
is_so bool
is_prof bool // benchmark every function
translated bool // `v translate doom.v` are we running V code translated from C? allow globals, ++ expressions, etc
is_prod bool // use "-O2"
is_verbose bool // print extra information with `v.log()`
obfuscate bool // `v -obf program.v`, renames functions to "f_XXX"
is_repl bool
is_run bool
show_c_cmd bool // `v -show_c_cmd` prints the C command to build program.v.c
sanitize bool // use Clang's new "-fsanitize" option
2019-07-26 17:45:16 +03:00
is_debuggable bool
2019-07-03 04:16:26 +03:00
is_debug bool // keep compiled C files
2019-08-17 22:19:37 +03:00
no_auto_free bool // `v -nofree` disable automatic `free()` insertion for better performance in some applications (e.g. compilers)
cflags string // Additional options which will be passed to the C compiler.
// For example, passing -cflags -Os will cause the C compiler to optimize the generated binaries for size.
// You could pass several -cflags XXX arguments. They will be merged with each other.
// You can also quote several options at the same time: -cflags '-Os -fno-inline-small-functions'.
ccompiler string // the name of the used C compiler
}
2019-06-22 21:20:28 +03:00
fn main() {
2019-07-03 14:20:43 +03:00
// There's no `flags` module yet, so args have to be parsed manually
args := env_vflags_and_os_args()
2019-06-22 21:20:28 +03:00
// Print the version and exit.
if '-v' in args || '--version' in args || 'version' in args {
2019-06-23 11:01:55 +03:00
println('V $Version')
2019-06-22 21:20:28 +03:00
return
}
if '-h' in args || '--help' in args || 'help' in args {
println(HelpText)
2019-06-23 03:40:36 +03:00
return
2019-06-22 21:20:28 +03:00
}
2019-06-24 18:42:44 +03:00
if 'translate' in args {
2019-08-17 22:19:37 +03:00
println('Translating C to V will be available in V 0.3')
return
}
2019-07-31 05:40:38 +03:00
if 'up' in args {
2019-08-17 22:19:37 +03:00
update_v()
return
}
2019-08-01 02:34:28 +03:00
if 'get' in args {
2019-08-17 22:19:37 +03:00
println('use `v install` to install modules from vpm.vlang.io')
return
}
2019-08-27 19:35:48 +03:00
if 'symlink' in args {
create_symlink()
return
}
2019-08-16 09:58:27 +03:00
if args.join(' ').contains(' test v') {
2019-08-17 22:19:37 +03:00
test_v()
return
}
2019-08-01 02:34:28 +03:00
if 'install' in args {
if args.len < 3 {
println('usage: v install [module] [module] [...]')
2019-08-17 22:19:37 +03:00
return
}
names := args.slice(2, args.len)
vexec := os.executable()
vroot := os.dir(vexec)
vget := '$vroot/tools/vget'
2019-08-10 11:14:49 +03:00
if true {
2019-08-17 22:19:37 +03:00
//println('Building vget...')
os.chdir(vroot + '/tools')
vgetcompilation := os.exec('$vexec -o $vget vget.v') or {
2019-08-29 03:30:17 +03:00
cerror(err)
return
}
if vgetcompilation.exit_code != 0 {
2019-08-29 03:30:17 +03:00
cerror( vgetcompilation.output )
return
}
2019-08-10 11:14:49 +03:00
}
vgetresult := os.exec('$vget ' + names.join(' ')) or {
2019-08-29 03:30:17 +03:00
cerror(err)
return
}
if vgetresult.exit_code != 0 {
2019-08-29 03:30:17 +03:00
cerror( vgetresult.output )
return
}
return
2019-08-17 22:19:37 +03:00
}
// TODO quit if the compiler is too old
// u := os.file_last_mod_unix('v')
2019-06-22 23:00:38 +03:00
// If there's no tmp path with current version yet, the user must be using a pre-built package
2019-06-22 21:20:28 +03:00
// Copy the `vlib` directory to the tmp path.
2019-08-17 22:19:37 +03:00
/*
// TODO
2019-06-22 21:20:28 +03:00
if !os.file_exists(TmpPath) && os.file_exists('vlib') {
}
2019-08-17 22:19:37 +03:00
*/
2019-06-22 21:20:28 +03:00
// Just fmt and exit
2019-08-17 22:19:37 +03:00
if 'fmt' in args {
2019-06-22 21:20:28 +03:00
file := args.last()
if !os.file_exists(file) {
println('"$file" does not exist')
exit(1)
2019-06-22 21:20:28 +03:00
}
if !file.ends_with('.v') {
println('v fmt can only be used on .v files')
exit(1)
2019-06-22 21:20:28 +03:00
}
2019-06-23 11:01:55 +03:00
println('vfmt is temporarily disabled')
2019-06-22 21:20:28 +03:00
return
}
2019-08-17 22:19:37 +03:00
// v get sqlite
if 'get' in args {
// Create the modules directory if it's not there.
if !os.file_exists(ModPath) {
2019-07-16 18:42:04 +03:00
os.mkdir(ModPath)
2019-08-17 22:19:37 +03:00
}
}
// No args? REPL
if args.len < 2 || (args.len == 2 && args[1] == '-') {
2019-06-22 21:20:28 +03:00
run_repl()
return
}
// Construct the V object from command line arguments
mut v := new_v(args)
if v.pref.is_verbose {
2019-06-22 21:20:28 +03:00
println(args)
}
// Generate the docs and exit
2019-08-17 22:19:37 +03:00
if 'doc' in args {
// v.gen_doc_html_for_module(args.last())
exit(0)
2019-06-22 21:20:28 +03:00
}
2019-08-17 22:19:37 +03:00
if 'run' in args {
2019-08-09 23:37:31 +03:00
// always recompile for now, too error prone to skip recompilation otherwise
// for example for -repl usage, especially when piping lines to v
2019-08-17 22:19:37 +03:00
v.compile()
v.run_compiled_executable_and_exit()
}
2019-08-17 22:19:37 +03:00
v.compile()
2019-08-17 22:19:37 +03:00
if v.pref.is_test {
v.run_compiled_executable_and_exit()
}
2019-08-17 22:19:37 +03:00
2019-06-22 21:20:28 +03:00
}
fn (v mut V) compile() {
// Emily: Stop people on linux from being able to build with msvc
if os.user_os() != 'windows' && v.os == .msvc {
2019-08-29 03:30:17 +03:00
cerror('Cannot build with msvc on ${os.user_os()}')
}
mut cgen := v.cgen
2019-06-22 21:20:28 +03:00
cgen.genln('// Generated by V')
// Add builtin parsers
for i, file in v.files {
// v.parsers << v.new_parser(file)
}
2019-08-01 02:34:28 +03:00
v.add_v_files_to_compile()
if v.pref.is_verbose {
2019-06-22 21:20:28 +03:00
println('all .v files:')
println(v.files)
2019-06-22 21:20:28 +03:00
}
// First pass (declarations)
for file in v.files {
mut p := v.new_parser(file)
p.parse(.decl)
2019-06-22 21:20:28 +03:00
}
// Main pass
2019-07-29 19:21:36 +03:00
cgen.pass = Pass.main
2019-08-16 08:50:36 +03:00
if v.pref.is_debug {
cgen.genln('#define VDEBUG (1) ')
}
2019-08-23 03:10:37 +03:00
cgen.genln(CommonCHeaders)
v.generate_hotcode_reloading_declarations()
2019-08-23 03:10:37 +03:00
imports_json := v.table.imports.contains('json')
2019-06-22 21:20:28 +03:00
// TODO remove global UI hack
if v.os == .mac && ((v.pref.build_mode == .embed_vlib && v.table.imports.contains('ui')) ||
(v.pref.build_mode == .build && v.dir.contains('/ui'))) {
2019-06-22 21:20:28 +03:00
cgen.genln('id defaultFont = 0; // main.v')
}
// We need the cjson header for all the json decoding user will do in default mode
if v.pref.build_mode == .default_mode {
2019-06-22 21:20:28 +03:00
if imports_json {
2019-06-23 10:03:52 +03:00
cgen.genln('#include "cJSON.h"')
2019-06-22 21:20:28 +03:00
}
}
if v.pref.build_mode == .embed_vlib || v.pref.build_mode == .default_mode {
2019-06-22 21:20:28 +03:00
// If we declare these for all modes, then when running `v a.v` we'll get
// `/usr/bin/ld: multiple definition of 'total_m'`
// TODO
//cgen.genln('i64 total_m = 0; // For counting total RAM allocated')
2019-06-22 21:20:28 +03:00
cgen.genln('int g_test_ok = 1; ')
if v.table.imports.contains('json') {
2019-08-17 22:19:37 +03:00
cgen.genln('
2019-06-22 21:20:28 +03:00
#define js_get(object, key) cJSON_GetObjectItemCaseSensitive((object), (key))
')
}
}
if os.args.contains('-debug_alloc') {
cgen.genln('#define DEBUG_ALLOC 1')
}
cgen.genln('/*================================== FNS =================================*/')
cgen.genln('this line will be replaced with definitions')
defs_pos := cgen.lines.len - 1
for file in v.files {
mut p := v.new_parser(file)
p.parse(.main)
2019-06-22 21:20:28 +03:00
// p.g.gen_x64()
// Format all files (don't format automatically generated vlib headers)
if !v.pref.nofmt && !file.contains('/vlib/') {
2019-06-22 21:20:28 +03:00
// new vfmt is not ready yet
}
}
v.log('Done parsing.')
2019-06-22 21:20:28 +03:00
// Write everything
mut d := strings.new_builder(10000)// Avoid unnecessary allocations
2019-06-22 21:20:28 +03:00
d.writeln(cgen.includes.join_lines())
d.writeln(cgen.typedefs.join_lines())
2019-08-28 17:35:44 +03:00
d.writeln(v.c_type_definitions())
2019-06-22 21:20:28 +03:00
d.writeln('\nstring _STR(const char*, ...);\n')
d.writeln('\nstring _STR_TMP(const char*, ...);\n')
d.writeln(cgen.fns.join_lines())
d.writeln(cgen.consts.join_lines())
d.writeln(cgen.thread_args.join_lines())
if v.pref.is_prof {
2019-06-22 21:20:28 +03:00
d.writeln('; // Prof counters:')
d.writeln(v.prof_counters())
2019-06-22 21:20:28 +03:00
}
dd := d.str()
2019-08-31 02:35:05 +03:00
cgen.lines[defs_pos] = dd// TODO `def.str()` doesn't compile
2019-08-23 03:10:37 +03:00
v.generate_main()
2019-08-23 03:10:37 +03:00
v.generate_hotcode_reloading_code()
2019-08-23 03:10:37 +03:00
cgen.save()
if v.pref.is_verbose {
v.log('flags=')
println(v.table.flags)
}
v.cc()
}
fn (v mut V) generate_main() {
mut cgen := v.cgen
2019-08-23 03:10:37 +03:00
// if v.build_mode in [.default, .embed_vlib] {
if v.pref.build_mode == .default_mode || v.pref.build_mode == .embed_vlib {
2019-08-17 22:19:37 +03:00
mut consts_init_body := cgen.consts_init.join_lines()
for imp in v.table.imports {
if imp == 'http' {
2019-08-17 22:19:37 +03:00
consts_init_body += '\n http__init_module();'
}
}
2019-06-22 21:20:28 +03:00
// vlib can't have `init_consts()`
2019-08-17 22:19:37 +03:00
cgen.genln('void init_consts() {
#ifdef _WIN32
#ifndef _BOOTSTRAP_NO_UNICODE_STREAM
_setmode(_fileno(stdout), _O_U8TEXT);
2019-08-17 22:19:37 +03:00
SetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE), ENABLE_PROCESSED_OUTPUT | 0x0004);
// ENABLE_VIRTUAL_TERMINAL_PROCESSING
#endif
#endif
g_str_buf=malloc(1000);
2019-08-17 22:19:37 +03:00
$consts_init_body
}')
2019-06-22 21:20:28 +03:00
// _STR function can't be defined in vlib
cgen.genln('
string _STR(const char *fmt, ...) {
va_list argptr;
va_start(argptr, fmt);
2019-08-17 22:19:37 +03:00
size_t len = vsnprintf(0, 0, fmt, argptr) + 1;
2019-06-22 21:20:28 +03:00
va_end(argptr);
2019-08-17 22:19:37 +03:00
byte* buf = malloc(len);
2019-06-22 21:20:28 +03:00
va_start(argptr, fmt);
vsprintf((char *)buf, fmt, argptr);
2019-06-22 21:20:28 +03:00
va_end(argptr);
2019-08-17 22:19:37 +03:00
#ifdef DEBUG_ALLOC
puts("_STR:");
puts(buf);
#endif
2019-06-22 21:20:28 +03:00
return tos2(buf);
}
string _STR_TMP(const char *fmt, ...) {
va_list argptr;
va_start(argptr, fmt);
//size_t len = vsnprintf(0, 0, fmt, argptr) + 1;
2019-06-22 21:20:28 +03:00
va_end(argptr);
va_start(argptr, fmt);
vsprintf((char *)g_str_buf, fmt, argptr);
2019-06-22 21:20:28 +03:00
va_end(argptr);
2019-08-17 22:19:37 +03:00
#ifdef DEBUG_ALLOC
//puts("_STR_TMP:");
//puts(g_str_buf);
#endif
2019-06-22 21:20:28 +03:00
return tos2(g_str_buf);
}
')
}
2019-06-22 21:20:28 +03:00
// Make sure the main function exists
// Obviously we don't need it in libraries
if v.pref.build_mode != .build {
if !v.table.main_exists() && !v.pref.is_test {
2019-06-22 21:20:28 +03:00
// It can be skipped in single file programs
if v.pref.is_script {
//println('Generating main()...')
cgen.genln('int main() { init_consts();')
cgen.genln('$cgen.fn_main;')
cgen.genln('return 0; }')
2019-06-22 21:20:28 +03:00
}
else {
println('panic: function `main` is undeclared in the main module')
2019-08-17 22:19:37 +03:00
exit(1)
2019-06-22 21:20:28 +03:00
}
}
// Generate `main` which calls every single test function
else if v.pref.is_test {
cgen.genln('int main() { init_consts();')
for _, f in v.table.fns {
if f.name.starts_with('test_') {
cgen.genln('$f.name();')
2019-06-22 21:20:28 +03:00
}
}
cgen.genln('return g_test_ok == 0; }')
}
}
}
fn final_target_out_name(out_name string) string {
mut cmd := if out_name.starts_with('/') {
out_name
}
else {
'./' + out_name
}
$if windows {
cmd = out_name
cmd = cmd.replace('/', '\\')
2019-08-09 23:37:31 +03:00
cmd += '.exe'
}
return cmd
}
fn (v V) run_compiled_executable_and_exit() {
if v.pref.is_verbose {
2019-08-17 22:19:37 +03:00
println('============ running $v.out_name ============')
}
2019-08-09 23:37:31 +03:00
mut cmd := final_target_out_name(v.out_name).replace('.exe','')
if os.args.len > 3 {
cmd += ' ' + os.args.right(3).join(' ')
}
if v.pref.is_test {
ret := os.system(cmd)
2019-06-22 21:20:28 +03:00
if ret != 0 {
exit(1)
2019-06-22 21:20:28 +03:00
}
2019-08-17 22:19:37 +03:00
}
if v.pref.is_run {
ret := os.system(cmd)
2019-08-17 22:19:37 +03:00
// TODO: make the runner wrapping as transparent as possible
// (i.e. use execve when implemented). For now though, the runner
// just returns the same exit code as the child process
// (see man system, man 2 waitpid: C macro WEXITSTATUS section)
2019-08-17 22:19:37 +03:00
exit( ret >> 8 )
2019-06-22 21:20:28 +03:00
}
exit(0)
2019-06-22 21:20:28 +03:00
}
fn (v &V) v_files_from_dir(dir string) []string {
2019-06-22 21:20:28 +03:00
mut res := []string
if !os.file_exists(dir) {
2019-08-29 03:30:17 +03:00
cerror('$dir doesn\'t exist')
} else if !os.dir_exists(dir) {
2019-08-29 03:30:17 +03:00
cerror('$dir isn\'t a directory')
2019-06-22 21:20:28 +03:00
}
mut files := os.ls(dir)
if v.pref.is_verbose {
2019-06-22 21:20:28 +03:00
println('v_files_from_dir ("$dir")')
}
files.sort()
for file in files {
if !file.ends_with('.v') && !file.ends_with('.vh') {
continue
}
if file.ends_with('_test.v') {
continue
}
if file.ends_with('_win.v') && (v.os != .windows && v.os != .msvc) {
2019-06-22 21:20:28 +03:00
continue
}
2019-08-17 22:19:37 +03:00
if file.ends_with('_lin.v') && v.os != .linux {
2019-06-22 21:20:28 +03:00
continue
}
2019-08-17 22:19:37 +03:00
if file.ends_with('_mac.v') && v.os != .mac {
2019-07-15 20:19:53 +03:00
continue
2019-08-17 22:19:37 +03:00
}
if file.ends_with('_nix.v') && (v.os == .windows || v.os == .msvc) {
2019-08-17 22:19:37 +03:00
continue
}
2019-06-22 21:20:28 +03:00
res << '$dir/$file'
}
return res
}
// Parses imports, adds necessary libs, and then user files
2019-08-01 02:34:28 +03:00
fn (v mut V) add_v_files_to_compile() {
mut dir := v.dir
v.log('add_v_files($dir)')
2019-06-22 21:20:28 +03:00
// Need to store user files separately, because they have to be added after libs, but we dont know
// which libs need to be added yet
mut user_files := []string
// v volt/slack_test.v: compile all .v files to get the environment
// I need to implement user packages! TODO
is_test_with_imports := dir.ends_with('_test.v') &&
(dir.contains('/volt') || dir.contains('/c2volt'))// TODO
if is_test_with_imports {
user_files << dir
pos := dir.last_index('/')
dir = dir.left(pos) + '/'// TODO WHY IS THIS .neEDED?
2019-06-22 21:20:28 +03:00
}
if dir.ends_with('.v') {
// Just compile one file and get parent dir
user_files << dir
dir = dir.all_before('/')
}
else {
// Add files from the dir user is compiling (only .v files)
files := v.v_files_from_dir(dir)
2019-06-22 21:20:28 +03:00
for file in files {
user_files << file
}
}
if user_files.len == 0 {
println('No input .v files')
exit(1)
2019-06-22 21:20:28 +03:00
}
if v.pref.is_verbose {
v.log('user_files:')
2019-06-22 21:20:28 +03:00
println(user_files)
}
// Parse builtin imports
for file in v.files {
mut p := v.new_parser(file)
p.parse(.imports)
}
2019-06-22 21:20:28 +03:00
// Parse user imports
for file in user_files {
mut p := v.new_parser(file)
p.parse(.imports)
2019-06-22 21:20:28 +03:00
}
// Parse lib imports
2019-08-17 22:19:37 +03:00
/*
if v.pref.build_mode == .default_mode {
2019-07-28 04:25:33 +03:00
// strange ( for mod in v.table.imports ) dosent loop all items
// for mod in v.table.imports {
for i := 0; i < v.table.imports.len; i++ {
mod := v.table.imports[i]
2019-07-27 00:36:22 +03:00
mod_path := v.module_path(mod)
import_path := '$ModPath/vlib/$mod_path'
vfiles := v.v_files_from_dir(import_path)
2019-07-26 19:24:40 +03:00
if vfiles.len == 0 {
2019-08-29 03:30:17 +03:00
cerror('cannot import module $mod (no .v files in "$import_path").')
2019-07-26 19:24:40 +03:00
}
2019-06-22 21:20:28 +03:00
// Add all imports referenced by these libs
for file in vfiles {
mut p := v.new_parser(file, Pass.imports)
2019-06-22 21:20:28 +03:00
p.parse()
}
}
}
else {
2019-08-17 22:19:37 +03:00
*/
2019-08-01 02:34:28 +03:00
// strange ( for mod in v.table.imports ) dosent loop all items
// for mod in v.table.imports {
for i := 0; i < v.table.imports.len; i++ {
mod := v.table.imports[i]
2019-08-17 22:19:37 +03:00
import_path := v.find_module_path(mod)
2019-08-01 02:34:28 +03:00
vfiles := v.v_files_from_dir(import_path)
if vfiles.len == 0 {
2019-08-29 03:30:17 +03:00
cerror('cannot import module $mod (no .v files in "$import_path").')
2019-08-01 02:34:28 +03:00
}
// Add all imports referenced by these libs
for file in vfiles {
mut p := v.new_parser(file)
p.parse(.imports)
2019-06-22 21:20:28 +03:00
}
}
if v.pref.is_verbose {
v.log('imports:')
println(v.table.imports)
2019-06-22 21:20:28 +03:00
}
2019-07-21 18:53:35 +03:00
// graph deps
mut dep_graph := new_mod_dep_graph()
dep_graph.from_import_tables(v.table.file_imports)
2019-07-21 18:53:35 +03:00
deps_resolved := dep_graph.resolve()
if !deps_resolved.acyclic {
deps_resolved.display()
2019-08-29 03:30:17 +03:00
cerror('Import cycle detected.')
2019-07-21 18:53:35 +03:00
}
// add imports in correct order
for mod in deps_resolved.imports() {
2019-08-17 22:19:37 +03:00
// Building this module? Skip. TODO it's a hack.
2019-08-01 02:34:28 +03:00
if mod == v.mod {
2019-08-17 22:19:37 +03:00
continue
}
mod_path := v.find_module_path(mod)
2019-07-21 18:53:35 +03:00
// If we are in default mode, we don't parse vlib .v files, but header .vh files in
// TmpPath/vlib
// These were generated by vfmt
2019-08-17 22:19:37 +03:00
/*
2019-07-21 18:53:35 +03:00
if v.pref.build_mode == .default_mode || v.pref.build_mode == .build {
module_path = '$ModPath/vlib/$mod_p'
}
2019-08-17 22:19:37 +03:00
*/
vfiles := v.v_files_from_dir(mod_path)
2019-07-21 18:53:35 +03:00
for file in vfiles {
if !file in v.files {
v.files << file
2019-07-18 20:25:46 +03:00
}
2019-07-02 22:55:57 +03:00
}
2019-07-21 18:53:35 +03:00
}
2019-08-01 02:34:28 +03:00
// add remaining files (not modules)
for fit in v.table.file_imports {
2019-08-17 22:19:37 +03:00
//println('fit $fit.file_path')
2019-07-18 20:25:46 +03:00
if !fit.file_path in v.files {
v.files << fit.file_path
2019-06-22 21:20:28 +03:00
}
}
}
fn get_arg(joined_args, arg, def string) string {
return get_all_after(joined_args, '-$arg', def)
}
fn get_all_after(joined_args, arg, def string) string {
key := '$arg '
2019-06-22 21:20:28 +03:00
mut pos := joined_args.index(key)
if pos == -1 {
return def
}
pos += key.len
mut space := joined_args.index_after(' ', pos)
if space == -1 {
space = joined_args.len
}
res := joined_args.substr(pos, space)
// println('get_arg($arg) = "$res"')
return res
}
fn (v &V) module_path(mod string) string {
// submodule support
if mod.contains('.') {
//return mod.replace('.', path_sep)
return mod.replace('.', '/')
}
return mod
}
fn (v &V) log(s string) {
if !v.pref.is_verbose {
2019-06-22 21:20:28 +03:00
return
}
println(s)
}
2019-09-01 22:51:16 +03:00
fn new_v(args[]string) &V {
joined_args := args.join(' ')
target_os := get_arg(joined_args, 'os', '')
mut out_name := get_arg(joined_args, 'o', 'a.out')
2019-08-28 17:35:44 +03:00
2019-06-22 21:20:28 +03:00
mut dir := args.last()
2019-06-26 15:13:02 +03:00
if args.contains('run') {
dir = get_all_after(joined_args, 'run', '')
2019-06-26 15:13:02 +03:00
}
2019-06-22 21:20:28 +03:00
if args.len < 2 {
dir = ''
}
// println('new compiler "$dir"')
2019-06-22 21:20:28 +03:00
// build mode
mut build_mode := BuildMode.default_mode
2019-08-17 22:19:37 +03:00
mut mod := ''
2019-08-01 02:34:28 +03:00
//if args.contains('-lib') {
2019-08-17 22:19:37 +03:00
if joined_args.contains('build module ') {
build_mode = .build
2019-06-22 21:20:28 +03:00
// v -lib ~/v/os => os.o
2019-08-17 22:19:37 +03:00
mod = os.dir(dir)
2019-08-01 02:34:28 +03:00
mod = mod.all_after('/')
println('Building module "${mod}" dir="$dir"...')
//out_name = '$TmpPath/vlib/${base}.o'
2019-08-01 02:34:28 +03:00
out_name = mod + '.o'
2019-06-22 21:20:28 +03:00
// Cross compiling? Use separate dirs for each os
2019-08-17 22:19:37 +03:00
/*
2019-06-22 21:20:28 +03:00
if target_os != os.user_os() {
os.mkdir('$TmpPath/vlib/$target_os')
out_name = '$TmpPath/vlib/$target_os/${base}.o'
2019-08-17 22:19:37 +03:00
println('target_os=$target_os user_os=${os.user_os()}')
println('!Cross compiling $out_name')
2019-06-22 21:20:28 +03:00
}
2019-08-17 22:19:37 +03:00
*/
2019-06-22 21:20:28 +03:00
}
// TODO embed_vlib is temporarily the default mode. It's much slower.
else if !args.contains('-embed_vlib') {
build_mode = .embed_vlib
2019-06-22 21:20:28 +03:00
}
2019-08-17 22:19:37 +03:00
//
2019-06-22 21:20:28 +03:00
is_test := dir.ends_with('_test.v')
is_script := dir.ends_with('.v')
if is_script && !os.file_exists(dir) {
println('`$dir` does not exist')
exit(1)
2019-06-22 21:20:28 +03:00
}
// No -o provided? foo.v => foo
if out_name == 'a.out' && dir.ends_with('.v') {
out_name = dir.left(dir.len - 2)
}
// if we are in `/foo` and run `v .`, the executable should be `foo`
if dir == '.' && out_name == 'a.out' {
base := os.getwd().all_after('/')
out_name = base.trim_space()
}
mut _os := OS.mac
2019-06-22 21:20:28 +03:00
// No OS specifed? Use current system
if target_os == '' {
$if linux {
2019-08-17 22:19:37 +03:00
_os = .linux
2019-06-22 21:20:28 +03:00
}
$if mac {
_os = .mac
2019-06-22 21:20:28 +03:00
}
$if windows {
_os = .windows
2019-06-22 21:20:28 +03:00
}
2019-07-15 18:24:40 +03:00
$if freebsd {
2019-08-17 22:19:37 +03:00
_os = .freebsd
2019-07-15 18:24:40 +03:00
}
2019-07-15 21:18:05 +03:00
$if openbsd {
2019-08-17 22:19:37 +03:00
_os = .openbsd
2019-07-15 21:18:05 +03:00
}
$if netbsd {
2019-08-17 22:19:37 +03:00
_os = .netbsd
2019-07-15 21:18:05 +03:00
}
$if dragonfly {
2019-08-17 22:19:37 +03:00
_os = .dragonfly
2019-07-15 21:18:05 +03:00
}
2019-06-22 21:20:28 +03:00
}
else {
switch target_os {
case 'linux': _os = .linux
case 'windows': _os = .windows
case 'mac': _os = .mac
case 'freebsd': _os = .freebsd
case 'openbsd': _os = .openbsd
case 'netbsd': _os = .netbsd
case 'dragonfly': _os = .dragonfly
case 'msvc': _os = .msvc
2019-06-22 21:20:28 +03:00
}
}
builtins := [
'array.v',
'string.v',
'builtin.v',
'int.v',
'utf8.v',
'map.v',
'option.v',
]
// Location of all vlib files
2019-08-17 22:19:37 +03:00
vroot := os.dir(os.executable())
//println('VROOT=$vroot')
// v.exe's parent directory should contain vlib
2019-07-16 00:33:31 +03:00
if os.dir_exists(vroot) && os.dir_exists(vroot + '/vlib/builtin') {
2019-08-17 22:19:37 +03:00
2019-07-16 00:33:31 +03:00
} else {
2019-08-17 22:19:37 +03:00
println('vlib not found. It should be next to the V executable. ')
println('Go to https://vlang.io to install V.')
2019-08-17 22:19:37 +03:00
exit(1)
}
mut out_name_c := os.realpath( out_name ) + '.tmp.c'
2019-06-22 21:20:28 +03:00
mut files := []string
// Add builtin files
if !out_name.contains('builtin.o') {
for builtin in builtins {
2019-07-16 00:33:31 +03:00
mut f := '$vroot/vlib/builtin/$builtin'
2019-06-22 21:20:28 +03:00
// In default mode we use precompiled vlib.o, point to .vh files with signatures
if build_mode == .default_mode || build_mode == .build {
//f = '$TmpPath/vlib/builtin/${builtin}h'
2019-06-22 21:20:28 +03:00
}
files << f
}
}
mut cflags := ''
for ci, cv in args {
if cv == '-cflags' {
cflags += args[ci+1] + ' '
}
}
obfuscate := args.contains('-obf')
pref := &Preferences {
2019-06-22 21:20:28 +03:00
is_test: is_test
is_script: is_script
is_so: args.contains('-shared')
is_prod: args.contains('-prod')
is_verbose: args.contains('-verbose')
2019-07-26 17:45:16 +03:00
is_debuggable: args.contains('-g') // -debuggable implys debug
is_debug: args.contains('-debug') || args.contains('-g')
obfuscate: obfuscate
2019-06-22 21:20:28 +03:00
is_prof: args.contains('-prof')
is_live: args.contains('-live')
sanitize: args.contains('-sanitize')
nofmt: args.contains('-nofmt')
show_c_cmd: args.contains('-show_c_cmd')
translated: args.contains('translated')
is_run: args.contains('run')
is_repl: args.contains('-repl')
build_mode: build_mode
cflags: cflags
ccompiler: find_c_compiler()
2019-08-17 22:19:37 +03:00
}
2019-07-08 04:42:36 +03:00
if pref.is_verbose || pref.is_debug {
println('C compiler=$pref.ccompiler')
}
if pref.is_so {
out_name_c = out_name.all_after('/') + '_shared_lib.c'
}
2019-08-31 16:38:13 +03:00
return &V{
os: _os
out_name: out_name
files: files
dir: dir
2019-08-17 22:19:37 +03:00
lang_dir: vroot
table: new_table(obfuscate)
out_name_c: out_name_c
cgen: new_cgen(out_name_c)
2019-08-17 22:19:37 +03:00
vroot: vroot
pref: pref
2019-08-17 22:19:37 +03:00
mod: mod
2019-06-22 21:20:28 +03:00
}
}
const (
HelpText = '
Usage: v [options] [file | directory]
Options:
- Read from stdin (Default; Interactive mode if in a tty)
-h, help Display this information.
-v, version Display compiler version.
-lib Generate object file.
-prod Build an optimized executable.
-o <file> Place output into <file>.
-obf Obfuscate the resulting binary.
2019-08-17 22:19:37 +03:00
-show_c_cmd Print the full C compilation command and how much time it took.
-debug Leave a C file for debugging in .program.c.
-live Enable hot code reloading (required by functions marked with [live]).
fmt Run vfmt to format the source code.
up Update V.
2019-07-21 14:51:52 +03:00
run Build and execute a V program. You can add arguments after the file name.
Files:
<file>_test.v Test file.
2019-06-22 21:20:28 +03:00
'
)
2019-08-17 22:19:37 +03:00
/*
- To disable automatic formatting:
2019-06-22 21:20:28 +03:00
v -nofmt file.v
- To build a program with an embedded vlib (use this if you do not have prebuilt vlib libraries or if you
2019-08-17 22:19:37 +03:00
are working on vlib)
v -embed_vlib file.v
2019-06-22 21:20:28 +03:00
*/
fn env_vflags_and_os_args() []string {
mut args := []string
vflags := os.getenv('VFLAGS')
if '' != vflags {
args << os.args[0]
args << vflags.split(' ')
if os.args.len > 1 {
args << os.args.right(1)
}
}else{
args << os.args
}
return args
}
2019-07-31 05:40:38 +03:00
fn update_v() {
2019-08-17 22:19:37 +03:00
println('Updating V...')
vroot := os.dir(os.executable())
s := os.exec('git -C "$vroot" pull --rebase origin master') or {
2019-08-29 03:30:17 +03:00
cerror(err)
return
}
2019-08-17 22:19:37 +03:00
println(s.output)
$if windows {
os.mv('$vroot/v.exe', '$vroot/v_old.exe')
s2 := os.exec('$vroot/make.bat') or {
2019-08-29 03:30:17 +03:00
cerror(err)
return
}
2019-08-17 22:19:37 +03:00
println(s2.output)
} $else {
s2 := os.exec('make -C "$vroot"') or {
2019-08-29 03:30:17 +03:00
cerror(err)
return
}
2019-08-17 22:19:37 +03:00
println(s2.output)
}
}
2019-08-01 02:34:28 +03:00
2019-08-16 09:58:27 +03:00
fn test_v() {
args := env_vflags_and_os_args()
vexe := args[0]
// Emily: pass args from the invocation to the test
// e.g. `v -g -os msvc test v` -> `$vexe -g -os msvc $file`
mut joined_args := env_vflags_and_os_args().right(1).join(' ')
joined_args = joined_args.left(joined_args.last_index('test'))
println('$joined_args')
2019-09-01 14:14:39 +03:00
mut failed := false
2019-08-17 22:19:37 +03:00
test_files := os.walk_ext('.', '_test.v')
for dot_relative_file in test_files {
relative_file := dot_relative_file.replace('./', '')
file := os.realpath( relative_file )
tmpcfilepath := file.replace('_test.v', '_test.tmp.c')
2019-08-24 03:08:30 +03:00
print(relative_file + ' ')
r := os.exec('$vexe $joined_args -debug $file') or {
2019-09-01 14:14:39 +03:00
failed = true
println('FAIL')
continue
}
if r.exit_code != 0 {
2019-09-01 14:14:39 +03:00
println('FAIL `$file` (\n$r.output\n)')
failed = true
2019-08-17 22:19:37 +03:00
} else {
println('OK')
}
os.rm( tmpcfilepath )
2019-08-17 22:19:37 +03:00
}
println('\nBuilding examples...')
examples := os.walk_ext('examples', '.v')
for relative_file in examples {
file := os.realpath( relative_file )
tmpcfilepath := file.replace('.v', '.tmp.c')
print(relative_file + ' ')
r := os.exec('$vexe $joined_args -debug $file') or {
2019-09-01 14:14:39 +03:00
failed = true
println('FAIL')
continue
}
if r.exit_code != 0 {
2019-09-01 14:14:39 +03:00
println('FAIL `$file` (\n$r.output\n)')
failed = true
2019-08-17 22:19:37 +03:00
} else {
println('OK')
}
2019-08-30 13:01:20 +03:00
os.rm(tmpcfilepath)
2019-08-17 22:19:37 +03:00
}
2019-09-01 14:14:39 +03:00
if failed {
exit(1)
}
2019-08-17 22:19:37 +03:00
}
2019-08-16 09:58:27 +03:00
2019-08-27 19:35:48 +03:00
fn create_symlink() {
vexe := os.executable()
link_path := '/usr/local/bin/v'
2019-08-31 16:38:13 +03:00
ret := os.system('ln -sf $vexe $link_path')
if ret == 0 {
println('symlink "$link_path" has been created')
} else {
println('failed to create symlink "$link_path", '+
'make sure you run with sudo')
}
2019-08-27 19:35:48 +03:00
}
2019-08-29 03:30:17 +03:00
pub fn cerror(s string) {
println('V error: $s')
os.flush_stdout()
exit(1)
}