v/vlib/v
div72 9d02ca51d1
checker: relax naming requirements for translated code (#10619)
2021-06-30 14:47:13 +03:00
..
ast checker: check for empty branches in match expressions (#10593) 2021-06-28 19:32:28 +03:00
builder v.builder: use a github repo for ~/.vmodules/linuxroot/ folder, to ease its updating 2021-06-29 13:05:43 +03:00
cflag all: improve unused variable warning (fix `x = 1`, `x += 1` etc) 2021-04-23 13:33:48 +03:00
checker checker: relax naming requirements for translated code (#10619) 2021-06-30 14:47:13 +03:00
depgraph v.depgraph: fix ci/misc-tooling `./v -autofree -o v2 cmd/v` task 2021-05-20 07:24:13 +03:00
doc ci: fix `v build-tools` 2021-05-11 11:08:46 +03:00
embed_file ci: fix byteptr cast in embed_file.v 2021-04-05 07:27:26 +03:00
errors v: support compiler notices. Use them for `[deprecated_after: '2021-05-01']` tags 2021-03-22 19:59:00 +02:00
eval all: a massive merge of ast and table modules 2021-04-02 01:57:09 +03:00
fmt v.fmt: keep selective type imports used for casting (#10597) 2021-06-28 13:21:26 +03:00
gen gen: cleanup `Gen.array init` (#10613) 2021-06-30 09:45:18 +03:00
live examples: fix compilation with -prod 2021-04-23 14:48:07 +03:00
markused gc: extend optimized mode to channel buffers (#10443) 2021-06-14 18:12:47 +03:00
parser v.parser: rename pratt.v to expr.v (#10566) 2021-06-28 19:35:06 +03:00
pkgconfig builtin,v.pkgconfig: use brew's libgc on macos 2021-03-25 07:28:30 +02:00
pref gc: use optimized mode by default (#10466) 2021-06-15 15:43:00 +03:00
preludes v: replace execuast => executable 2021-05-31 09:39:18 +03:00
scanner vlib: use `malloc_noscan()` where possible (#10465) 2021-06-15 14:47:11 +03:00
tests checker, cgen: fix aliased array methods (#10603) 2021-06-29 12:14:37 +03:00
token all: new function `isreftype(T)` to know if `T` contains pointers (#10438) 2021-06-13 06:26:13 +03:00
util tests: add cmd/tools/vdoc/tests/vdoc_file_test.v, extract a `v.util.diff` module, cleanup 2021-06-22 18:52:34 +03:00
vcache v.vcache: another workaround for a tcc arm64 runtime bug 2021-04-07 19:13:05 +03:00
vet v vet: give an error for trailing whitespace (#9574) 2021-04-09 13:22:14 +03:00
vmod v: support dump(expr) (#9160) 2021-03-06 18:09:28 +01:00
README.md all: a massive merge of ast and table modules 2021-04-02 01:57:09 +03:00
TEMPLATES.md tools: improve `v check-md` by checking for broken TOC headline links (#10417) 2021-06-14 13:12:02 +03:00
compiler_errors_test.v checker: bugfix for `__global ( cpu_get_id fn () u64 ) ... cpu_get_id()` 2021-06-26 01:23:50 +03:00

README.md

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 seperators 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)