v/vlib/v
joe-conigliaro b578e60dd5
tests: add test for fix #cf7b45b
2020-12-04 15:43:28 +11:00
..
ast scope: remove redundant name arg from register() (#7077) 2020-12-02 14:40:25 +01:00
builder error on unknown generic struct init. closes #7085 2020-12-02 20:53:40 +11:00
cflag v: add VCACHE support for thirdparty object files and for `v build-module` 2020-10-25 03:09:07 +03:00
checker checker: correctly check arrays with element that is an alias. fixes #6735 2020-12-04 14:26:25 +11:00
depgraph fmt: fix multiple things and format most of the compiler (#6631) 2020-10-15 22:12:59 +02:00
doc v: support multiple paths in VMODULES env variable (#7048) 2020-11-30 18:31:37 +01:00
errors fmt: fix multiple things and format most of the compiler (#6631) 2020-10-15 22:12:59 +02:00
eval all: refactor UnionSumType to SumType (#6944) 2020-11-25 13:09:40 +02:00
fmt fmt: smarter wrap of orm lines (#7070) 2020-12-02 04:06:20 +01:00
gen map: add 3 DenseArray methods for bootstrapping (#7113) 2020-12-03 21:12:53 +02:00
parser vls,parser: fix an eof error in parsing invalid const declarations (#7115) 2020-12-03 21:11:43 +02:00
pkgconfig pkgconfig: improve and fix the parser; move to v.pkgconfig (#6695) 2020-10-29 11:57:23 +02:00
pref pref: vfmt 2020-12-01 04:16:36 +01:00
scanner scanner: do not warn for \x07 in strings 2020-12-03 14:11:32 +02:00
table dont allow method on non-local types & no mod for arrays. closes #6971 2020-11-30 11:43:22 +11:00
tests tests: add test for fix #cf7b45b 2020-12-04 15:43:28 +11:00
token token: remove old keyword "embed" 2020-11-30 03:11:40 +01:00
util V 0.1.30 2020-11-28 04:43:11 +01:00
vcache checker: add check against `fn test_opt() ?{}` 2020-11-20 15:12:53 +02:00
vet fmt: fix multiple things and format most of the compiler (#6631) 2020-10-15 22:12:59 +02:00
vmod fmt: fix multiple things and format most of the compiler (#6631) 2020-10-15 22:12:59 +02:00
README.md doc: detailed documentation of the compiler pipeline (#7043) 2020-12-01 03:58:39 +01:00
compiler_errors_test.v tests: restore skipped return_missing_comp_if.vv and return_missing_comp_if_nested.vv 2020-11-16 10:07:53 +02: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.table
table := table.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
res := gen.cgen(parsed_files, table, &pref)