1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/v
2023-01-06 09:33:11 +03:00
..
ast checker: require unsafe for Struct(voidptr) casts 2023-01-06 09:28:11 +03:00
builder builder: show a hint about v ., on unknown errors, suggesting that the user tried to compile a single .v file from a multi file project (#16878) 2023-01-05 07:45:23 +02:00
callgraph vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
cflag vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
checker checker, cgen: allow iterating over optional array fields (#16858) 2023-01-06 09:33:11 +03:00
depgraph vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
doc vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
dotgraph vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
embed_file checker: require unsafe for Struct(voidptr) casts 2023-01-06 09:28:11 +03:00
errors
eval vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
fmt vfmt: fix alignment of value formatting for "x := {.: 1, : 2}" 2022-12-28 18:06:32 +02:00
gen checker, cgen: allow iterating over optional array fields (#16858) 2023-01-06 09:33:11 +03:00
help v: move cmd/v/help/ to vlib/v/help, to simplify the interaction between module lookup & v recompilation (#16867) 2023-01-04 14:01:05 +02:00
live tests: add a watchdog thread to live_test.v to prevent it from blocking the whole CI on slow sanitized jobs 2022-11-21 12:24:54 +02:00
markused checker: require unsafe for Struct(voidptr) casts 2023-01-06 09:28:11 +03:00
mathutil all: replace generic <> with [] - part 2 (#16536) 2022-11-26 18:23:26 +02:00
parser v.token,v.parser: use p.tok.kind.precedence(), instead of p.tok.precedence(), since token.Token struct values, are much larger, than just the token.Kind enum values 2023-01-04 17:50:51 +02:00
pkgconfig v.pkgconfig: support PKG_CONFIG_PATH_DEFAULTS for overriding the default search path list too (enable easier -m32 with a custom tcc cross compiler) 2022-12-10 00:50:24 +02:00
pref pref: deprecate -error-limit in favour of the documented -message-limit option. 2022-12-15 10:37:57 +02:00
preludes tests: improve Teamcity test runner (#16817) 2022-12-31 17:26:18 +02:00
preludes_js vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
profile
scanner scanner: make Scanner.peek_token more robust (p.peek_token(-999999) will return an EOF token, instead of garbage data) 2022-11-27 12:09:43 +02:00
tests checker, cgen: allow iterating over optional array fields (#16858) 2023-01-06 09:33:11 +03:00
token v.token,v.parser: use p.tok.kind.precedence(), instead of p.tok.precedence(), since token.Token struct values, are much larger, than just the token.Kind enum values 2023-01-04 17:50:51 +02:00
trace_calls
transformer transformer: clean up expr_stmt_match_expr() (#16655) 2022-12-12 08:41:02 +02:00
util builder: show a hint about v ., on unknown errors, suggesting that the user tried to compile a single .v file from a multi file project (#16878) 2023-01-05 07:45:23 +02:00
vcache vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
vet
vmod vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
compiler_errors_test.v vfmt: change all '$expr' to '${expr}' (#16428) 2022-11-15 16:53:13 +03:00
README.md
TEMPLATES.md

Description

v is a namespace for all of the V compiler modules.

The V compiler modules can be used by V programs that want to process V source code in different ways, in fact, that is how various V tools are implemented: v fmt, v doc, v ast, vls, as well as the V compiler itself.

Compiler pipeline

A simple high level explanation how the compiler pipeline (parser -> checker -> generator) works.

Reading files

Getting builtin files

To load all builtin files, a preference Preferences.lookup_path for the path where to look for exists. See Builder.get_builtin_files as example. If the file is a .vsh file and the backend is C, vlib/os will also be loaded as builtin.

Getting project files

Either there is a specific file: my_file.v or a directory containing V files. In the last case it scans that directory for all files. See Builder.v_files_from_dir as the helper method. This list of files needs to be filtered so that only *.v files exist.

Skips the following file types:

  • *_test.v
  • either *.c.v or *.c.js depending on the backend
  • all files that doesn't end with .v
  • Files that are not defined in Preferences.compile_defines or Preferences.compile_defines_all if any file is defined.

Parsing files

To parse something a new template is created as the first step:

import v.ast

table := ast.new_table()

a new preference is created:

import v.pref

pref := &pref.Preferences{}

and a new scope is created:

import v.ast

scope := ast.Scope{
	parent: 0
}

after that, you can parse your files.

Parse text

If you want to parse only text which isn't saved on the disk you can use this function.

import v.parser

code := ''
// table, pref and scope needs to be passed as reference
parsed_file := parser.parse_text(code, table, .parse_comments, &pref, &scope)

Parse a single file

For parsing files on disk, a path needs to be provided. The paths are collected one step earlier.

import v.parser

path := ''
// table, pref and scope needs to be passed as reference
parsed_file := parser.parse_file(path, table, .parse_comments, &pref, &scope)

Parse a set of files

If you have a batch of paths available which should be parsed, there is also a function which does all the work.

import v.parser

paths := ['']
// table, pref and scope needs to be passed as reference
parsed_files := parser.parse_files(paths, table, &pref, &scope)

Parse imports

A file often contains imports. These imports might need to be parsed as well. The builder contains a method which does this: Builder.parse_imports.

If the module which is imported isn't parsed already, you have to collect it relatively from the main file. For this the ast.File contains a list of imports. Those imports needs to be found on disk. . is just replaced with separators in the relative location of the main file. Then all files from that directory are collected and parsed again like the previous steps explained.

Checking AST

A new checker is created:

import v.checker

mut checker := checker.new_checker(table, &pref)

After checking your files in checker.errors and checker.warnings you can see the results.

Check ast.File

checker.check(parsed_file)

Check a list of ast.File

checker.check_files(parsed_files)

Generate target from AST

Generating C code works just as this:

import v.gen.c

res := c.gen(parsed_files, table, &pref)