binary_artifact.yml: chmod 755 thirdparty/tcc/tcc.exe too

good work

.ctags.d/v.ctags

@@ -0,0 +1,44 @@
+## TODO: support more precise struct/const/enum fields
+
+--langdef=V
+--map-V=+.v
+--map-V=+.vv
+--map-V=+.vsh
+--kinddef-V=m,imodule,imported modules
+--kinddef-V=M,module,modules
+--kinddef-V=C,cfunction,cfunctions
+--kinddef-V=f,function,functions
+--kinddef-V=h,method,functions
+--kinddef-V=c,const,constants
+--kinddef-V=v,variable,variables
+--kinddef-V=s,struct,structs
+--kinddef-V=e,enum,enums
+--kinddef-V=i,interface,interfaces
+--kinddef-V=S,sfield,struct field
+--kinddef-V=E,efield,enum field
+--_roledef-V.m=imported,imported module
+--_roledef-V.M=declared,module declaration
+--regex-V=/^module[[:blank:]]+([0-9a-zA-Z]+)[[:blank:]]*$/\1/M/{_role=declared}{scope=push}
+--regex-V=/^import[[:blank:]]+(([0-9a-zA-Z]+)?|.*\.([a-zA-Z_][0-9a-zA-Z]+))[[:blank:]]*$/\2\3/m/{_role=imported}{scope=ref}
+--regex-V=/^[[:blank:]]*fn[[:blank:]]+C\.([a-zA-Z_][0-9a-zA-Z_]*)\(/C.\1/C/
+--regex-V=/^(pub)?[[:blank:]]*fn[[:blank:]]+([a-zA-Z_][0-9a-zA-Z_]*)\(/\2/f/
+--regex-V=/^(pub)?[[:blank:]]*fn[[:blank:]]+\(.*\)[[:blank:]]*([a-zA-Z_][0-9a-zA-Z_]*)\(/\2/h/
+--regex-V=/^(pub)?[[:blank:]]*struct[[:blank:]]+([a-zA-Z_][0-9a-zA-Z_]*)[[:blank:]]*\{/\2/s/{scope=push}
+--regex-V=/^(pub)?[[:blank:]]*enum[[:blank:]]+([a-zA-Z_][0-9a-zA-Z_]*)[[:blank:]]*\{/\2/e/{scope=push}
+--regex-V=/^(pub)?[[:blank:]]*interface[[:blank:]]+([a-zA-Z_][0-9a-zA-Z_]*)[[:blank:]]*\{/\2/i/{scope=push}
+--regex-V=/^[[:blank:]]*([a-zA-Z_][0-9a-zA-Z_]+)[[:blank:]]*(,)?[[:blank:]]*(\/\/.*)?$/\1/E/{scope=ref}
+--regex-V=/^[[:blank:]]*([a-zA-Z_][0-9a-zA-Z_]+)[[:blank:]]+\??\&?(\[[0-9]*\])?([a-zA-Z_][0-9a-zA-Z_.]+)[[:blank:]]*(\/\/.*)?$/\1/S/{scope=ref}
+--regex-V=/^[[:blank:]]*\}[[:blank:]]*$//{scope=pop}{placeholder}
+
+## Variables:
+--regex-V=/^[[:blank:]]*(mut[[:blank:]]+)?([a-zA-Z_][0-9a-zA-Z_]+)[[:blank:]]*:=/\2/v/
+
+## Consts:
+--regex-V=/^(pub)?[[:blank:]]*const[[:blank:]]+\([[:blank:]]*/const/c/{scope=push}
+##NB: the next variable regexp should work only inside const ( ), but currently works for ordinary assignments too:
+--regex-V=/^[[:blank:]]*([a-zA-Z_][0-9a-zA-Z_]+)[[:blank:]]*=/\1/v/{scope=ref}
+--regex-V=/^[[:blank:]]*\)[[:blank:]]*$//{scope=pop}{placeholder}
+
+--extras=+q
+--extras=+r
+--fields=+r

.editorconfig

@@ -0,0 +1,24 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.v]
+indent_style = tab
+indent_size = 4
+
+[*.{yml,yaml}]
+indent_style = space
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{txt,out}]
+insert_final_newline = false
+
+[Makefile]
+indent_style = tab

.gitattributes

@@ -1,2 +1,4 @@
-*.v linguist-language=Go
-website/* linguist-vendored
+*.v linguist-language=V text=auto eol=lf
+*.vv linguist-language=V text=auto eol=lf
+*.bat text=auto eol=crlf
+ Dockerfile.* linguist-language=Dockerfile

.github/FUNDING.yml

@@ -1,3 +1,4 @@
 # These are supported funding model platforms
 
 patreon: vlang
+github: [medvednikov]

.github/ISSUE_TEMPLATE/bug-report-for-v.md

@@ -1,18 +1,18 @@
 ---
 name: Bug report for V
-about: Please use the apropriate label when submitting an issue: bug/feature request/question.
+about: Please use the appropriate label when submitting an issue: bug/feature request/question.
 title: "New issue"
 labels: ''
 assignees: ''
 
 ---
 
+<!-- You can use `v doctor` to fill up the next fields -->
+
 #### V version:
 
-
 #### OS:
 
-
 #### C Compiler:
 
 

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,11 +2,15 @@
 name: Bug report
 about: Bug report
 title: ''
-labels: bug
+labels: 'Bug'
 assignees: ''
 
 ---
 
+<!-- Please make sure to run `v up` before reporting any issues as it may have already been fixed.
+     It's also advisable to update all relvant modules using `v outdated` and `v install` -->
+
+<!-- You can use `v doctor` to fill up the next fields -->
 **V version:** 
 **OS:** 
 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,7 +2,7 @@
 name: Feature request
 about: Suggest an idea for this project
 title: ''
-labels: feature request
+labels: 'Feature Request'
 assignees: ''
 
 ---

.github/PULL_REQUEST_TEMPLATE

@@ -1,15 +1,41 @@
-Please title your PR as follows: `time: fix foo bar`. Always start with the thing you are fixing, then describe the fix.
+
+
+<!--
+
+Please title your PR as follows: `time: fix foo bar`.
+Always start with the thing you are fixing, then describe the fix.
 Don't use past tense (e.g. "fixed foo bar").
 
 Explain what your PR does and why.
 
-Before submitting a PR, please run the tests with `make test`, and make sure V can still compile itself. Run this twice:
+If you are adding a new function, please document it and add tests:
 
-./v -o v
-./v -o v
+```
+// foo does foo and bar
+fn foo() {
+
+// file_test.v
+fn test_foo() {
+    assert foo() == ...
+    ...
+}
+```
+
+If you are fixing a bug, please add a test that covers it.
+
+Before submitting a PR, please:
+  A) run the tests with `v test-compiler` .
+  B) make sure, that V can still compile itself:
+```shell
+./v -o v cmd/v
+./v -o v cmd/v
+```
+See also `TESTS.md`.
 
 I try to process PRs as soon as possible. They should be handled within 24 hours.
 
 Applying labels to PRs is not needed.
 
 Thanks a lot for your contribution!
+
+-->

.github/workflows/alpine.build.sh

@@ -0,0 +1,15 @@
+#!/bin/sh -l
+
+set -e
+
+pwd
+
+uname -a
+
+make -j4
+
+./v version
+
+du -s .
+
+echo "DONE"

.github/workflows/alpine.test.sh

@@ -0,0 +1,22 @@
+#!/bin/sh -l
+
+set -e
+
+pwd
+
+uname -a
+
+du -s .
+
+ls -lat 
+
+##./v test-compiler
+
+## try running the known failing tests first to get faster feedback
+./v test vlib/builtin/string_test.v vlib/strings/builder_test.v
+
+./v test-fixed
+
+./v build-vbinaries
+
+echo "DONE"

.github/workflows/binary_artifact.yml

@@ -0,0 +1,153 @@
+name: Build binary artifacts
+
+on:
+  push:
+     tags:
+       - weekly.**
+       - 0.**
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        compiler: [gcc]
+    steps:
+    - uses: actions/checkout@v1
+    - name: Compile
+      env:
+        CC: ${{ matrix.compiler }}
+      run: make && ./v -cc $CC -o v -prod cmd/v
+    - name: Create artifact
+      uses: actions/upload-artifact@v2
+      with:
+        name: linux
+        path: |
+          .
+          !./.git
+          !./vc
+          !./v_old
+    - name: Create binary only artifact
+      uses: actions/upload-artifact@v2
+      with:
+        name: linux-binary
+        path: ./v
+
+  build-macos:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        compiler: [clang]
+    steps:
+    - uses: actions/checkout@v1
+    - name: Compile
+      env:
+        CC: ${{ matrix.compiler }}
+      run: make && ./v -cc $CC -o v -prod cmd/v
+    - name: Create artifact
+      uses: actions/upload-artifact@v2
+      with:
+        name: macos
+        path: |
+          .
+          !./.git
+          !./vc
+          !./v_old
+    - name: Create binary only artifact
+      uses: actions/upload-artifact@v2
+      with:
+        name: macos-binary
+        path: ./v
+
+  build-windows:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: msys2/setup-msys2@v2
+    - name: Compile
+      run: ./make.bat
+    - name: Create artifact
+      uses: actions/upload-artifact@v2
+      with:
+        name: windows
+        path: |
+          .
+          !./.git
+          !./vc
+          !./v_old
+    - name: Create binary only artifact
+      uses: actions/upload-artifact@v2
+      with:
+        name: windows-binary
+        path: ./v.exe
+
+  release:
+    name: Create Github Release
+    needs: [build-linux, build-windows, build-macos]
+    runs-on: ubuntu-latest
+    steps:
+    - name: Get short tag name
+      uses: jungwinter/split@v1
+      id: split
+      with:
+        msg: ${{ github.ref }}
+        seperator: /
+    - name: Create Release
+      id: create_release
+      uses: ncipollo/release-action@v1
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        tag: ${{ steps.split.outputs._2 }}
+        name: ${{ steps.split.outputs._2 }}
+        commit: ${{ github.sha }}
+        draft: false
+        prerelease: false
+
+  publish:
+    needs: [release]
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        version: [linux, macos, windows]
+    steps:
+    - uses: actions/checkout@v1
+    - name: Fetch artifacts
+      uses: actions/download-artifact@v1
+      with:
+        name: ${{ matrix.version }}
+        path: ./${{ matrix.version }}
+    - name: Build Zip Archives
+      run: |
+           mkdir -p workdir/
+           mv ${{ matrix.version }}/ workdir/v/
+           cd workdir/v/
+           chmod 755 v || true
+           chmod 755 v.exe || true
+           chmod 755 thirdparty/tcc/tcc.exe || true
+           cd ..
+           zip -r9 --symlinks ../v_${{ matrix.version }}.zip v/*
+           cd ..
+           rm -rf workdir/
+    - name: Get short tag name
+      uses: jungwinter/split@v1
+      id: split
+      with:
+        msg: ${{ github.ref }}
+        seperator: /
+    - name: Get release
+      id: get_release_info
+      uses: leahlundqvist/get-release@v1.3.1
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      with:
+        tag_name: ${{ steps.split.outputs._2 }}
+    - name: Upload Release Asset
+      id: upload-release-asset
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.get_release_info.outputs.upload_url }}
+        asset_path: ./v_${{ matrix.version }}.zip
+        asset_name: v_${{ matrix.version }}.zip
+        asset_content_type: application/zip

.github/workflows/ci.yml

@@ -0,0 +1,596 @@
+name: CI
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+
+jobs:
+  code-formatting:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 30
+    env:
+      VFLAGS: -cc tcc
+    steps:
+    - uses: actions/checkout@v2
+    - name: Environment info
+      run: echo $VFLAGS $GITHUB_SHA $GITHUB_REF
+    - name: Build local v
+      run: make -j4
+    - name: v test-cleancode
+      run: ./v -silent test-cleancode
+    - name: v test-fmt
+      run: ./v -silent test-fmt
+
+#  v-fmt:
+#    runs-on: ubuntu-18.04
+#    timeout-minutes: 30
+#    steps:
+#    - uses: actions/checkout@v2
+#    - name: getting all branch metainfo from github
+#      run: |
+#          git fetch --no-tags --prune --depth=1 origin +refs/heads/*:refs/remotes/origin/*
+#          echo "Changed files compared to origin/master are:" && git diff --name-status origin/master HEAD -- '*.v'
+#    - name: Build v (there is no need for dependencies for fmt)
+#      run: make -j4
+#    - name: Build a production cmd/tools/vfmt
+#      run: ./v -prod -d vfmt cmd/tools/vfmt.v
+#    - name: Run v fmt -diff on only the changed files. Does NOT fail for now.
+#      run: git diff --name-status origin/master HEAD -- '*.v' |grep -v '^D'|rev|cut -f1|rev| xargs ./v fmt -noerror -diff
+#    - name: Run v test-fmt
+#      run: echo "TODO" #./v test-fmt
+
+  performance-regressions:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 30
+    env:
+      VFLAGS: -cc gcc
+    steps:
+    - uses: actions/checkout@v2
+    - name: Environment info
+      run: echo $VFLAGS $GITHUB_SHA $GITHUB_REF
+    - name: Build local v
+      run: (make -j4)
+    - name: Clone & Build vmaster/v
+      run: |
+        git clone --depth=1 https://github.com/vlang/v vmaster/
+        (cd vmaster; make -j4)
+    - name: V versions
+      run: ./v version && ./vmaster/v version
+    - name: Build the repeat tool
+      run: ./v cmd/tools/repeat.v
+    - name: Repeat -o hw.c examples/hello_world.v
+      run: cmd/tools/repeat --max_time 150 --series 3 --count 15 --warmup 3 --fail_percent 10 './v -show-timings -o hw.c examples/hello_world.v' './vmaster/v -show-timings -o hw.c examples/hello_world.v'
+    - name: Repeat -o v.c cmd/v
+      run: cmd/tools/repeat --max_time 750 --series 3 --count 15 --warmup 3 --fail_percent 10 './v -show-timings -o v.c cmd/v' './vmaster/v -show-timings -o v.c cmd/v'
+
+  ubuntu-tcc:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 30
+    env:
+      VFLAGS: -cc tcc -cflags -bt10
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: |
+           sudo rm -f /etc/apt/sources.list.d/dotnetdev.list /etc/apt/sources.list.d/microsoft-prod.list; sudo apt-get update;
+           sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev valgrind
+           sudo apt-get install --quiet -y libglfw3 libglfw3-dev  libfreetype6-dev  libxi-dev libxcursor-dev libasound2-dev
+           ## sudo apt-get install --quiet -y libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev
+    - name: Build v
+      run: |
+        echo $VFLAGS
+        sudo ln -s $PWD/thirdparty/tcc/tcc.exe /usr/local/bin/tcc ## TODO: remove
+        make -j4
+        ./v -cg -cflags -Werror -o v cmd/v
+    - name: Test v->c
+      run: |
+        thirdparty/tcc/tcc.exe -version
+        ./v -cg -o v cmd/v # Make sure vtcc can build itself twice
+#        ./v -silent test-compiler
+    - name: v self compilation
+      run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
+    - name: Fixed tests
+      run: ./v -silent test-fixed
+    - name: Test building v tools
+      run: ./v -silent build-tools
+    - name: v doctor
+      run: |
+        ./v doctor
+    - name: Test v binaries
+      run: ./v -silent build-vbinaries
+
+  # Alpine docker pre-built container
+  alpine-docker-musl-gcc:
+    name: alpine-musl
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    container:
+      image: thevlang/vlang:alpine-build
+      env:
+        V_CI_MUSL: 1
+        VFLAGS: -cc gcc
+      volumes:
+        - ${{github.workspace}}:/opt/vlang
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Build V
+        run: |
+          make CC=clang
+      - name: Test V fixed tests
+        run: |
+          v -silent test-fixed
+
+  macos:
+    runs-on: macOS-latest
+    timeout-minutes: 30
+    env:
+      VFLAGS: -cc clang
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v1
+      with:
+        node-version: 12.x
+    - name: Install dependencies
+      run: |
+        ##brew install libpq openssl freetype ### these are *already installed* on Catalina ...
+        brew uninstall --ignore-dependencies libpq ## libpq is a dependency of PHP
+        brew install postgresql
+        brew install glfw
+        ## brew install sdl2 sdl2_ttf sdl2_mixer sdl2_image
+        export LIBRARY_PATH="$LIBRARY_PATH:/usr/local/opt/openssl/lib/"
+    - name: Build V
+      run:  make -j4 && ./v -cg -cflags -Werror -o v cmd/v
+    - name: Build V using V
+      run:  ./v -o v2 cmd/v && ./v2 -o v3 cmd/v
+    - name: v self with -usecache
+      run: ./v -o v2 -usecache cmd/v
+    - name: Test symlink
+      run:  ./v symlink
+#    - name: Set up pg database
+#      run: |
+#        pg_ctl -D /usr/local/var/postgres -l /usr/local/var/postgres/server.log start
+#        psql -d postgres -c 'select rolname from pg_roles'
+#        psql -d postgres -c 'create database customerdb;'
+#        psql -d customerdb -f examples/database/pg/mydb.sql
+#    - name: Test v->c
+#      run: ./v -silent test-compiler
+#    - name: Test v binaries
+#      run: ./v -silent build-vbinaries
+##    - name: Test v->js
+##      run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+    - name: Fixed tests
+      run: VJOBS=1 ./v -silent test-fixed
+    - name: Build examples
+      run: ./v -silent build-examples
+    - name: Build examples with -autofree
+      run: |
+        ./v -autofree -experimental -o tetris examples/tetris/tetris.v
+    - name: v doctor
+      run: |
+        ./v doctor
+    - name: Cross-compilation to Linux
+      run: ./v -os linux cmd/v
+#    - name: Test vsh
+#      run:  ./v examples/v_script.vsh
+    - name: Test ved
+      run: |
+        git clone --depth 1 https://github.com/vlang/ved
+        cd ved && ../v -o ved .
+#        ../v -autofree .
+    - name: Build V UI examples
+      run: |
+        git clone --depth 1 https://github.com/vlang/ui
+        cd ui
+        mkdir -p ~/.vmodules
+        ln -s $(pwd) ~/.vmodules/ui
+        ../v examples/rectangles.v
+        ../v run examples/build_examples.vsh
+
+  ubuntu:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v1
+      with:
+        node-version: 12.x
+    - name: Install dependencies
+      run: |
+         sudo rm -f /etc/apt/sources.list.d/dotnetdev.list /etc/apt/sources.list.d/microsoft-prod.list;
+         sudo apt-get update;
+         sudo apt-get install --quiet -y postgresql libpq-dev libssl-dev sqlite3 libsqlite3-dev valgrind
+         sudo apt-get install --quiet -y libglfw3 libglfw3-dev  libfreetype6-dev  libxi-dev libxcursor-dev libasound2-dev
+         ## sudo apt-get install --quiet -y libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev
+    - name: Build V
+      run: make -j4 && ./v -cc gcc -cg -cflags -Werror -o v cmd/v
+#    - name: Test V
+#      run: ./v -silent test-compiler
+#    - name: Test v binaries
+#      run: ./v -silent build-vbinaries
+##    - name: Test v->js
+##      run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+#    - name: Build Vorum
+#      run: git clone --depth 1 https://github.com/vlang/vorum && cd vorum && ../v . && cd ..
+#    - name: Build vpm
+#      run: git clone --depth 1 https://github.com/vlang/vpm && cd vpm && ../v . && cd ..
+#    - name: Freestanding
+#      run: ./v -freestanding -o bare vlib/os/bare/bare_example_linux.v
+    - name: v self compilation
+      run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
+    - name: v self with -usecache
+      run: ./v -o v2 -usecache cmd/v
+    - name: Fixed tests
+      run: |
+        ./v -silent test-fixed
+    - name: Fixed tests (-prod)
+      run: ./v -o vprod -prod cmd/v && ./vprod -silent test-fixed
+    - name: Build examples
+      run: ./v -silent build-examples
+    - name: Build examples with -autofree
+      run: |
+        ./v -autofree -experimental -o tetris examples/tetris/tetris.v
+    - name: Build modules
+      run: |
+        ./v build-module vlib/os
+        ./v build-module vlib/builtin
+        ./v build-module vlib/strconv
+        ./v build-module vlib/time
+        ./v build-module vlib/term
+        ./v build-module vlib/math
+        ./v build-module vlib/strings
+        ./v build-module vlib/v/token
+        ./v build-module vlib/v/ast
+        ./v build-module vlib/v/parser
+        ./v build-module vlib/v/gen
+        ./v build-module vlib/v/depgraph
+        ./v build-module vlib/os/cmdline
+    - name: x64 machine code generation
+      run: |
+        exit
+        ./v -o vprod -prod cmd/v
+        cd cmd/tools
+        echo "Generating a 1m line V file..."
+        ../../vprod gen1m.v
+        ./gen1m > 1m.v
+        echo "Building it..."
+        ../../vprod -backend x64 -o 1m 1m.v
+        echo "Running it..."
+        ls
+#    - name: SDL examples
+#      run: git clone --depth 1 https://github.com/vlang/sdl && cd sdl
+
+#        ./1m
+      #run: echo "TODO" #cd examples/x64 && ../../v -x64 hello_world.v && ./hello_world
+#    - name: Coveralls GitHub Action
+#      uses: coverallsapp/github-action@v1.0.1
+#      with:
+#        github-token: ${{ secrets.GITHUB_TOKEN }}
+
+
+#  ubuntu-autofree-selfcompile:
+#    runs-on: ubuntu-18.04
+#    timeout-minutes: 30
+#    env:
+#      VFLAGS: -cc gcc
+#    steps:
+#    - uses: actions/checkout@v2
+#    - name: Build V
+#      run: make -j4
+#    - name: V self compilation with -autofree
+#      run: ./v -o v2 -autofree cmd/v && ./v2 -o v3 -autofree cmd/v && ./v3 -o v4 -autofree cmd/v
+
+
+  # Ubuntu docker pre-built container
+  ubuntu-musl:
+    name: ubuntu-musl
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    container:
+      image: thevlang/vlang:ubuntu-build
+      env:
+        V_CI_MUSL: 1
+        V_CI_UBUNTU_MUSL: 1
+        VFLAGS: -cc musl-gcc
+      volumes:
+        - ${{github.workspace}}:/opt/vlang
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Build V
+        run: |
+          echo $VFLAGS && make -j4 && ./v -cg -o v cmd/v
+      - name: Test V fixed tests
+        run: |
+          ./v -silent test-fixed
+
+#   ubuntu-musl:
+#     runs-on: ubuntu-18.04
+#     timeout-minutes: 30
+#     env:
+#       VFLAGS: -cc musl-gcc
+#       V_CI_MUSL: 1
+#     steps:
+#     - uses: actions/checkout@v2
+#     - uses: actions/setup-node@v1
+#       with:
+#         node-version: 12.x
+#     - name: Install dependencies
+#       run: |
+#          sudo rm -f /etc/apt/sources.list.d/dotnetdev.list /etc/apt/sources.list.d/microsoft-prod.list;
+#          sudo apt-get update;
+#          sudo apt-get install --quiet -y musl musl-tools libssl-dev sqlite3 libsqlite3-dev valgrind
+#          sudo apt-get install --quiet -y libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev
+#     - name: Build v
+#       run: echo $VFLAGS && make -j4 && ./v -cg -o v cmd/v
+# #    - name: Test v binaries
+# #      run: ./v -silent build-vbinaries
+# ##    - name: Test v->js
+# ##      run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+#     - name: quick debug
+#       run: ./v -stats vlib/strconv/format_test.v
+#     - name: Fixed tests
+#       run: ./v -silent test-fixed
+
+  ubuntu-llvm-mingw:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v2
+#    - name: Cross-compile V
+#      run: docker build . -f Dockerfile.cross
+
+  windows-gcc:
+    runs-on: windows-2019
+    timeout-minutes: 30
+    env:
+        VFLAGS: -cc gcc
+    steps:
+    - uses: actions/checkout@v2
+    #- uses: actions/setup-node@v1
+    #  with:
+    #    node-version: 12.x
+    - name: Build
+      run: |
+        gcc --version
+        .\make.bat -gcc
+    - name: Test new v.c
+      run: .\v.exe -o v.c cmd/v && gcc -Werror -municode -w v.c
+    - name: Install dependencies
+      run: |
+        .\v.exe setup-freetype
+        .\.github\workflows\windows-install-sqlite.bat
+        ## .\.github\workflows\windows-install-sdl.bat
+    - name: Fixed tests
+      run: |
+        .\v.exe -silent test-fixed
+#    - name: Test
+#      run: |
+#        .\v.exe -silent test-compiler
+      ## v.js dosent work on windows
+        #.\v.exe -o hi.js examples/hello_v_js.v
+        #node hi.js
+#    - name: Test v binaries
+#      run: ./v -silent build-vbinaries
+#    - name: v2 self compilation
+#      run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
+
+  windows-msvc:
+    runs-on: windows-2019
+    timeout-minutes: 30
+    env:
+        VFLAGS: -cc msvc
+    steps:
+    - uses: actions/checkout@v2
+    #- uses: actions/setup-node@v1
+    #  with:
+    #    node-version: 12.x
+    - name: Build
+      run: |
+        echo %VFLAGS%
+        echo $VFLAGS
+        .\make.bat -msvc
+        .\v.exe -cflags /WX self
+    - name: Install dependencies
+      run: |
+        .\v.exe setup-freetype
+        .\.github\workflows\windows-install-sqlite.bat
+        ## .\.github\workflows\windows-install-sdl.bat
+    - name: Fixed tests
+      run: |
+        ./v -cg cmd\tools\vtest-fixed.v
+        ./v -silent test-fixed
+    - name: v doctor
+      run: |
+        ./v doctor
+#    - name: Test
+#      run: |
+#        .\v.exe -silent test-compiler
+#      ## v.js dosent work on windows
+        #.\v.exe -o hi.js examples/hello_v_js.v
+        #node hi.js
+#    - name: Test v binaries
+#      run: ./v -silent build-vbinaries
+
+  windows-tcc:
+    runs-on: windows-2019
+    timeout-minutes: 30
+    # We are simulating a user with no cc installed.
+    # This way, v's cc detection on Windows is also tested.
+    # env:
+    #   VFLAGS: -cc tcc
+    steps:
+    - uses: actions/checkout@v2
+    #- uses: actions/setup-node@v1
+    #  with:
+    #    node-version: 12.x
+    - name: Build
+      # We need to move gcc and msvc, so that V can't find an existing C compiler and downloads tcc
+      run: |
+        'for /f "usebackq tokens=*" %i in (`where gcc.exe`) do move /Y "%i" "%i.old"'     | cmd
+        'for /f "usebackq tokens=*" %i in (`where vswhere.exe`) do move /Y "%i" "%i.old"' | cmd
+        move "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe" "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe.old"
+        .\make.bat
+    - name: Test new v.c
+      run: .\v.exe -o v.c cmd/v && .\thirdparty\tcc\tcc.exe -Werror -w -ladvapi32 -bt10 v.c
+    - name: Install dependencies
+      run: |
+        .\v.exe setup-freetype
+        .\.github\workflows\windows-install-sqlite.bat
+        ## .\.github\workflows\windows-install-sdl.bat
+    - name: Fixed tests
+      run: |
+        .\v.exe -silent test-fixed
+#    - name: Test
+#      run: |
+#        .\v.exe -silent test-compiler
+      ## v.js dosent work on windows
+        #.\v.exe -o hi.js examples/hello_v_js.v
+        #node hi.js
+#    - name: Test v binaries
+#      run: ./v -silent build-vbinaries
+#    - name: v2 self compilation
+#      run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
+
+
+  compilable-v-c-and-v-win-c:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: |
+        sudo rm -f /etc/apt/sources.list.d/dotnetdev.list /etc/apt/sources.list.d/microsoft-prod.list
+        sudo apt-get update
+        sudo apt install --quiet -y mingw-w64 wine-stable winetricks
+    - name: Build V
+      run: make -j4
+    - name: v.c can be compiled and run
+      run: |
+        ./v -os cross -o /tmp/v.c cmd/v
+        gcc  -g -std=gnu11 -w -o v_from_vc /tmp/v.c  -lm -lpthread
+        ls -lart v_from_vc
+        ./v_from_vc version
+    - name: v_win.c can be compiled and run
+      run: |
+        ./v -os windows -o /tmp/v_win.c cmd/v
+        x86_64-w64-mingw32-gcc  /tmp/v_win.c -std=c99 -w -municode -o v_from_vc.exe
+        ls -lart v_from_vc.exe
+        winetricks nocrashdialog
+        wine v_from_vc.exe version
+
+
+  ubuntu-c-plus-plus:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: |
+        sudo rm -f /etc/apt/sources.list.d/dotnetdev.list /etc/apt/sources.list.d/microsoft-prod.list;
+        sudo apt-get update;
+        sudo apt-get install --quiet -y postgresql libpq-dev libssl-dev sqlite3 libsqlite3-dev
+        sudo apt-get install --quiet -y libglfw3 libglfw3-dev  libfreetype6-dev  libxi-dev libxcursor-dev libasound2-dev
+        sudo apt-get install --quiet -y valgrind g++-9
+        ## sudo apt-get install --quiet -y libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev
+    - name: Build V
+      run: make -j4
+    - name: g++ version
+      run: g++-9 --version
+    - name: V self compilation with g++
+      run: ./v -cc g++-9 -o v2 cmd/v && ./v2 -cc g++-9 -o v3 cmd/v
+##    - name: Running tests with g++
+##      run: ./v -cc g++-9 -silent test-fixed
+
+  install-modules:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: sudo apt-get install --quiet -y libssl-dev
+    - name: Build V
+      run: make -j4
+    - name: Installing V modules
+      run: |
+        ./v install ui
+        ./v install nedpals.args
+
+  gitly-compiles:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev
+    - name: Build V
+      run: make -j2 && ./v -cc gcc -o v cmd/v
+    - name: Install markdown
+      run: ./v install markdown
+    - name: Build Gitly
+      run: |
+        git clone --depth 1 https://github.com/vlang/gitly
+        cd gitly
+        ../v .
+        cd ..
+
+  websocket_autobahn:
+    name: Autobahn integrations tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Run autobahn services
+        run: docker-compose -f ${{github.workspace}}/vlib/x/websocket/tests/autobahn/docker-compose.yml up -d
+      - name: Build client test
+        run: docker exec autobahn_client "/src/v" "/src/vlib/x/websocket/tests/autobahn/autobahn_client.v"
+      - name: Run client test
+        run: docker exec autobahn_client "/src/vlib/x/websocket/tests/autobahn/autobahn_client"
+      - name: Build client wss test
+        run: docker exec autobahn_client "/src/v" "/src/vlib/x/websocket/tests/autobahn/autobahn_client_wss.v"
+      - name: Run client wss test
+        run: docker exec autobahn_client "/src/vlib/x/websocket/tests/autobahn/autobahn_client_wss"
+      - name: Run server test
+        run: docker exec autobahn_server "wstest" "-m" "fuzzingclient" "-s" "/config/fuzzingclient.json"
+      - name: Copy reports
+        run: docker cp autobahn_server:/reports ${{github.workspace}}/reports
+      - name: Copy reports wss
+        run: docker cp autobahn_server_wss:/reports ${{github.workspace}}/reports_wss
+      - name: Test success
+        run: docker exec autobahn_server "python" "/check_results.py"
+      - name: Test success WSS
+        run: docker exec autobahn_server_wss "python" "/check_results.py"
+
+      - name: Publish all reports
+        uses: actions/upload-artifact@v2
+        with:
+            name: full report
+            path: ${{github.workspace}}/reports
+      - name: Publish report client
+        uses: actions/upload-artifact@v2
+        with:
+            name: client
+            path: ${{github.workspace}}/reports/clients/index.html
+      - name: Publish report server
+        uses: actions/upload-artifact@v2
+        with:
+            name: server
+            path: ${{github.workspace}}/reports/servers/index.html
+      - name: Publish all reports WSS
+        uses: actions/upload-artifact@v2
+        with:
+            name: full report wss
+            path: ${{github.workspace}}/reports_wss
+      - name: Publish report client wss
+        uses: actions/upload-artifact@v2
+        with:
+            name: client wss
+            path: ${{github.workspace}}/reports_wss/clients/index.html

.github/workflows/docs_ci.yml

@@ -0,0 +1,16 @@
+name: Docs CI
+
+### Run on *EVERY* commit. The documentation *SHOULD* stay valid, and
+### the developers should receive early warning if they break it.
+on: [push, pull_request]
+
+jobs:
+  check-markdown:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 5
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build V
+      run: make
+    - name: Check markdown line length & code examples
+      run: ./v run cmd/tools/check-md.v -all

.github/workflows/periodic.yml

@@ -0,0 +1,58 @@
+name: Periodic
+
+on:
+  schedule:
+    - cron:  '31 1,12 * * *'
+
+jobs:
+  network-tests-ubuntu:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    env:
+        V_CI_PERIODIC: 1
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install dependencies
+      run: sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev valgrind
+    - name: Build v
+      run: make -j4
+    - name: Symlink V
+      run:  sudo ./v symlink
+    - name: Run network tests
+      run: ./v -d network -silent test-fixed
+
+
+  network-tests-macos:
+    runs-on: macOS-latest
+    timeout-minutes: 30
+    env:
+        V_CI_PERIODIC: 1
+    steps:
+    - uses: actions/checkout@v2
+    - name: Setup openssl library path
+      run: export LIBRARY_PATH="$LIBRARY_PATH:/usr/local/opt/openssl/lib/"
+    - name: Build V
+      run:  make -j4
+    - name: Symlink V
+      run:  sudo ./v symlink
+    - name: Ensure thirdparty/cJSON/cJSON.o is compiled, before running tests.
+      run:  ./v examples/json.v
+    - name: Run network tests
+      run: ./v -d network -silent test-fixed
+
+
+  network-windows-msvc:
+    runs-on: windows-2019
+    timeout-minutes: 30
+    env:
+        V_CI_PERIODIC: 1
+        VFLAGS: -cc msvc
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build
+      run: |
+        echo %VFLAGS%
+        echo $VFLAGS
+        .\make.bat -msvc
+    - name: Run network tests
+      run: .\v.exe -d network -silent test-fixed

.github/workflows/prebuilt.yml

@@ -0,0 +1,56 @@
+name: Test prebuilt binaries
+on:
+  release:
+    types: [edited, published]
+jobs:
+  ubuntu:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install --quiet -y postgresql libpq-dev libglfw3 libglfw3-dev libfreetype6-dev libssl-dev sqlite3 libsqlite3-dev valgrind
+        ## sudo apt-get install --quiet -y libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev 
+    - name: Download V
+      run: |
+        tag=${GITHUB_REF##*/}
+        wget https://github.com/vlang/v/releases/download/$tag/v_linux.zip
+        unzip v_linux.zip
+        ./v -version
+    - name: Test V
+      run: |
+        ./v run examples/hello_world.v
+
+  macos:
+    runs-on: macOS-latest
+    timeout-minutes: 5
+    steps:
+    - name: Install dependencies
+      run: |
+        brew install freetype glfw openssl
+        # brew install sdl2 sdl2_ttf sdl2_mixer sdl2_image
+        export LIBRARY_PATH="$LIBRARY_PATH:/usr/local/opt/openssl/lib/"
+    - name: Download V
+      run: |
+        tag=${GITHUB_REF##*/}
+        wget https://github.com/vlang/v/releases/download/$tag/v_macos.zip
+        unzip v_macos.zip
+        ./v -version
+    - name: Test V
+      run: |
+        ./v run examples/hello_world.v
+
+  windows:
+    runs-on: windows-latest
+    timeout-minutes: 5
+    steps:
+    - name: Download V
+      run: |
+        Set-Variable -Name "tag" -Value $env:GITHUB_REF.split("/", 3)[-1]
+        & curl -L https://github.com/vlang/v/releases/download/$tag/v_windows.zip -o v_windows.zip
+        & unzip .\v_windows.zip
+        & .\v.exe -version
+    - name: Test V
+      run: |
+        & .\v.exe run .\examples\hello_world.v

.github/workflows/windows-install-sdl.bat

@@ -0,0 +1,16 @@
+@echo off
+
+curl -L https://www.libsdl.org/release/SDL2-devel-2.0.10-VC.zip -o SDL2.zip
+curl -L https://www.libsdl.org/projects/SDL_ttf/release/SDL2_ttf-devel-2.0.15-VC.zip -o SDL2_ttf.zip
+curl -L https://www.libsdl.org/projects/SDL_image/release/SDL2_image-devel-2.0.5-VC.zip -o SDL2_image.zip
+curl -L https://www.libsdl.org/projects/SDL_mixer/release/SDL2_mixer-devel-2.0.4-VC.zip -o SDL2_mixer.zip
+
+unzip SDL2.zip -d thirdparty/
+unzip SDL2_ttf.zip -d thirdparty/
+unzip SDL2_image.zip -d thirdparty/
+unzip SDL2_mixer.zip -d thirdparty/
+
+move /y thirdparty/SDL2-2.0.10 thirdparty/SDL2
+move /y thirdparty/SDL2_ttf-2.0.15 thirdparty/SDL2_ttf
+move /y thirdparty/SDL2_image-2.0.5 thirdparty/SDL2_image
+move /y thirdparty/SDL2_mixer-2.0.4 thirdparty/SDL2_mixer

.github/workflows/windows-install-sqlite.bat

@@ -0,0 +1,12 @@
+@echo off
+
+curl -L https://www.sqlite.org/2020/sqlite-amalgamation-3320300.zip -o sqlite-amalgamation-3320300.zip
+
+unzip sqlite-amalgamation-3320300.zip -d thirdparty\
+
+del thirdparty\sqlite-amalgamation-3320300\shell.c
+
+move /y thirdparty\sqlite-amalgamation-3320300  thirdparty\sqlite
+
+dir thirdparty\sqlite
+

.gitignore

@@ -1,2 +1,78 @@
+# ignore all build binaries
+*
+!*/
+!*.*
+*.exe
+*.o
+*.so
+.*.c
+*.tmp.c
+*.obj
+*.exp
+*.ilk
+*.pdb
+*.dll
+*.lib
+*.bak
+a.out
+.noprefix.vrepl_temp
+
+# ignore v build files
+/vc
+/v.c
+/v.*.c
+/v.c.out
+.vrepl_temp.v
+fns.txt
+.noprefix.vrepl_temp.v
+
+# ignore temp directories
+/temp
+/tmp
+
+# unignore special files without extension
+!.github/PULL_REQUEST_TEMPLATE
+!.editorconfig
+!.gitattributes
+!.gitignore
+!BSDmakefile
+!Dockerfile
+!Dockerfile.alpine
+!Dockerfile.cross
+!LICENSE
+!Makefile
+
+# ignore editor files
+.idea
+.project
+.classpath
+.c9
+*.launch
+.settings/
+*.sublime-workspace
+.vscode/
+*.code-workspace
+*~
+*.swp
+*.swo
+*.swn
+.env
+
+# ignore debugger files
+cachegrind.out.*
+.gdb_history
 *.dSYM
-*_test
+*.def
+
+# ignore system files
+.DS_Store
+._*
+thumbs.db
+/.symlink
+/.bin
+
+_docs
+
+# ignore vs databases
+*.suo
+*.VC.db

.travis.yml

@@ -1,44 +0,0 @@
-language: c
-matrix:
-  include:
-    - os: linux
-      dist: xenial
-      sudo: required
-      addons:
-        apt:
-          sources:
-          - ubuntu-toolchain-r-test
-          packages:
-          - gcc-5
-          - g++-5
-          - make
-          - libglfw3 
-          - libglfw3-dev
-          - libfreetype6-dev 
-          - libcurl3-dev
-    - os: windows
-      language: sh
-      filter_secrets: false
-    - os: osx
-      osx_image: xcode10.2
-      addons:
-        homebrew:
-          packages:
-          - freetype
-          - glfw
-      #env:
-      #  - MATRIX_EVAL="brew install freetype glfw"
-script:
-  - |
-    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
-      sudo unlink /usr/bin/gcc && sudo ln -s /usr/bin/gcc-5 /usr/bin/gcc
-    fi
-  - |
-    if [[ "${TRAVIS_OS_NAME}" == "windows" ]]; then
-      choco install make
-      cp "C:\\ProgramData\\chocolatey\\bin\\gcc.exe" "C:\\ProgramData\\chocolatey\\bin\\cc.exe"
-    fi
-  - export VROOT=$(pwd)
-  - make
-  - make test
-

0.3_roadmap.txt

@@ -0,0 +1,27 @@
+- = TODO
++ = done
+
+- make `-autofree` the default
+- coroutines
++ channels
++ lock{}
++ thread safe arrays
+- thread safe maps
+- C2V translator
+- doom.v
+- rune type, replace `ustring` with `[]rune`, fix `byte.str()`
+- maps with non-string keys
++ iOS/Android support
+- parallel parser (and maybe checker/gen?)
+- `recover()` from panics
++ IO streams
++ struct embedding
+- interface embedding
+- interfaces: allow struct fields (not just methods)
+- vfmt: fix common errors automatically to save time (make vars mutable and vice versa, add missing imports etc)
+- method expressions with an explicit receiver as the first argument
++ short generics syntax (`foo(5)` instead of `foo<int>(5)`)
+- fix all remaining generics issues
+- merge v.c and v_win.c
+- more advanced errors, not just `error('message')`
+- VLS for autocomplete, refactoring, go to definition etc

BSDmakefile

@@ -0,0 +1,8 @@
+CC ?= cc
+
+all:
+	rm -rf vc/
+	git clone --depth 1 --quiet https://github.com/vlang/vc
+	$(CC) -std=gnu11 -w -o v vc/v.c -lm -lexecinfo
+	rm -rf vc/
+	@echo "V has been successfully built"

CHANGELOG.md

@@ -1,10 +1,380 @@
+## V 0.1.30
+*28 Nov 2020*
+(V 0.2 RC)
+TODO
 
-# 0.1.8 
+## V 0.1.27
+*5 May 2020*
+
+- vfmt has been re-written from scratch using the new AST parser.
+    It's much faster, cleaner, and can format
+files with compilation errors.
+- `strconv`, `sprintf`, and `printf` in native V, without any libc calls.
+- Interfaces are now a lot more stable and have all expected features.
+- Lots of x64 backend improvements: function calls, if expressions, for loops, local variables.
+- `map()` and `filter()` methods can now be chained.
+- New `[]int{cap:cap, len:len}` syntax for initializing array length and capacity.
+- New `is` keyword for checking the type of sum types and interfaces.
+- `as` can now be used to cast interfaces and sum types.
+- Profiling with `-profile`. Prints a nice table with details about every single function call:
+    number of calls, average time per call, total time per function
+- `import(xxx)` syntax has been removed in favor of `import xxx` for simplicity and greppability.
+- Lots of fixes and improvements in the type checker.
+- `time.StopWatch`
+- `dl` module for dynamic loading.
+- Automatic `str()` method generation for every single type, including all arrays.
+- Short struct initialization syntax for imitating named function args: `foo(bar:0, baz:1)`.
+- New operator `!in`.
+- Performance improvements in critical parts of the builtin data structures (array, map).
+- High order functions improvements (functions can now be returned etc).
+- Anonymous functions that can be defined inside other functions.
+- Built-in JSON module is back.
+- Closures.
+- Lots and lots of new tests added, including output tests that test error messages.
+- Multiple errors are now printed, the compiler no longer stops after the first error.
+- The new JS backend using the AST parser (almost complete).
+- Variadic functions.
+- `net.websocket` module (early stage).
+- `vlib` is now memory leak free, lots of `autofree` improvements.
+- Simplified and cleaned up `cmd/v`, `v.builder`.
+- V UI was updated to work with the new backend.
+
+
+## V 0.1.25
+*1 Apr 2020*
+
+- The entire compiler has been re-written with an AST parser.
+    The code is now a lot cleaner and more maintainable.
+    ~15k lines of old compiler code were removed.
+
+## V 0.1.24
+*31 Dec 2019*
+
+- A new parser/generator built on top of an AST that simplifies code greatly
+    and allows to implement new backends much faster.
+- Sum types (`type Expr = IfExpr | MatchExpr | IntegerLiteral`).
+- B-tree map (sped up the V compiler by ~10%).
+- `v fmt -w`.
+- The entire code base has been formatted with vfmt.
+- Generic structs.
+- SDL module.
+- Arrays of pointers.
+- os: `is_link()`, `is_dir()`, `exists()`.
+- Ranging through fixed size arrays.
+- Lots of fixes in ORM and vweb.
+- The first tutorial: [building a simple web application with vweb](https://github.com/vlang/v/blob/master/tutorials/building-a-simple-web-blog-with-vweb.md)
+- Match expressions now must be exhaustive.
+- freestanding: `malloc()`/`free()`.
+- `++` is now required instead of `+= 1` for consistency.
+- Interpolated strings now allow function calls: `println('val = $get_val()')`.
+- `string.replace_each([])` for an efficient replacement of multiple values.
+- More utf8 helper functions.
+- `-prealloc` option for block allocations.
+- `type` aliases.
+- Running `v` with an unknown command will result in an error.
+- `atof` implementation in pure V.
+- Enums can now have negative values.
+- New `filepath` module.
+- `math.factorial`.
+- `ftp` module.
+- New syntax for casting: `val as Type`.
+- Fewer libc functions used (soon V will have no dependency on libc).
+
+
+## V 0.1.23
+*30 Nov 2019*
+
+- [Direct x64 machine code generation](https://github.com/vlang/v/issues/2849).
+    Hello world being built in 3 milliseconds.
+- Bare metal support via the `-freestanding` flag, to build programs without linking to libc.
+- Prebuilt V packages for Linux, macOS, and Windows.
+- `string.index()` now returns `?int` instead of `int/-1`.
+- Lots of fixes in Generics.
+- vweb framework for developing web applications is back.
+- Vorum, the forum/blogging software written in vweb, can now be compiled and has been added to CI.
+- REPL, `v up` have been split up into separate applications to keep the core V compiler small.
+- V now enforces short enum syntax (`.green` instead of `Color.green`) when it's enough.
+- V UI for macOS.
+- Interfaces have been rewritten. `[]interface` support.
+- `os.cp()` for copying files and directores.
+- Additional compile-time flags: `$if clang, msvc, mingw, x32, x64, big_endian, little_endian {`.
+- All C functions now have to be declared, all missing C functions have been defined.
+- Global variables (only with the `--enable-globals` flag)
+    for low level applications like kernels and drivers.
+- Nothing can be cast to bool (previously code like `if bool(1) {` worked).
+- `<<` and `>>` now work with all integer types.
+- V detects Cygwin and shows an error (V supports Windows natively).
+- Improved type checking of some operators (`%, |, &` etc).
+- Windows 7 support.
+- `println(true)` now prints `true` instead of `1`.
+- `os.exec()` now uses `CreateProcess` on Windows.
+- fast.vlang.io website for monitoring the performance of V after every commit.
+- On Windows Visual Studio is now used automatically if GCC is not installed.
+- vfmt!
+- Lots of cleaning up in the compiler code.
+- Multi-level pointers in unsafe code (`****int`).
+- MSVC backtrace.
+- `$if os {` blocks are now skipped on a different OS.
+- C string literals (`c'hello'`).
+- AlpineLinux/musl fixes + added to CI.
+- Inline assembly.
+- Clipboard module (Windows, macOS, X).
+- `foo()?` syntax for error propagation.
+- Docs have been migrated from HTML to `doc/docs.md`.
+- `eventbus` module.
+- Haiku OS support.
+- `malloc/free` on bare metal.
+- `utf8` helper functions (`to_lower()`, `to_upper()`, etc).
+- Optimization of `for c in str {`.
+- `string/array.left/right/slice/substr` were removed (use `[a..b]` slicing syntax instead).
+
+
+
+## V 0.1.22
+*28 Oct 2019*
+
+- Generic functions (`fn foo<T>(bar T) T {`) with varargs support.
+- `array[start..end]` and `string[start..end]` slicing syntax.
+- Optimized `array.filter()` and `array.map()`.
+- `sqlite` module.
+- Cached modules for faster compilation.
+- Dramatic compilation optimizations: [V now compiles itself in 0.10 - 0.30 seconds](https://github.com/vlang/v/wiki/The-V-language-now-compiles-itself-in-0.09-seconds)
+- V scripts (simpler and cross-platform alternative to Bash).
+- Infinite multi-dimensional arrays (`[][][]int`).
+- `unsafe`.
+- `[deprecated]` attribute.
+- `[if]` function attributes for compile time function exclusion for performance.
+- `switch` has been completely removed from the language and replaced by
+`match` everywhere.
+- `pub struct` and `pub const`, previously all structs and consts were public
+by default.
+- `musl` support (V can now run on, for example, Alpine Linux).
+- Module header generation. V now supports closed source modules, which are still
+used in some industries.
+- Constants were added to typo suggestions.
+- `color in [.green, .red, .blue]` now works without specifying `Color.green`.
+- V compiler is now a module that can be used by other programs.
+- Backtraces now have source lines on Linux.
+- `runtime.nr_cpus()`.
+- `fn init()` for module initialization.
+- `a in [1, 2, 3]` optimization: no array gets allocated.
+- Raw strings: `s := r'hello\nworld'`.
+- `if a := func() { }` syntax for handling optionals.
+- f32/f64 comparison now uses machine epsilon by default.
+
+
+## V 0.1.21
+*30 Sep 2019*
+
+- `none` keyword for optionals.
+- Solaris support.
+- All table lookup functions now use `none`.
+- varargs: `fn foo(bar int, params ...string) {`.
+- Double quotes (`"`) can now also be used to denote strings.
+- GitHub Actions CI in addition to Travis.
+- `-compress` option. The V binary built with `-compress` is only ~90 KB!
+- More memory management.
+- Unused modules result in an error.
+- "Unused variable/module" errors are now warnings in non-production builds.
+- Duplicate methods with the same name can no longer be defined.
+- Struct names must be capitalized, variable/function names must use snake_case.
+- Error messages are now even nicer!
+- Lots of fixes in automatic `.str()` method generation for structs and arrays.
+- ~30% faster parser (files are no longer parsed separately for each pass).
+- `_` is no longer a variable, but an actual syntax construct to skip unused values, like in Go.
+- Multiple returns (`fn foo() (int, string) {`).
+- `!` can now only be used with booleans.
+
+
+## V 0.1.20
+*17 Sep 2019*
+
+- JavaScript backend!
+- Hundreds of C warnings were fixed. `gcc v.c` now builds without
+any warnings.
+- The mutability check now applies to function args (mutable
+receivers that are not modified result in a compilation error).
+- V tests now show how long each test took.
+- Official Android support (only console applications via Termux for now).
+- Typo check. If a variable/function/module etc is misspelled,
+V will suggest the correct name.
+- Lots of Microsoft C fixes, and a separate Travis instance for
+this backend.
+- Bitwise operators `|`, `^`, `&` no longer work with booleans.
+
+
+## V 0.1.19
+*12 Sep 2019*
+
+- Lots of refactoring, simplifications, and optimizations in the compiler.
+- Experimental memory management at compilation (only for the V compiler itself for now).
+- Lots of ORM fixes.
+- Functions can now be inlined via the `[inline]` attribute.
+- New `mysql` module.
+- Better error format that is supported by all major editors (go to error).
+- Error messages now point to the actual place where the error happened.
+- Custom json field names: `struct User { last_name string [json:lastName] }`.
+- Raw json fields via the `[raw]` attribute.
+- All C code was removed from the `freetype` module.
+- `gg` module can now render all Unicode characters.
+- `[typedef]` attribute for imported C struct typedefs.
+- Support of Objective C interfaces (primarily for using Cocoa).
+- REPL: clear command and custom functions.
+- REPL tests (which are also used for testing certain compiler errors).
+- Syntax bug fixed: `foo[0] += 10` is now possible.
+- http: support plain HTTP protocol and follow redirects.
+- http: header data is now processed correctly.
+- net: basic UDP support.
+- `import const` was removed from the language.
+- `array.contains()` was removed from the language (`in` should be used instead).
+- `[0; len]` syntax was removed (replaced with a simpler `[0].repeat(len)`)
+- Primitive aliases were removed to simplify the language.
+- GitHub supports V now!
+- Backtraces are now printed on panics.
+- A new awesome `readline` module.
+- V.c is now regenerated automatically after every commit.
+- A bug with struct ordering was fixed, now structs can be declared in any order.
+- V modules can now be built with `v build module`.
+- `@FILE, @LINE, @FN, @COLUMN` for debugging.
+
+
+## V 0.1.18
+*16 Aug 2019*
+
+- Built-in ORM (`uk_customers = db.select from Customer where country == 'uk' && nr_orders > 0`).
+- Map initialization syntax: `m := { ‘foo’: ‘bar’, ‘baz’: ‘foo’ }`.
+- `map.delete(key)`.
+- `libcurl` dependency was removed from the `http` module.
+- All function arguments are now immutable by default (previously they could be
+  modifed inside the function).
+- `http` functions now return optionals.
+- `sync.WaitGroup`.
+- `vweb` static files serving.
+- `crypto.rand` module.
+- `v up` to update V.
+- SChannel support on Windows.
+- `net.urllib` module.
+- vpm package manager, `v install`.
+- `()` are now required in complex bool expressions: `(a && b) || c` instead of `a && b || c`.
+- All arrays now have a default `.str()` method.
+- Bootstrapping V with MSVC.
+- Experimental `≠` etc support.
+- `encoding.csv` module.
+- `$if debug {` for running code in debug mode only.
+- Map struct fields are now initialized automatically, just like arrays.
+- Maps now support array values.
+- `json` functions can no longer be used if the `json` module is not imported.
+
+
+## V 0.1.17
+*29 Jul 2019*
+- `vweb` module for developing web apps in V.
+- vtalk, open source V forum software.
+- Generics (very limited right now, but they will be gradually improved).
+- Comptime codegen (`foo.$method()` where `method` is a string).
+- @ for escaping keywords (e.g. `struct Foo { @type string }`).
+- Windows Unicode fixes (V can now work with non-ASCII paths etc on Windows).
+- Fix mutable args bugs + don't allow primitive arguments to be modified.
+- Declaring a mutable variable and never modifying it results in a compilation error.
+- Interactive debugging support.
+- `sync` module for Windows.
+- `#!` support on Unix systems (V scripts).
+- Lots of Visual Studio fixes.
+- `crypto.aes` and `crypto.rc4` modules.
+- Internal modules.
+
+
+## V 0.1.16
+*23 Jul 2019*
+- V can now be used with Visual Studio!
+- Hot code reloading now works with graphical applications (e.g. graph.v, bounce.v).
+- Compile time memory management for arrays.
+- High order functions.
+- `match` expression (replacing `switch`).
+- Import cycle detection.
+- `crypto/md5`, `crypto/sha256`, and `crypro/sha512` modules.
+- `os.executable()` - a cross platform function that returns full path to current executable.
+- `~/.vlang` and `VROOT` were removed entirely. The installation is a lot cleaner now.
+- V can now be packaged for all Linux distros.
+- Arch Linux package.
+- `string(bytes_buffer, len)`, `string(bytes_array)` casts.
+- Multiple `defer`s.
+- `key in map` syntax (replacing `map.exists(key)`).
+
+
+## V 0.1.15
+*15 Jul 2019*
+- FreeBSD, OpenBSD, NetBSD, DragonFly support.
+- Hot reloading now works with graphical applications: [bounce.v](examples/hot_reload/bounce.v)
+- VROOT was removed, the installation process is now much simpler.
+- `defer` statement.
+- map.v was re-written. It's now much faster.
+- `for key, val in map` syntax.
+- `flag` module for parsing command line arguments.
+- `zip` module.
+- `crypto/sha1` module.
+- Submodules and module aliases (`import encoding.base64 as b64`).
+
+
+## V 0.1.14
+*12 Jul 2019*
+- `gg` module Windows support, V Tetris runs on Windows.
+- Compile `glad` and `cJSON` only once. Programs using `gg` or `json` compile a bit faster.
+- `v.c` has been cleaned up and minimized (~16k => ~10k lines of code).
+- `type` aliases can now have methods.
+- Const overflow check during compilation (`byte(1000)` will no longer compile).
+
+
+## V 0.1.13
+*10 Jul 2019*
+- New enum syntax (`token == .name`), enum values are no longer global consts.
+- Submodules (`import encoding.base64`).
+- Hot code reloading.
+- Special `err` variable for getting error values.
+- Complex numbers.
+- `<<` can now append arrays (`numbers << [1, 2, 3]`).
+- Lots of Windows fixes (Windows still needs some work).
+- Lots of REPL improvements (e.g. `>> 2 + 3` works now, no `println` required).
+- The website was made easily translatable, it's now partially available in several languages.
+
+
+## V 0.1.12
+*4 Jul 2019*
+- V can finally compile itself on Windows (https://github.com/vlang/v#mingw-w64).
+- `os` module now uses optionals in all functions that return `File`.
+- Lots of bugs with optionals were fixed.
+- `println` was optimized. It no longer results in allocations.
+    Now it also works correctly with all integer types.
+- Lots of `vfmt` fixes, it will be enabled tomorrow.
+- New `strings` module.
+- Lots of other fixes and improvements, thanks to all the contributors.
+
+
+## V 0.1.11
+*1 Jul 2019*
+- Cross compilation for Windows!
+- Lots of Windows fixes.
+- socket.v.
+- maps fixed.
+
+
+## V 0.1.9 - 0.1.10
+*29 Jun 2019*
+- Windows support via MinGW-w64. Pre-built Windows binary.
+- File structure has been simplified: all vlib modules were moved to the vlib/ directory,
+  makefile was moved to the root.
+- One single archive with pre-built binaries for all operating systems.
+- `mut var := val` was fixed (previously `mut var = val` was allowed as well).
+
+
+## V 0.1.8
+*28 Jun 2019*
 - Single file programs without `fn main` now work as expected.
-- REPL has been fixed: it now supports imports, consts, function definitions, etc. 
+- REPL has been fixed: it now supports imports, consts, function definitions, etc.
 
-# 0.1.7
 
+## V 0.1.7
+*27 Jun 2019*
 - All C code in the compiler and vlib has been replaced with V.
 - `#` syntax for embedding C code has been removed.
 - Exported functions now need to be marked with `pub`, all public vlib functions have been updated.

CODE_OF_CONDUCT.md

@@ -1 +1,4 @@
+# Code of Conduct
+
 Be nice and respectful.
+

CONTRIBUTING.md

@@ -0,0 +1,167 @@
+## Code Structure
+
+I tried to make the code of the compiler and vlib as simple and readable as
+possible.  One of V's goals is to be open to developers with different levels
+of experience in compiler development. Compilers don't need to be black boxes
+full of magic that only few people understand.
+
+The V compiler is modular, and can be used by other applications. It is located
+in `cmd/v/` and `vlib/v/`.
+
+The most important and useful command to remember when working on the V compiler
+is `v self`.
+It rebuilds the V compiler.
+
+Be careful, if you introduce a breaking change and rebuild V, you will no longer
+be able to use V to build itself. So it's a good idea to make a backup copy of a
+working compiler executable.
+
+But don't worry, you can always simply run `make` (or `make.bat`), it will
+download the C version of the compiler and rebuild it from scratch.
+
+The architecture of the compiler is very simple and has three distinct steps:
+
+Parse/generate AST (`v.parser`) => Check types (`v.checker`) 
+=> Generate C/JavaScript/machine code (`v.gen`)
+
+
+The main files are:
+
+1. `cmd/v/v.v` The entry point.
+
+- V figures out the build mode.
+- Constructs the compiler object (`struct V`).
+- Creates a list of .v files that need to be parsed.
+- Creates a parser object for each file and runs `parse()` on them.
+- The correct backend is called (C, JS, x64), and a binary is compiled.
+
+2. `v/scanner` The scanner's job is to parse a list of characters and convert
+them to tokens.
+
+3. `v/token` This is simply a list of all tokens, their string values, and a
+couple of helper functions.
+
+4. `v/parser` The parser. It converts a list of tokens into an AST.
+In V, objects can be used before declaration, so unknown types are marked as
+unresolved. They are resolved later in the type checker.
+
+5. `v/table` V creates one table object that is shared by all parsers. It
+contains all types, consts, and functions, as well as several helpers to search
+for objects by name, register new objects, modify types' fields, etc.
+
+6. `v/checker` Type checker and resolver. It processes the AST and makes sure
+the types are correct. Unresolved types are resolved, type information is added
+to the AST.
+
+7. `v/gen` C backend. It simply walks the AST and generates C code that can be
+compiled with Clang, GCC, Visual Studio, and TCC.
+
+8. `json.v` defines the json code generation. This file will be removed once V
+supports comptime code generation, and it will be possible to do this using the
+language's tools.
+
+9. `v/gen/x64` is the directory with all the machine code generation logic. It
+defines a set of functions that translate assembly instructions to machine code
+and build the binary from scratch byte by byte. It manually builds all headers,
+segments, sections, symtable, relocations, etc. Right now it only has basic
+support of the x64 platform/ELF format.
+
+The rest of the directories are vlib modules: `builtin/` (strings, arrays,
+maps), `time/`, `os/`, etc. Their documentation is pretty clear.
+
+## Example Workflow for Contributing
+(provided by [@spytheman](https://github.com/spytheman))
+
+(If you don't already have a GitHub account, please create one. Your GitHub
+username will be referred to later as 'YOUR_GITHUB_USERNAME'. Change it
+accordingly in the steps below.)
+
+1. Fork https://github.com/vlang/v using GitHub's interface to your own account.
+Let's say that the forked repository is at
+`https://github.com/YOUR_GITHUB_USERNAME/v` .
+2. Clone the main v repository https://github.com/vlang/v to a local folder on
+your computer, say named nv/ (`git clone https://github.com/vlang/v nv`)
+3. `cd nv`
+4. `git remote add pullrequest https://github.com/YOUR_GITHUB_USERNAME/v`
+NB: the remote named `pullrequest` should point to YOUR own forked repo, not the
+main v repository! After this, your local cloned repository is prepared for
+making pullrequests, and you can just do normal git operations such as:
+`git pull` `git status` and so on.
+
+5. When finished with a feature/bugfix/change, you can:
+`git checkout -b fix_alabala`
+6. `git push pullrequest`  # (NOTE: the `pullrequest` remote was setup on step 4)
+7. On GitHub's web interface, go to: https://github.com/vlang/v/pulls
+
+   Here the UI shows a dialog with a button to make a new pull request based on
+   the new pushed branch.
+   (Example dialog: https://url4e.com/gyazo/images/364edc04.png)
+
+8. After making your pullrequest (aka, PR), you can continue to work on the
+branch `fix_alabala` ... just do again `git push pullrequest` when you have more
+commits.
+
+9. If there are merge conflicts, or a branch lags too much behind V's master,
+you can do the following:
+
+   1. `git pull --rebase origin master` # solve conflicts and do
+   `git rebase --continue`
+   2. `git push pullrequest -f` # this will overwrite your current remote branch
+   with the updated version of your changes.
+
+The point of doing the above steps, is to never directly push to the main V
+repository, *only to your own fork*. Since your local `master` branch tracks the
+main V repository's master, then `git checkout master`, as well as
+`git pull --rebase origin master` will continue to work as expected
+(these are actually used by `v up`) and git can always do it cleanly.
+
+Git is very flexible, so there are other ways to accomplish the same thing.
+See the [GitHub flow](https://guides.github.com/introduction/git-handbook/#github), for more information.
+
+## Using Github's hub CLI tool
+
+You can download the `hub` tool from https://hub.github.com/ . Using
+`hub`, you will not need to go through the (sometimes) slow website
+to make PRs. Most remote operations can be done through the `hub` CLI
+command.
+
+NB: You still need to have a GitHub account.
+
+### Preparation:
+(steps 1..3 need to be done just *once*):
+
+1. `hub clone vlang/v my_v`
+2. `cd my_v`
+3. `hub fork --remote-name pullrequest`
+
+4. `git checkout -b my_cool_feature` # Step 4 is better done *once per each new
+feature/bugfix* that you make.
+
+### Improve V by making commits:
+
+5. `git commit -am "math: add a new function copysign"`
+
+### Testing your commits locally:
+You can test locally whether your changes have not broken something by
+running: `v test-compiler`. See `TESTS.md` for more details.
+
+### Publishing your commits to GitHub:
+
+6. `git push pullrequest`
+
+### Making a PR with `hub`:
+(so that your changes can be merged to the main V repository)
+
+7. `hub pull-request`
+
+Optionally, you can track the status of your PR CI tests with:
+
+8. `hub ci-status --verbose`
+
+### Fixing failing tests:
+If everything is OK, after 5-10 minutes, the CI tests should pass for
+all platforms. If not, visit the URLs for the failing CI jobs, see
+which tests have failed and then fix them by making more changes. Just use
+`git push pullrequest` to publish your changes. The CI tests will
+run with your updated code. Use `hub ci-status --verbose` to monitor
+their status.

CodeStructure.md

@@ -1,39 +0,0 @@
-## Code Structure
-
-I tried making the code of the compiler and vlib as simple and readable as possible. One of V's goals is to be open to developers with different levels of experience in compiler development. Compilers don't need to be black boxes full of magic that only few people understand.
-
-The compiler itself is located in `compiler/`
-
-It has only 8 files (soon to be 7):
-
-1. `main.v` The entry point.
-- V figures out the build mode.
-- Constructs the compiler object (`struct V`).
-- Creates a list of .v files that need to be parsed.
-- Creates a parser object for each file and runs `parse()` on them (this should work concurrently in the future). The parser emits C or x64 code directly. For performance reasons, there are no intermediate steps (no AST or Assembly code generation).
-- If the parsing is successful, a single C file is generated by merging the output from the parsers and carefully arranging all definitions (C is a single pass language).
-- Finally, a C compiler is called to compile this C file and generate an executable or a library.
-
-2. `parser.v` The core of the compiler. This is the largest file (~3.5k loc). `parse()` method asks the scanner to generate a list of tokens for the file it needs to parse. Then it simply goes through all the tokens one by one.
-
-   In V objects can be used before declaration, so there are 2 passes. During the first pass it only looks at declarations and skips function bodies. It memorizes all function signatures, types, consts, etc. During the second pass it looks at function bodies and generates C  (e.g. `cgen('if ($expr) {'`) or machine code (e.g. `gen.mov(EDI, 1)`).
-
-   The formatter is embedded in the parser. Correctly formatted tokens are emitted as they are parsed. This allowed to simplify the compiler and avoid duplication, but slowed it down a bit. In the future this will be fixed with build flags and separate binaries for C generation, machine code generation, and formatting. This way there will be no unnecessary branching and function calls.
-   
-3. `scanner.v` The scanner's job is to parse a list of characters and convert them to tokens. It also takes care of string interpolation, which is a mess at the moment.
-
-4. `token.v` This is simply a list of all tokens, their string values, and a couple of helper functions.
-
-5. `table.v` V creates one table object that is shared by all parsers. It contains all types, consts, and functions, as well as several helpers to search for objects by name, register new objects, modify types' fields, etc.
-
-6. `cgen.v` The small `Cgen` struct helps generate C code. It's also shared by all parsers. It has a couple of functions that allow to go back and set something that was previously unknown (like with `a := 0` => `int a = 0;`). Some of these functions are hacky and need improvements and simplifications.
-
-7. `fn.v` Handles declaring and calling normal and async functions and methods. This file is about 1000 lines of code, and has some complex logic. It needs to be cleaned up and simplified a bit.
-
-8. `json.v` defines the json code generation. This file will be removed once V supports comptime code generation, and it will be possible to do this using the language's tools.
-
-9. `x64/` is the directory with all the machine code generation logic. It will be available in early July. Obviously this is the most complex part of the compiler. It defines a set of functions that translate assembly instructions to machine code, it builds complicated binaries from scratch byte by byte. It manually builds all headers, segments, sections, symtable, relocations, etc. Right now it only has basic support of the x64 platform/Mach-O format, and it can only generate `.o` files, which then have to be linked with `lld`. 
-
-The rest of the directories are vlib modules: `builtin/` (strings, arrays, maps), `time/`, `os/`, etc. Their documentation is pretty clear.
-
-

Dockerfile

@@ -0,0 +1,14 @@
+#same container that golang use
+FROM buildpack-deps:buster-curl
+
+LABEL maintainer="ANAGO Ronnel <anagoandy@gmail.com>"
+WORKDIR /opt/vlang
+RUN apt-get update && \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends gcc clang make git && \
+    apt-get clean && rm -rf /var/cache/apt/archives/* && \
+    rm -rf /var/lib/apt/lists/*
+COPY . .
+RUN make && \
+    ln -s /opt/vlang/v /usr/local/bin/v
+
+CMD [ "bash" ]

Dockerfile.alpine

@@ -0,0 +1,20 @@
+FROM alpine:3.11
+
+LABEL maintainer="spytheman <spytheman@bulsynt.org>"
+
+WORKDIR /opt/vlang
+
+ENV VVV  /opt/vlang
+ENV PATH /opt/vlang:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+
+RUN mkdir -p /opt/vlang && ln -s /opt/vlang/v /usr/bin/v
+
+RUN apk --no-cache add \
+  git make upx gcc \
+  musl-dev \
+  openssl-dev sqlite-dev \
+  libx11-dev glfw-dev freetype-dev
+
+## RUN apk --no-cache add --virtual sdl2deps sdl2-dev sdl2_ttf-dev sdl2_mixer-dev sdl2_image-dev
+
+RUN git clone https://github.com/vlang/v /opt/vlang && make && v -version

Dockerfile.cross

@@ -0,0 +1,10 @@
+FROM mstorsjo/llvm-mingw
+
+LABEL maintainer="Vitaly Takmazov <vitalyster@gmail.com>"
+COPY . .
+RUN make
+RUN ./v -os windows -o v.c cmd/v
+RUN x86_64-w64-mingw32-gcc v.c -std=c99 -w -municode -o v.exe
+RUN file v.exe
+
+CMD [ "bash" ]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Alexander Medvednikov
+Copyright (c) 2019-2020 Alexander Medvednikov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,20 +1,130 @@
-all: clean v
-	$(info V has been successfully built)
+CC ?= cc
+CFLAGS ?=
+LDFLAGS ?=
+TMPDIR ?= /tmp
+VROOT  ?= .
+VC     ?= ./vc
+V      ?= ./v
+VCREPO ?= https://github.com/vlang/vc
+TCCREPO ?= https://github.com/vlang/tccbin
 
-v: v.c
-	cc -std=gnu11 -w -o v v.c
-	./v -o v compiler 
-	rm v.c 
+VCFILE := v.c
+TMPTCC := $(VROOT)/thirdparty/tcc
+TCCBRANCH := thirdparty-unknown-unknown
+GITCLEANPULL := git clean -xf && git pull --quiet
+GITFASTCLONE := git clone --depth 1 --quiet --single-branch
 
-v.c:
-	curl -Os https://raw.githubusercontent.com/vlang/vc/master/v.c
+#### Platform detections and overrides:
+_SYS := $(shell uname 2>/dev/null || echo Unknown)
+_SYS := $(patsubst MSYS%,MSYS,$(_SYS))
+_SYS := $(patsubst MINGW%,MinGW,$(_SYS))
 
-test: v
-	./v -prod -o vprod compiler # Test prod build 
-	echo "Running V tests..." 
-	find . -name '*_test.v' -print0 | xargs -0 -n1 ./v
-	echo "Building V examples..." 
-	find examples -name '*.v' -print0 | xargs -0 -n1 ./v
+ifneq ($(filter $(_SYS),MSYS MinGW),)
+WIN32 := 1
+V:=./v.exe
+endif
+
+ifeq ($(_SYS),Linux)
+LINUX := 1
+TCCBRANCH := thirdparty-linux-amd64
+endif
+
+ifeq ($(_SYS),Darwin)
+MAC := 1
+TCCBRANCH := thirdparty-macos-amd64
+endif
+
+ifeq ($(_SYS),FreeBSD)
+LDFLAGS += -lexecinfo
+endif
+
+ifdef ANDROID_ROOT
+ANDROID := 1
+undefine LINUX
+TCCBRANCH := thirdparty-linux-arm64
+endif
+#####
+
+ifdef WIN32
+TCCBRANCH := thirdparty-windows-amd64
+VCFILE := v_win.c
+endif
+
+all: latest_vc latest_tcc
+ifdef WIN32
+	$(CC) $(CFLAGS) -g -std=c99 -municode -w -o $(V) $(VC)/$(VCFILE) $(LDFLAGS)
+ifdef prod
+	$(V) -prod self
+else
+	$(V) self
+endif
+else
+	$(CC) $(CFLAGS) -g -std=gnu99 -w -o $(V) $(VC)/$(VCFILE) -lm -lpthread $(LDFLAGS) 
+ifdef ANDROID
+	chmod 755 v
+endif
+
+ifdef prod
+	$(V) -prod self
+else
+	$(V) self
+endif
+
+ifndef ANDROID
+	$(MAKE) modules
+endif
+endif
+	@echo "V has been successfully built"
+	@$(V) -version
+
+#clean: clean_tmp
+#git clean -xf
 
 clean:
-	-rm -f v.c v vprod 
+	rm -rf $(TMPTCC)
+	rm -rf $(VC)
+
+latest_vc: $(VC)/.git/config
+ifndef local
+	cd $(VC) && $(GITCLEANPULL)
+else
+	@echo "Using local vc"
+endif
+
+fresh_vc:
+	$(GITFASTCLONE) $(VCREPO) $(VC)
+
+latest_tcc: $(TMPTCC)/.git/config
+ifndef ANDROID
+ifndef local
+	cd $(TMPTCC) && $(GITCLEANPULL)
+else
+	@echo "Using local tcc"
+endif
+endif
+
+fresh_tcc:
+ifndef ANDROID
+	rm -rf $(TMPTCC)
+	$(GITFASTCLONE) --branch $(TCCBRANCH) $(TCCREPO) $(TMPTCC)
+endif
+
+$(TMPTCC)/.git/config:
+	$(MAKE) fresh_tcc
+
+$(VC)/.git/config:
+	$(MAKE) fresh_vc
+
+selfcompile:
+	$(V) -cg -o v cmd/v
+
+selfcompile-static:
+	$(V) -cg -cflags '--static' -o v-static cmd/v
+
+modules: module_builtin module_strings module_strconv
+module_builtin:
+	#$(V) build module vlib/builtin > /dev/null
+module_strings:
+	#$(V) build module vlib/strings > /dev/null
+module_strconv:
+	#$(V) build module vlib/strconv > /dev/null

README.md

@@ -1,155 +1,253 @@
-# The V Programming Language 0.1.x
+<div align="center">
+<p>
+    <img width="80" src="https://raw.githubusercontent.com/donnisnoni95/v-logo/master/dist/v-logo.svg?sanitize=true">
+</p>
+<h1>The V Programming Language</h1>
 
-[![Build Status](https://dev.azure.com/alexander0785/vlang/_apis/build/status/vlang-CI?branchName=master)](https://dev.azure.com/alexander0785/vlang/_build/latest?definitionId=1&branchName=master) [![Build Status](https://travis-ci.org/vlang/v.svg?branch=master)](https://travis-ci.org/vlang/v)
+[vlang.io](https://vlang.io) |
+[Docs](https://github.com/vlang/v/blob/master/doc/docs.md) |
+[Changelog](https://github.com/vlang/v/blob/master/CHANGELOG.md) |
+[Speed](https://fast.vlang.io/) |
+[Contributing & compiler design](https://github.com/vlang/v/blob/master/CONTRIBUTING.md)
 
-https://vlang.io
+</div>
+<div align="center">
 
-Documentation: https://vlang.io/docs
-
-Twitter: https://twitter.com/v_language
-
-Discord (primary community): https://discord.gg/n7c74HM
-
-Installing V: https://github.com/vlang/v#installing-v-from-source
+[![Build Status][WorkflowBadge]][WorkflowUrl]
+[![Sponsor][SponsorBadge]][SponsorUrl]
+[![Patreon][PatreonBadge]][PatreonUrl]
+[![Discord][DiscordBadge]][DiscordUrl]
+[![Twitter][TwitterUrl]][TwitterBadge]
 
+</div>
 
 ## Key Features of V
 
-- Simplicity: the language can be learned in half an hour, less if you already know Go
-- Fast compilation: ~100k loc/s right now, ~1.2 million loc/s once x64 generation is mature enough
+- Simplicity: the language can be learned in less than an hour
+- Fast compilation: ≈80k loc/s with a Clang backend, 
+    ≈1 million loc/s with x64 and tcc backends *(Intel i5-7500, SSD, no optimization)*
 - Easy to develop: V compiles itself in less than a second
-- Performance: within 5% of C
+- Performance: as fast as C (V's main backend compiles to human readable C)
 - Safety: no null, no globals, no undefined behavior, immutability by default
 - C to V translation
 - Hot code reloading
-- Powerful UI and graphics libraries
+- [Cross-platform UI library](https://github.com/vlang/ui)
+- Built-in graphics library
 - Easy cross compilation
 - REPL
+- [Built-in ORM](https://github.com/vlang/v/blob/master/doc/docs.md#orm)
+- [Built-in web framework](https://github.com/vlang/v/blob/master/vlib/vweb/README.md)
+- C and JavaScript backends
 
-V 1.0 release is planned for December 2019.
+## Stability guarantee and future changes
 
-## Notes
+Despite being at an early development stage, the V language is relatively stable and has
+backwards compatibility guarantee, meaning that the code you write today is guaranteed
+to work a month, a year, or five years from now.
 
-GitHub marks V's code as written in Go. It's actually written in V, GitHub doesn't support the language yet.
+There still may be minor syntax changes before the 1.0 release, but they will be handled
+automatically via `vfmt`, as has been done in the past.
 
-The compilation is temporarily slower for this release:
+The V core APIs (primarily the `os` module) will still have minor changes until
+they are stabilized in 2020. Of course the APIs will grow after that, but without breaking
+existing code.
 
-- Debug builds are used (use `./v -prod -o v .` to get faster compilation).
-- vlib is recompiled with every program you build.
-- The new formatter runs on every single token and slows the compiler down by ~20%. This will be taken care of.
-- There are a lot of known issues that are quick to fix (like function lookups being O(n)).
-
-There's some old hacky code written when V was 2 months old. All of it will be quickly cleaned up. There are ~500 lines of C code, which will be removed by the end of June.
-
-## Code structure
-
-https://github.com/vlang/v/blob/master/CodeStructure.md
+Unlike many other languages, V is not going to be always changing, with new features
+being introduced and old features modified. It is always going to be a small and simple
+language, very similar to the way it is right now.
 
 ## Installing V from source
 
-### Linux and macOS
-
-You'll need Clang or GCC. On macOS run `xcode-select --install` if you don't have XCode or XCode tools installed.
+### Linux, macOS, Windows, *BSD, Solaris, WSL, Android, Raspbian
 
 ```bash
-# You can clone V anywhere
 git clone https://github.com/vlang/v
 cd v
 make
 ```
-Or build without make:
-```bash
-# Download the V compiler's source translated to C
-curl -sO https://raw.githubusercontent.com/vlang/vc/master/v.c
-cc -std=gnu11 -w -o v v.c  # Build it with Clang or GCC
-./v -o v .                 # Use the resulting V binary to build V from V source
-./v -o v .                 # Build the compiler again to make sure it works
-```
 
 That's it! Now you have a V executable at `[path to V repo]/v`.
+`[path to V repo]` can be anywhere.
 
-You can create a symlink so that it's globally available:
+(On Windows `make` means running `make.bat`, so make sure you use `cmd.exe`)
 
-```
-sudo ln -s [path to V repo]/v /usr/local/bin/v
-```
+Now you can try `./v run examples/hello_world.v` (`v.exe` on Windows).
 
-V is being constantly updated. To update V, simply run
-
-```
-git pull origin master
-make
-```
-
-
-### Windows
-
-V works great on Windows Subsystem for Linux. The instructions are the same as above.
-
-If you want to build v.exe on Windows without WSL, you can use MinGW-w64 or Visual Studio.
-
-#### MinGW-w64
-
-[Download](https://downloads.sourceforge.net/project/mingw-w64/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/installer/mingw-w64-install.exe?r=&ts=1561736169&use_mirror=gigenet) and install MinGW-w64.
-
-Make sure the `C:/mingw-w64/bin` directory is in system's PATH.
+V is being constantly updated. To update V, simply run:
+
+```bash
+v up
+```
+
+### C compiler
+
+It's recommended to use Clang or GCC or Visual Studio. 
+If you are doing development, you most likely already have one of those installed.
+
+Otherwise, follow these instructions:
+
+- [Installing a C compiler on Linux and macOS](https://github.com/vlang/v/wiki/Installing-a-C-compiler-on-Linux-and-macOS)
+
+- [Installing a C compiler on Windows](https://github.com/vlang/v/wiki/Installing-a-C-compiler-on-Windows)
+
+However, if none is found when running `make` on Linux or Windows, 
+TCC would be downloaded and set as an alternative C backend. 
+It's very lightweight (several MB) so this shouldn't take too long.
+
+### Symlinking
+
+NB: it is *highly recommended*, that you put V on your PATH. That saves
+you the effort to type in the full path to your v executable every time.
+V provides a convenience `v symlink` command to do that more easily.
+
+On Unix systems, it creates a `/usr/local/bin/v` symlink to your
+executable. To do that, run:
+
+```bash
+sudo ./v symlink
+```
+
+On Windows, start a new shell with administrative privileges, for
+example by <kbd>Windows Key</kbd>, then type `cmd.exe`, right click on its menu
+entry, and choose `Run as administrator`. In the new administrative
+shell, cd to the path, where you have compiled v.exe, then type:
+
+```bat
+.\v.exe symlink
+```
+
+That will make v available everywhere, by adding it to your PATH.
+Please restart your shell/editor after that, so that it can pick
+the new PATH variable.
+
+NB: there is no need to run `v symlink` more than once - v will
+continue to be available, even after `v up`, restarts and so on.
+You only need to run it again, if you decide to move the V repo
+folder somewhere else.
+
+### Docker
+
+<details><summary>Expand Docker instructions</summary>
 
 ```bash
-# You can clone V anywhere
 git clone https://github.com/vlang/v
-cd v/compiler
-# Download the V compiler's source translated to C
-curl -sO https://raw.githubusercontent.com/vlang/vc/master/v.c
-gcc -std=gnu11 -w -o v.exe v.c  # Build it with GCC
+cd v
+docker build -t vlang .
+docker run --rm -it vlang:latest
+v
 ```
 
+### Docker with Alpine/musl
 
-### Testing
-
+```bash
+git clone https://github.com/vlang/v
+cd v
+docker build -t vlang --file=Dockerfile.alpine .
+docker run --rm -it vlang:latest
+/usr/local/v/v
 ```
-$ cd examples
-$ v run hello_world.v
-hello world
 
+</details>
+
+### Testing and running the examples
+
+Make sure V can compile itself:
+
+```bash
+v self
+```
+
+```bash
 $ v
-V 0.1.2
-Use Ctrl-D to exit
+V 0.1.x
+Use Ctrl-C or `exit` to exit
 
 >>> println('hello world')
 hello world
 >>>
 ```
 
-Now if you want, you can start tinkering with the compiler. If you introduce a breaking change and rebuild V, you will no longer be able to use V to build itself. So it's a good idea to make a backup copy of a working compiler executable.
-
-
-### Running the examples
-
-```
+```bash
+cd examples
 v hello_world.v && ./hello_world    # or simply
 v run hello_world.v                 # this builds the program and runs it right away
 
 v word_counter.v && ./word_counter cinderella.txt
 v run news_fetcher.v
-v run tetris.v
+v run tetris/tetris.v
 ```
 
 <img src='https://raw.githubusercontent.com/vlang/v/master/examples/tetris/screenshot.png' width=300>
 
+NB: In order to build Tetris or 2048 (or anything else using `sokol` or  `gg` graphics modules)
+on some Linux systems, you need to install `libxi-dev` and `libxcursor-dev` .
 
-In order to build Tetris and anything else using the graphics module, you will need to install glfw and freetype.
+If you plan to use the http package, you also need to install OpenSSL on non-Windows systems.
 
-If you plan to use the http package, you also need to install libcurl.
-
-```
+```bash
 macOS:
-brew install glfw freetype curl
+brew install openssl
 
-Ubuntu:
-sudo apt install libglfw3 libglfw3-dev libfreetype6-dev libcurl3-dev
+Debian/Ubuntu:
+sudo apt install libssl-dev
 
-Arch:
-sudo pacman -S glfw-x11 curl freetype2
+Arch/Manjaro:
+openssl is installed by default
+
+Fedora:
+sudo dnf install openssl-devel
 ```
 
-glfw and libcurl dependencies will be removed soon.
+## V UI
+
+<a href="https://github.com/vlang/ui">
+<img src='https://raw.githubusercontent.com/vlang/ui/master/examples/screenshot.png' width=712>
+</a>
+
+https://github.com/vlang/ui
+
+<!---
+## JavaScript backend
+
+[examples/hello_v_js.v](examples/hello_v_js.v):
+
+```v
+fn main() {
+        for i in 0..3 {
+                println('Hello from V.js')
+        }
+}
+```
+
+```bash
+v -o hi.js examples/hello_v_js.v && node hi.js
+Hello from V.js
+Hello from V.js
+Hello from V.js
+```
+-->
+
+## Developing web applications
+
+Check out the [Building a simple web blog](https://github.com/vlang/v/blob/master/tutorials/building-a-simple-web-blog-with-vweb.md)
+tutorial and Gitly, a light and fast alternative to GitHub/GitLab:
+
+https://github.com/vlang/gitly
+
+<img src="https://user-images.githubusercontent.com/687996/85933714-b195fe80-b8da-11ea-9ddd-09cadc2103e4.png">
+
+## Troubleshooting
+
+Please see the [Troubleshooting](https://github.com/vlang/v/wiki/Troubleshooting) section on our [wiki page](https://github.com/vlang/v/wiki)
+
+[WorkflowBadge]: https://github.com/vlang/v/workflows/CI/badge.svg
+[DiscordBadge]: https://img.shields.io/discord/592103645835821068?label=Discord&logo=discord&logoColor=white
+[PatreonBadge]: https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dvlang%26type%3Dpledges
+[SponsorBadge]: https://camo.githubusercontent.com/da8bc40db5ed31e4b12660245535b5db67aa03ce/68747470733a2f2f696d672e736869656c64732e696f2f7374617469632f76313f6c6162656c3d53706f6e736f72266d6573736167653d254532253944254134266c6f676f3d476974487562
+[TwitterBadge]: https://twitter.com/v_language
+
+[WorkflowUrl]: https://github.com/vlang/v/commits/master
+[DiscordUrl]: https://discord.gg/vlang
+[PatreonUrl]: https://patreon.com/vlang
+[SponsorUrl]: https://github.com/sponsors/medvednikov
+[TwitterUrl]: https://img.shields.io/twitter/follow/v_language.svg?style=flatl&label=Follow&logo=twitter&logoColor=white&color=1da1f2

TESTS.md

@@ -0,0 +1,69 @@
+# Automated tests
+
+In the `v` repo there are several different tests. The main types are:
+
+* `_test.v` tests - check that `test_` functions succeed. These can be 
+run per directory or individually.
+* `.out` tests - run a `.vv` file and check the output matches the 
+contents of the `.out` file with the same base name. This is 
+particularly useful for checking that errors are printed.
+
+Tip: use `v -cc tcc` when compiling tests for speed.
+
+## `v test-compiler`
+
+This builds and tests:
+
+* `vc` repo
+* `_test.v` files
+* examples
+* `v install` a module
+
+Some of these can be invoked separately.
+
+## `vlib/v/compiler_errors_test.v`
+
+This runs tests for:
+* `checker/tests/*.vv`
+* `parser/tests/*.vv`
+
+## `vlib/v/tests`
+
+General runnable program tests.
+
+## Actual code
+
+* `v build-examples`
+* `v build-tools`
+
+## `v test-fixed`
+
+Test `vlib`.
+
+## vfmt tests
+
+In `vlib/v/fmt/` there's:
+
+* `fmt_test.v`
+
+This checks `.out` tests.
+
+* `fmt_keep_test.v`
+
+This verifies that `_keep.v` files would be unchanged by `vfmt -w`.
+
+* `fmt_vlib_test.v`
+
+This checks all source files are formatted and prints a summary. This 
+is not required.
+
+* `v test-fmt`
+
+Test all files in the current directory are formatted.
+
+## `.github/workflows/ci.yml`
+
+This runs various CI tests, e.g.:
+
+* `v vet vlib/v` - style checker
+* `v fmt -verify` on certain source files

azure-pipelines.yml

@@ -1,39 +0,0 @@
-jobs:
-  - job: LinuxBuild
-    pool: 
-      vmImage: 'ubuntu-16.04'
-    displayName: "V Linux Build"
-    steps:
-      - script: |
-          sudo apt install -y libglfw3 libglfw3-dev libfreetype6-dev libcurl3-dev
-        displayName: 'Install Dependencies'
-      - script: |
-          make
-        displayName: 'Build V'
-      - script: |
-          make test
-        displayName: 'Run Tests'
-  - job: WindowsBuild
-    pool: 
-      vmImage: 'vs2017-win2016'
-    displayName: "V Windows Build"
-  - job: OSXBuild
-    pool: 
-      vmImage: 'macOS-10.13'
-    displayName: "V MacOSX Build"
-    steps:
-      - script: |
-          brew install glfw freetype curl
-        displayName: 'Install Dependencies'
-      - script: |
-          make && make test
-        displayName: 'Build V'
-trigger:
-  branches:
-    include:
-      - '*'
-pr:
-  autoCancel: false
-  branches:
-    include:
-      - '*'

cmd/tools/bench/wyhash.v

@@ -0,0 +1,55 @@
+module main
+
+import hash.fnv1a
+import hash as wyhash
+import rand
+import benchmark
+
+fn main() {
+	rand.seed([u32(42), 0])
+	sample_size := 10000000
+	min_str_len := 20
+	max_str_len := 40
+	println('Generating $sample_size strings between $min_str_len - $max_str_len chars long...')
+	mut checksum := u64(0)
+	mut start_pos := 0
+	mut bgenerating := benchmark.start()
+	mut bytepile := []byte{}
+	for _ in 0 .. sample_size * max_str_len {
+		bytepile << byte(rand.int_in_range(40, 125))
+	}
+	mut str_lens := []int{}
+	for _ in 0 .. sample_size {
+		str_lens << rand.int_in_range(min_str_len, max_str_len)
+	}
+	bgenerating.measure('generating strings')
+	println('Hashing each of the generated strings...')
+	//
+	mut bhashing_1 := benchmark.start()
+	start_pos = 0
+	checksum = 0
+	for len in str_lens {
+		end_pos := start_pos + len
+		checksum ^= wyhash.wyhash_c(unsafe { bytepile.data + start_pos }, u64(len), 1)
+		start_pos = end_pos
+	}
+	bhashing_1.measure('wyhash.wyhash_c  | checksum: ${checksum:22}')
+	mut bhashing_2 := benchmark.start()
+	start_pos = 0
+	checksum = 0
+	for len in str_lens {
+		end_pos := start_pos + len
+		checksum ^= wyhash.sum64(bytepile[start_pos..end_pos], 1)
+		start_pos = end_pos
+	}
+	bhashing_2.measure('wyhash.sum64     | checksum: ${checksum:22}')
+	mut bhashing_3 := benchmark.start()
+	start_pos = 0
+	checksum = 0
+	for len in str_lens {
+		end_pos := start_pos + len
+		checksum ^= fnv1a.sum64(bytepile[start_pos..end_pos])
+		start_pos = end_pos
+	}
+	bhashing_3.measure('fnv1a.sum64      | checksum: ${checksum:22}')
+}

cmd/tools/check-md.v

@@ -0,0 +1,271 @@
+module main
+
+import os
+import rand
+import term
+import v.pref
+
+const (
+	too_long_line_length = 100
+	term_colors          = term.can_show_color_on_stderr()
+)
+
+fn main() {
+	files_paths := if '-all' in os.args { md_file_paths() } else { os.args[1..] }
+	mut warnings := 0
+	mut errors := 0
+	mut oks := 0
+	mut all_md_files := []MDFile{}
+	for file_path in files_paths {
+		real_path := os.real_path(file_path)
+		lines := os.read_lines(real_path) or {
+			println('"$file_path" does not exist')
+			warnings++
+			continue
+		}
+		mut mdfile := MDFile{
+			path: file_path
+		}
+		for i, line in lines {
+			if line.len > too_long_line_length {
+				if mdfile.state == .vexample {
+					println(wline(file_path, i, line.len, 'long V example line'))
+					warnings++
+				} else if mdfile.state == .codeblock {
+					println(wline(file_path, i, line.len, 'long code block line'))
+					warnings++
+				} else if line.starts_with('|') {
+					println(wline(file_path, i, line.len, 'long table'))
+					warnings++
+				} else if line.contains('https') {
+					println(wline(file_path, i, line.len, 'long link'))
+					warnings++
+				} else {
+					eprintln(eline(file_path, i, line.len, 'line too long'))
+					errors++
+				}
+			}
+			mdfile.parse_line(i, line)
+		}
+		all_md_files << mdfile
+	}
+	for mut mdfile in all_md_files {
+		new_errors, new_oks := mdfile.check_examples()
+		errors += new_errors
+		oks += new_oks
+	}
+	// println('all_md_files: $all_md_files')
+	if warnings > 0 || errors > 0 || oks > 0 {
+		println('\nWarnings: $warnings | Errors: $errors | OKs: $oks')
+	}
+	if errors > 0 {
+		exit(1)
+	}
+}
+
+fn md_file_paths() []string {
+	mut files_to_check := []string{}
+	md_files := os.walk_ext('.', '.md')
+	for file in md_files {
+		if file.starts_with('./thirdparty') {
+			continue
+		}
+		files_to_check << file
+	}
+	return files_to_check
+}
+
+fn ftext(s string, cb fn (string) string) string {
+	if term_colors {
+		return cb(s)
+	}
+	return s
+}
+
+fn btext(s string) string {
+	return ftext(s, term.bold)
+}
+
+fn mtext(s string) string {
+	return ftext(s, term.magenta)
+}
+
+fn rtext(s string) string {
+	return ftext(s, term.red)
+}
+
+fn wline(file_path string, lnumber int, column int, message string) string {
+	return btext('$file_path:${lnumber + 1}:${column + 1}:') + btext(mtext(' warn:')) + rtext(' $message')
+}
+
+fn eline(file_path string, lnumber int, column int, message string) string {
+	return btext('$file_path:${lnumber + 1}:${column + 1}:') + btext(rtext(' error: $message'))
+}
+
+//
+const (
+	default_command = 'compile'
+)
+
+struct VCodeExample {
+mut:
+	text    []string
+	command string
+	sline   int
+	eline   int
+}
+
+enum MDFileParserState {
+	markdown
+	vexample
+	codeblock
+}
+
+struct MDFile {
+	path     string
+mut:
+	examples []VCodeExample
+	current  VCodeExample
+	state    MDFileParserState = .markdown
+}
+
+fn (mut f MDFile) parse_line(lnumber int, line string) {
+	if line.starts_with('```v') {
+		if f.state == .markdown {
+			f.state = .vexample
+			mut command := line.replace('```v', '').trim_space()
+			if command == '' {
+				command = default_command
+			}
+			f.current = VCodeExample{
+				sline: lnumber
+				command: command
+			}
+		}
+		return
+	}
+	if line.starts_with('```') {
+		match f.state {
+			.vexample {
+				f.state = .markdown
+				f.current.eline = lnumber
+				f.examples << f.current
+				f.current = VCodeExample{}
+				return
+			}
+			.codeblock {
+				f.state = .markdown
+				return
+			}
+			.markdown {
+				f.state = .codeblock
+				return
+			}
+		}
+	}
+	if f.state == .vexample {
+		f.current.text << line
+	}
+}
+
+fn (mut f MDFile) dump() {
+	for e in f.examples {
+		eprintln('f.path: $f.path | example: $e')
+	}
+}
+
+fn (mut f MDFile) check_examples() (int, int) {
+	mut errors := 0
+	mut oks := 0
+	vexe := pref.vexe_path()
+	for e in f.examples {
+		if e.command == 'ignore' {
+			continue
+		}
+		if e.command == 'wip' {
+			continue
+		}
+		fname := os.base(f.path).replace('.md', '_md')
+		uid := rand.ulid()
+		vfile := os.join_path(os.temp_dir(), 'check_${fname}_example_${e.sline}__${e.eline}__${uid}.v')
+		mut should_cleanup_vfile := true
+		// eprintln('>>> checking example $vfile ...')
+		vcontent := e.text.join('\n')
+		os.write_file(vfile, vcontent) or {
+			panic(err)
+		}
+		mut acommands := e.command.split(' ')
+		for command in acommands {
+			match command {
+				'compile' {
+					res := os.system('"$vexe" -silent -o x.c $vfile')
+					os.rm('x.c') or { }
+					if res != 0 {
+						eprintln(eline(f.path, e.sline, 0, 'example failed to compile'))
+						eprintln(vcontent)
+						should_cleanup_vfile = false
+						errors++
+						continue
+					}
+					oks++
+				}
+				'live' {
+					res := os.system('"$vexe" -silent -live -o x.c $vfile')
+					if res != 0 {
+						eprintln(eline(f.path, e.sline, 0, 'example failed to compile with -live'))
+						eprintln(vcontent)
+						should_cleanup_vfile = false
+						errors++
+						continue
+					}
+					oks++
+				}
+				'failcompile' {
+					res := os.system('"$vexe" -silent -o x.c $vfile')
+					os.rm('x.c') or { }
+					if res == 0 {
+						eprintln(eline(f.path, e.sline, 0, '`failcompile` example compiled'))
+						eprintln(vcontent)
+						should_cleanup_vfile = false
+						errors++
+						continue
+					}
+					oks++
+				}
+				'oksyntax' {
+					res := os.system('"$vexe" -silent -check-syntax $vfile')
+					if res != 0 {
+						eprintln(eline(f.path, e.sline, 0, '`oksyntax` example with invalid syntax'))
+						eprintln(vcontent)
+						should_cleanup_vfile = false
+						errors++
+						continue
+					}
+					oks++
+				}
+				'badsyntax' {
+					res := os.system('"$vexe" -silent -check-syntax $vfile')
+					if res == 0 {
+						eprintln(eline(f.path, e.sline, 0, '`badsyntax` example can be parsed fine'))
+						eprintln(vcontent)
+						should_cleanup_vfile = false
+						errors++
+						continue
+					}
+					oks++
+				}
+				else {
+					eprintln(eline(f.path, e.sline, 0, 'unrecognized command: "$command", use one of: wip/ignore/compile/failcompile/oksyntax/badsyntax'))
+					should_cleanup_vfile = false
+					errors++
+				}
+			}
+		}
+		if should_cleanup_vfile {
+			os.rm(vfile) or {
+				panic(err)
+			}
+		}
+	}
+	return errors, oks
+}

cmd/tools/check_os_api_parity.v

@@ -0,0 +1,131 @@
+module main
+
+import os
+import v.util
+import v.pref
+import v.builder
+import v.ast
+import term
+
+const (
+	base_os      = 'linux'
+	os_names     = ['linux', 'macos', 'windows']
+	skip_modules = [
+		'builtin.bare',
+		'builtin.js',
+		'strconv',
+		'strconv.ftoa',
+		'hash',
+		'strings',
+		'crypto.rand',
+		'os.bare',
+		'os2',
+		'picohttpparser',
+		'picoev',
+		'szip',
+		'v.eval',
+	]
+)
+
+struct App {
+	diff_cmd        string
+	is_verbose      bool
+	modules         []string
+mut:
+	api_differences map[string]int
+}
+
+fn main() {
+	vexe := pref.vexe_path()
+	vroot := os.dir(vexe)
+	util.set_vroot_folder(vroot)
+	os.chdir(vroot)
+	cmd := util.find_working_diff_command() or {
+		''
+	}
+	mut app := App{
+		diff_cmd: cmd
+		is_verbose: os.getenv('VERBOSE').len > 0
+		modules: if os.args.len > 1 { os.args[1..] } else { all_vlib_modules() }
+	}
+	for mname in app.modules {
+		if !app.is_verbose {
+			eprintln('Checking module: $mname ...')
+		}
+		api_base := app.gen_api_for_module_in_os(mname, base_os)
+		for oname in os_names {
+			if oname == base_os {
+				continue
+			}
+			api_os := app.gen_api_for_module_in_os(mname, oname)
+			app.compare_api(api_base, api_os, mname, base_os, oname)
+		}
+	}
+	howmany := app.api_differences.len
+	eprintln('NB: please, do run `git clean -xf` after this tool, or at least `find thirdparty/ |grep .o$|xargs rm`')
+	eprintln('otherwise, `./v test-fixed` may show false positives, due to .o files compiled with a cross compiler.')
+	if howmany > 0 {
+		eprintln(term.header('Found $howmany modules with different APIs', '='))
+		for m in app.api_differences.keys() {
+			eprintln('Module: $m')
+		}
+		exit(1)
+	}
+}
+
+fn all_vlib_modules() []string {
+	mut vlib_v_files := os.walk_ext('vlib', '.v')
+	mut vmodulesmap := map[string]int{}
+	for f in vlib_v_files {
+		if f.contains('/tests/') || f.ends_with('_test.v') {
+			continue
+		}
+		vmodulename := os.dir(f).replace('/', '.').replace('vlib.', '')
+		if vmodulename in skip_modules {
+			continue
+		}
+		vmodulesmap[vmodulename] = vmodulesmap[vmodulename] + 1
+	}
+	mut modules := vmodulesmap.keys()
+	modules.sort()
+	return modules
+}
+
+fn (app App) gen_api_for_module_in_os(mod_name string, os_name string) string {
+	if app.is_verbose {
+		eprintln('Checking module: ${mod_name:-30} for OS: ${os_name:-10} ...')
+	}
+	mpath := os.join_path('vlib', mod_name.replace('.', '/'))
+	tmpname := '/tmp/${mod_name}_${os_name}.c'
+	prefs, _ := pref.parse_args(['-os', os_name, '-o', tmpname, '-shared', mpath])
+	mut b := builder.new_builder(prefs)
+	b.compile_c()
+	mut res := []string{}
+	for f in b.parsed_files {
+		for s in f.stmts {
+			if s is ast.FnDecl {
+				if s.is_pub {
+					fn_signature := s.stringify(b.table, mod_name)
+					fn_mod := s.modname()
+					if fn_mod == mod_name {
+						fline := '$fn_mod: $fn_signature'
+						res << fline
+					}
+				}
+			}
+		}
+	}
+	res.sort()
+	return res.join('\n')
+}
+
+fn (mut app App) compare_api(api_base string, api_os string, mod_name string, os_base string, os_target string) {
+	res := util.color_compare_strings(app.diff_cmd, api_base, api_os)
+	if res.len > 0 {
+		summary := 'Different APIs found for module: `$mod_name`, between OS base: `$os_base` and OS: `$os_target`'
+		eprintln(term.header(summary, '-'))
+		eprintln(res)
+		eprintln(term.h_divider('-'))
+		app.api_differences[mod_name] = 1
+	}
+}

cmd/tools/fast/.gitignore

@@ -0,0 +1,5 @@
+fast
+index.html
+table.html
+v.c
+v2

cmd/tools/fast/fast.v

@@ -0,0 +1,128 @@
+// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
+// Use of this source code is governed by an MIT license
+// that can be found in the LICENSE file.
+import os
+import time
+
+fn main() {
+	exe := os.executable()
+	dir := os.dir(exe)
+	vdir := os.dir(os.dir(os.dir(dir)))
+	if !os.exists('$vdir/v') && !os.is_dir('$vdir/vlib') {
+		println('fast.html generator needs to be located in `v/cmd/tools/fast`')
+	}
+	println('fast.html generator\n')
+	// Fetch the last commit's hash
+	println('Fetching updates...')
+	ret := os.system('$vdir/v up')
+	if ret != 0 {
+		println('failed to update V')
+		return
+	}
+	mut commit_hash := exec('git rev-parse HEAD')
+	commit_hash = commit_hash[..8]
+	if os.exists('last_commit.txt') {
+		last_commit := os.read_file('last_commit.txt') ?
+		if last_commit.trim_space() == commit_hash.trim_space() {
+			println('No new commits to benchmark. Commit $commit_hash has already been processed.')
+			return
+		}
+		commit_hash = last_commit.trim_space()
+	}
+	if !os.exists('table.html') {
+		os.create('table.html') ?
+	}
+	mut table := os.read_file('table.html') ?
+	/*
+	// Do nothing if it's already been processed.
+	if table.contains(commit_hash) {
+		println('Commit $commit_hash has already been processed')
+		return
+	}
+	*/
+	last_commits := exec('git log --pretty=format:"%h" -n 50').split('\n')
+	// Fetch all unprocessed commits (commits after the last processed commit)
+	mut commits := []string{}
+	println('!last_commit="$commit_hash"')
+	for i, c in last_commits {
+		if c == commit_hash {
+			commits = last_commits[..i].reverse()
+			break
+		}
+	}
+	println(last_commits)
+	println('Commits to benchmark:')
+	println(commits)
+	for i, commit in commits {
+		message := exec('git log --pretty=format:"%s" -n1 $commit')
+		println('\n${i + 1}/$commits.len Benchmarking commit $commit "$message"')
+		// Build an optimized V
+		println('Checking out ${commit}...')
+		exec('git checkout $commit')
+		println('  Building vprod...')
+		exec('v -o $vdir/vprod -prod $vdir/cmd/v')
+		diff1 := measure('$vdir/vprod -cc clang -o v.c $vdir/cmd/v', 'v.c')
+		diff2 := measure('$vdir/vprod -cc clang -o v2 $vdir/cmd/v', 'v2')
+		diff3 := measure('$vdir/vprod -x64 $vdir/cmd/tools/1mil.v', 'x64 1mil')
+		diff4 := measure('$vdir/vprod -cc clang $vdir/examples/hello_world.v', 'hello.v')
+		// println('Building V took ${diff}ms')
+		commit_date := exec('git log -n1 --pretty="format:%at" $commit')
+		date := time.unix(commit_date.int())
+		mut out := os.create('table.html') ?
+		// Place the new row on top
+		table = '<tr>
+		<td>$date.format()</td>
+		<td><a target=_blank href="https://github.com/vlang/v/commit/$commit">$commit</a></td>
+		<td>$message</td>
+		<td>${diff1}ms</td>
+		<td>${diff2}ms</td>
+		<td>${diff3}ms</td>
+		<td>${diff4}ms</td>
+	</tr>\n' +
+			table.trim_space()
+		out.writeln(table)
+		out.close()
+		// Regenerate index.html
+		header := os.read_file('header.html') ?
+		footer := os.read_file('footer.html') ?
+		mut res := os.create('index.html') ?
+		res.writeln(header)
+		res.writeln(table)
+		res.writeln(footer)
+		res.close()
+	}
+	exec('git checkout master')
+	os.write_file('last_commit.txt', commits[commits.len - 1]) ?
+}
+
+fn exec(s string) string {
+	e := os.exec(s) or {
+		panic(err)
+	}
+	return e.output.trim_right('\r\n')
+}
+
+// returns milliseconds
+fn measure(cmd string, description string) int {
+	println('  Measuring $description')
+	println('  Warming up...')
+	for _ in 0 .. 3 {
+		exec(cmd)
+	}
+	println('  Building...')
+	mut runs := []int{}
+	for r in 0 .. 5 {
+		println('  Sample ${r+1}/5')
+		sw := time.new_stopwatch({})
+		exec(cmd)
+		runs << int(sw.elapsed().milliseconds())
+	}
+	// discard lowest and highest time
+	runs.sort()
+	runs = runs[1..4]
+	mut sum := 0
+	for run in runs {
+		sum += run
+	}
+	return int(sum / 3)
+}

cmd/tools/fast/fast_main.js

@@ -0,0 +1,67 @@
+const delta = 20;
+
+(function () {
+    var table = document.querySelector("table");
+    var isTbody = table.children[0].nodeName == "TBODY";
+    var trs = isTbody
+        ? table.children[0].querySelectorAll("tr")
+        : table.querySelectorAll("tr");
+    trs.forEach(function (tr, idx) {
+        if (idx != 0 && idx + 1 < trs.length) {
+            var vc = 3, vv = 4, vf = 5, vh = 6;
+            var textContent = {
+                vc: tr.children[vc].textContent,
+                vv: tr.children[vv].textContent,
+                vf: tr.children[vf].textContent,
+                vh: tr.children[vh].textContent
+            };
+            var currentData = {
+                vc: int(textContent.vc.slice(0, -2)),
+                vv: int(textContent.vv.slice(0, -2)),
+                vf: int(textContent.vf.slice(0, -2)),
+                vh: int(textContent.vh.slice(0, -2))
+            };
+            var prevData = {
+                vc: int(trs[idx + 1].children[vc].textContent.slice(0, -2)),
+                vv: int(trs[idx + 1].children[vv].textContent.slice(0, -2)),
+                vf: int(trs[idx + 1].children[vf].textContent.slice(0, -2)),
+                vh: int(trs[idx + 1].children[vh].textContent.slice(0, -2))
+            };
+            var result = {
+                vc: currentData.vc - prevData.vc,
+                vv: currentData.vv - prevData.vv,
+                vf: currentData.vf - prevData.vf,
+                vh: currentData.vh - prevData.vh
+            };
+            if (Math.abs(result.vc) > delta)
+                tr.children[vc].appendChild(createElement(result.vc));
+            if (Math.abs(result.vv) > delta * 2)
+                tr.children[vv].appendChild(createElement(result.vv));
+            if (Math.abs(result.vf) > delta * 2)
+                tr.children[vf].appendChild(createElement(result.vf));
+            if (Math.abs(result.vh) > delta * 2)
+                tr.children[vh].appendChild(createElement(result.vh));
+        }
+    });
+    function int(src) {
+        return src - 0;
+    }
+    function getClassName(x) {
+        if (x == 0)
+            return "equal";
+        return x < 0 ? "plus" : "minus";
+    }
+    function createElement(result) {
+        var el = document.createElement("span");
+        var parsedResult = parseResult(result);
+        el.classList.add("diff");
+        el.classList.add(getClassName(result));
+        el.textContent = parsedResult;
+        return el;
+    }
+    function parseResult(x) {
+        if (x == 0)
+            return "0";
+        return x > 0 ? "+" + x : x;
+    }
+})();

cmd/tools/fast/footer.html

@@ -0,0 +1,4 @@
+</table>
+<script src="main.js"></script>
+</body>
+</html>

cmd/tools/fast/header.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Is V still fast?</title>
+<style>
+*, body {
+	font-family: Menlo, Monospace, 'Courier New';
+}
+table, td {
+	border-collapse: collapse;
+	border: 1px solid #dfdfdf;
+}
+td {
+	padding: 5px;
+	position: relative;
+}
+.diff {
+	border-radius: 2.5px;
+	color: #ffffff;
+	padding: 0 5px 0 5px;
+	position: absolute;
+	right: 5px;
+}
+.minus {
+	background-color: rgb(195, 74, 104);
+}
+.plus {
+	background-color: #8BC34A;
+}
+.equal {
+	background-color: rgb(113, 68, 172);
+}
+</style>
+</head>
+<body>
+<h2>Is V still fast?</h2>
+
+Monitoring compilation speed for each commit. <br><br>
+Running on an AWS t2.micro instance (1 vCPU). <br><br>
+Source code: <a target=blank href='https://github.com/vlang/v/blob/master/cmd/tools/fast/fast.v'>fast.v</a> <br><br>
+
+
+
+<table>
+	<tr>
+		<td></td>
+		<td></td>
+		<td style='width:400px'></td>
+		<td style='width:120px'>v -o v.c</td>
+		<td style='width:120px'>v -o v</td>
+		<td style='width:130px'>v -x64 1mil.v</td>
+		<td style='width:120px'>v hello.v</td>
+	</tr>

cmd/tools/gen1m.v

@@ -0,0 +1,18 @@
+fn main() {
+	println('fn print(a int) {}')
+	// println('fn println(a string) {}')
+	for i in 0 .. 100000 {
+		println('
+fn foo${i}() {
+	x := $i
+	mut a := 1
+	a += 2
+	print(a)
+	a = 0
+	a = 1
+}
+')
+	}
+	// println('fn main() {foo1()} ')
+	println('fn main() { println("1m DONE") } ')
+}

cmd/tools/gen_vc.v

@@ -0,0 +1,379 @@
+module main
+
+// This tool regenerates V's bootstrap .c files
+// every time the V master branch is updated.
+// if run with the --serve flag it will run in webhook
+// server mode awaiting a request to http://host:port/genhook
+// available command line flags:
+// --work-dir  gen_vc's working directory
+// --purge     force purge the local repositories
+// --serve     run in webhook server mode
+// --port      port for http server to listen on
+// --log-to    either 'file' or 'terminal'
+// --log-file  path to log file used when --log-to is 'file'
+// --dry-run   dont push anything to remote repo
+// --force     force update even if already up to date
+import os
+import log
+import flag
+import time
+import vweb
+import net.urllib
+
+// git credentials
+const (
+	git_username = os.getenv('GITUSER')
+	git_password = os.getenv('GITPASS')
+)
+
+// repository
+const (
+	// git repo
+	git_repo_v      = 'github.com/vlang/v'
+	git_repo_vc     = 'github.com/vlang/vc'
+	// local repo directories
+	git_repo_dir_v  = 'v'
+	git_repo_dir_vc = 'vc'
+)
+
+// gen_vc
+const (
+	// name
+	app_name             = 'gen_vc'
+	// version
+	app_version          = '0.1.2'
+	// description
+	app_description      = "This tool regenerates V\'s bootstrap .c files every time the V master branch is updated."
+	// assume something went wrong if file size less than this
+	too_short_file_limit = 5000
+	// create a .c file for these os's
+	vc_build_oses        = [
+		'nix', // all nix based os
+		'windows',
+	]
+)
+
+// default options (overridden by flags)
+const (
+	// gen_vc working directory
+	work_dir    = '/tmp/gen_vc'
+	// dont push anything to remote repo
+	dry_run     = false
+	// server port
+	server_port = 7171
+	// log file
+	log_file    = '$work_dir/log.txt'
+	// log_to is either 'file' or 'terminal'
+	log_to      = 'terminal'
+)
+
+// errors
+const (
+	err_msg_build = 'error building'
+	err_msg_make  = 'make failed'
+	err_msg_gen_c = 'failed to generate .c file'
+	err_msg_cmd_x = 'error running cmd'
+)
+
+struct GenVC {
+	// logger
+	// flag options
+	options   FlagOptions
+mut:
+	logger    &log.Log
+	// true if error was experienced running generate
+	gen_error bool
+}
+
+// webhook server
+struct WebhookServer {
+pub mut:
+	vweb   vweb.Context
+	gen_vc &GenVC
+}
+
+// storage for flag options
+struct FlagOptions {
+	work_dir string
+	purge    bool
+	serve    bool
+	port     int
+	log_to   string
+	log_file string
+	dry_run  bool
+	force    bool
+}
+
+fn main() {
+	mut fp := flag.new_flag_parser(os.args.clone())
+	fp.application(app_name)
+	fp.version(app_version)
+	fp.description(app_description)
+	fp.skip_executable()
+	show_help := fp.bool('help', 0, false, 'Show this help screen\n')
+	flag_options := parse_flags(mut fp)
+	if show_help {
+		println(fp.usage())
+		exit(0)
+	}
+	fp.finalize() or {
+		eprintln(err)
+		println(fp.usage())
+		return
+	}
+	// webhook server mode
+	if flag_options.serve {
+		vweb.run<WebhookServer>(flag_options.port)
+	} else {
+		// cmd mode
+		mut gen_vc := new_gen_vc(flag_options)
+		gen_vc.init()
+		gen_vc.generate()
+	}
+}
+
+// new GenVC
+fn new_gen_vc(flag_options FlagOptions) &GenVC {
+	mut logger := &log.Log{}
+	logger.set_level(.debug)
+	if flag_options.log_to == 'file' {
+		logger.set_full_logpath(flag_options.log_file)
+	}
+	return &GenVC{
+		options: flag_options
+		logger: logger
+	}
+}
+
+// WebhookServer init
+pub fn (mut ws WebhookServer) init_once() {
+	mut fp := flag.new_flag_parser(os.args.clone())
+	flag_options := parse_flags(mut fp)
+	ws.gen_vc = new_gen_vc(flag_options)
+	ws.gen_vc.init()
+	// ws.gen_vc = new_gen_vc(flag_options)
+}
+
+pub fn (mut ws WebhookServer) init() {
+	// ws.init_once()
+}
+
+pub fn (mut ws WebhookServer) index() {
+	eprintln('WebhookServer.index() called')
+}
+
+// gen webhook
+pub fn (mut ws WebhookServer) genhook() {
+	// request data
+	// println(ws.vweb.req.data)
+	// TODO: parse request. json or urlencoded
+	// json.decode or net.urllib.parse
+	ws.gen_vc.generate()
+	// error in generate
+	if ws.gen_vc.gen_error {
+		ws.vweb.json('{status: "failed"}')
+		return
+	}
+	ws.vweb.json('{status: "ok"}')
+}
+
+pub fn (ws &WebhookServer) reset() {
+}
+
+// parse flags to FlagOptions struct
+fn parse_flags(mut fp flag.FlagParser) FlagOptions {
+	return FlagOptions{
+		serve: fp.bool('serve', 0, false, 'run in webhook server mode')
+		work_dir: fp.string('work-dir', 0, work_dir, 'gen_vc working directory')
+		purge: fp.bool('purge', 0, false, 'force purge the local repositories')
+		port: fp.int('port', 0, server_port, 'port for web server to listen on')
+		log_to: fp.string('log-to', 0, log_to, "log to is \'file\' or \'terminal\'")
+		log_file: fp.string('log-file', 0, log_file, "log file to use when log-to is \'file\'")
+		dry_run: fp.bool('dry-run', 0, dry_run, 'when specified dont push anything to remote repo')
+		force: fp.bool('force', 0, false, 'force update even if already up to date')
+	}
+}
+
+// init
+fn (mut gen_vc GenVC) init() {
+	// purge repos if flag is passed
+	if gen_vc.options.purge {
+		gen_vc.purge_repos()
+	}
+}
+
+// regenerate
+fn (mut gen_vc GenVC) generate() {
+	// set errors to false
+	gen_vc.gen_error = false
+	// check if gen_vc dir exists
+	if !os.is_dir(gen_vc.options.work_dir) {
+		// try create
+		os.mkdir(gen_vc.options.work_dir) or {
+			panic(err)
+		}
+		// still dosen't exist... we have a problem
+		if !os.is_dir(gen_vc.options.work_dir) {
+			gen_vc.logger.error('error creating directory: $gen_vc.options.work_dir')
+			gen_vc.gen_error = true
+			return
+		}
+	}
+	// cd to gen_vc dir
+	os.chdir(gen_vc.options.work_dir)
+	// if we are not running with the --serve flag (webhook server)
+	// rather than deleting and re-downloading the repo each time
+	// first check to see if the local v repo is behind master
+	// if it isn't behind theres no point continuing further
+	if !gen_vc.options.serve && os.is_dir(git_repo_dir_v) {
+		gen_vc.cmd_exec('git -C $git_repo_dir_v checkout master')
+		// fetch the remote repo just in case there are newer commits there
+		gen_vc.cmd_exec('git -C $git_repo_dir_v fetch')
+		git_status := gen_vc.cmd_exec('git -C $git_repo_dir_v status')
+		if !git_status.contains('behind') && !gen_vc.options.force {
+			gen_vc.logger.warn('v repository is already up to date.')
+			return
+		}
+	}
+	// delete repos
+	gen_vc.purge_repos()
+	// clone repos
+	gen_vc.cmd_exec('git clone --depth 1 https://$git_repo_v $git_repo_dir_v')
+	gen_vc.cmd_exec('git clone --depth 1 https://$git_repo_vc $git_repo_dir_vc')
+	// get output of git log -1 (last commit)
+	git_log_v := gen_vc.cmd_exec('git -C $git_repo_dir_v log -1 --format="commit %H%nDate: %ci%nDate Unix: %ct%nSubject: %s"')
+	git_log_vc := gen_vc.cmd_exec('git -C $git_repo_dir_vc log -1 --format="Commit %H%nDate: %ci%nDate Unix: %ct%nSubject: %s"')
+	// date of last commit in each repo
+	ts_v := git_log_v.find_between('Date:', '\n').trim_space()
+	ts_vc := git_log_vc.find_between('Date:', '\n').trim_space()
+	// parse time as string to time.Time
+	last_commit_time_v := time.parse(ts_v) or {
+		panic(err)
+	}
+	last_commit_time_vc := time.parse(ts_vc) or {
+		panic(err)
+	}
+	// git dates are in users local timezone and v time.parse does not parse
+	// timezones at the moment, so for now get unix timestamp from output also
+	t_unix_v := git_log_v.find_between('Date Unix:', '\n').trim_space().int()
+	t_unix_vc := git_log_vc.find_between('Date Unix:', '\n').trim_space().int()
+	// last commit hash in v repo
+	last_commit_hash_v := git_log_v.find_between('commit', '\n').trim_space()
+	last_commit_hash_v_short := last_commit_hash_v[..7]
+	// subject
+	last_commit_subject := git_log_v.find_between('Subject:', '\n').trim_space().replace('"',
+		'\\"')
+	// log some info
+	gen_vc.logger.debug('last commit time ($git_repo_v): ' + last_commit_time_v.format_ss())
+	gen_vc.logger.debug('last commit time ($git_repo_vc): ' + last_commit_time_vc.format_ss())
+	gen_vc.logger.debug('last commit hash ($git_repo_v): $last_commit_hash_v')
+	gen_vc.logger.debug('last commit subject ($git_repo_v): $last_commit_subject')
+	// if vc repo already has a newer commit than the v repo, assume it's up to date
+	if t_unix_vc >= t_unix_v && !gen_vc.options.force {
+		gen_vc.logger.warn('vc repository is already up to date.')
+		return
+	}
+	// try build v for current os (linux in this case)
+	gen_vc.cmd_exec('make -C $git_repo_dir_v')
+	v_exec := '$git_repo_dir_v/v'
+	// check if make was successful
+	gen_vc.assert_file_exists_and_is_not_too_short(v_exec, err_msg_make)
+	// build v.c for each os
+	for os_name in vc_build_oses {
+		vc_suffix := if os_name == 'nix' { '' } else { '_${os_name[..3]}' }
+		v_flags := if os_name == 'nix' { '-os cross' } else { '-os $os_name' }
+		c_file := 'v${vc_suffix}.c'
+		// try generate .c file
+		gen_vc.cmd_exec('$v_exec $v_flags -o $c_file $git_repo_dir_v/cmd/v')
+		// check if the c file seems ok
+		gen_vc.assert_file_exists_and_is_not_too_short(c_file, err_msg_gen_c)
+		// embed the latest v commit hash into the c file
+		gen_vc.cmd_exec('sed -i \'1s/^/#define V_COMMIT_HASH "$last_commit_hash_v_short"\\n/\' $c_file')
+		// move to vc repo
+		gen_vc.cmd_exec('mv $c_file $git_repo_dir_vc/$c_file')
+		// add new .c file to local vc repo
+		gen_vc.cmd_exec('git -C $git_repo_dir_vc add $c_file')
+	}
+	// check if the vc repo actually changed
+	git_status := gen_vc.cmd_exec('git -C $git_repo_dir_vc status')
+	if git_status.contains('nothing to commit') {
+		gen_vc.logger.error('no changes to vc repo: something went wrong.')
+		gen_vc.gen_error = true
+	}
+	// commit changes to local vc repo
+	gen_vc.cmd_exec_safe('git -C $git_repo_dir_vc commit -m "[v:master] $last_commit_hash_v_short - $last_commit_subject"')
+	// push changes to remote vc repo
+	gen_vc.cmd_exec_safe('git -C $git_repo_dir_vc push https://${urllib.query_escape(git_username)}:${urllib.query_escape(git_password)}@$git_repo_vc master')
+}
+
+// only execute when dry_run option is false, otherwise just log
+fn (mut gen_vc GenVC) cmd_exec_safe(cmd string) string {
+	return gen_vc.command_execute(cmd, gen_vc.options.dry_run)
+}
+
+// always execute command
+fn (mut gen_vc GenVC) cmd_exec(cmd string) string {
+	return gen_vc.command_execute(cmd, false)
+}
+
+// execute command
+fn (mut gen_vc GenVC) command_execute(cmd string, dry bool) string {
+	// if dry is true then dont execute, just log
+	if dry {
+		return gen_vc.command_execute_dry(cmd)
+	}
+	gen_vc.logger.info('cmd: $cmd')
+	r := os.exec(cmd) or {
+		gen_vc.logger.error('$err_msg_cmd_x: "$cmd" could not start.')
+		gen_vc.logger.error(err)
+		// something went wrong, better start fresh next time
+		gen_vc.purge_repos()
+		gen_vc.gen_error = true
+		return ''
+	}
+	if r.exit_code != 0 {
+		gen_vc.logger.error('$err_msg_cmd_x: "$cmd" failed.')
+		gen_vc.logger.error(r.output)
+		// something went wrong, better start fresh next time
+		gen_vc.purge_repos()
+		gen_vc.gen_error = true
+		return ''
+	}
+	return r.output
+}
+
+// just log cmd, dont execute
+fn (mut gen_vc GenVC) command_execute_dry(cmd string) string {
+	gen_vc.logger.info('cmd (dry): "$cmd"')
+	return ''
+}
+
+// delete repo directories
+fn (mut gen_vc GenVC) purge_repos() {
+	// delete old repos (better to be fully explicit here, since these are destructive operations)
+	mut repo_dir := '$gen_vc.options.work_dir/$git_repo_dir_v'
+	if os.is_dir(repo_dir) {
+		gen_vc.logger.info('purging local repo: "$repo_dir"')
+		gen_vc.cmd_exec('rm -rf $repo_dir')
+	}
+	repo_dir = '$gen_vc.options.work_dir/$git_repo_dir_vc'
+	if os.is_dir(repo_dir) {
+		gen_vc.logger.info('purging local repo: "$repo_dir"')
+		gen_vc.cmd_exec('rm -rf $repo_dir')
+	}
+}
+
+// check if file size is too short
+fn (mut gen_vc GenVC) assert_file_exists_and_is_not_too_short(f string, emsg string) {
+	if !os.exists(f) {
+		gen_vc.logger.error('$err_msg_build: $emsg .')
+		gen_vc.gen_error = true
+		return
+	}
+	fsize := os.file_size(f)
+	if fsize < too_short_file_limit {
+		gen_vc.logger.error('$err_msg_build: $f exists, but is too short: only $fsize bytes.')
+		gen_vc.gen_error = true
+		return
+	}
+}

cmd/tools/modules/scripting/scripting.v

@@ -0,0 +1,121 @@
+module scripting
+
+import os
+import term
+
+const (
+	term_colors = term.can_show_color_on_stdout()
+)
+
+pub fn set_verbose(on bool) {
+	// setting a global here would be the obvious solution,
+	// but V does not have globals normally.
+	if on {
+		os.setenv('VERBOSE', '1', true)
+	}
+	else {
+		os.unsetenv('VERBOSE')
+	}
+}
+
+pub fn cprintln(message string) {
+	mut omessage := message
+	omessage = if term_colors { term.green(omessage) } else { omessage }
+	println(omessage)
+}
+
+pub fn verbose_trace(label string, message string) {
+	if os.getenv('VERBOSE').len > 0 {
+		slabel := 'scripting.${label}'
+		cprintln('# ${slabel:-25s} : $message')
+	}
+}
+
+pub fn verbose_trace_exec_result(x os.Result) {
+	if os.getenv('VERBOSE').len > 0 {
+		cprintln('#   cmd.exit_code : ${x.exit_code.str():-4s}  cmd.output:')
+		cprintln('# ----------------------------------- #')
+		mut lnum := 1
+		lines := x.output.split_into_lines()
+		for line in lines {
+			cprintln('# ${lnum:3d}: $line')
+			lnum++
+		}
+		cprintln('# ----------------------------------- #')
+	}
+}
+
+pub fn chdir(path string) {
+	verbose_trace(@FN, 'cd $path')
+	os.chdir(path)
+}
+
+pub fn rmrf(path string) {
+	verbose_trace(@FN, 'rm -rf $path')
+	if os.exists(path) {
+		if os.is_dir(path) {
+			os.rmdir_all(path)
+		}else{
+			os.rm(path)
+		}
+	}
+}
+
+pub fn exec(cmd string) ?os.Result {
+	verbose_trace(@FN, cmd)
+	x := os.exec(cmd) or {
+		verbose_trace(@FN, '## failed.')
+		return error(err)
+	}
+	verbose_trace_exec_result(x)
+	return x
+}
+
+pub fn run(cmd string) string {
+	verbose_trace(@FN, cmd)
+	x := os.exec(cmd) or {
+		verbose_trace(@FN, '## failed.')
+		return ''
+	}
+	verbose_trace_exec_result(x)
+	if x.exit_code == 0 {
+		return x.output.trim_right('\r\n')
+	}
+	return ''
+}
+
+pub fn exit_0_status(cmd string) bool {
+	verbose_trace(@FN, cmd)
+	x := os.exec(cmd) or {
+		verbose_trace(@FN, '## failed.')
+		return false
+	}
+	verbose_trace_exec_result(x)
+	if x.exit_code == 0 {
+		return true
+	}
+	return false
+}
+
+pub fn tool_must_exist (toolcmd string) {
+	verbose_trace(@FN, toolcmd)
+	if exit_0_status('type $toolcmd') {
+		return
+	}
+	eprintln('Missing tool: $toolcmd')
+	eprintln('Please try again after you install it.')
+	exit(1)
+}
+
+pub fn used_tools_must_exist(tools []string) {
+	for t in tools {
+		tool_must_exist(t)
+	}
+}
+
+pub fn show_sizes_of_files(files []string) {
+	for f in files {
+		size := os.file_size(f)
+		println('${size:10d} $f')
+	}
+}

cmd/tools/modules/testing/common.v

@@ -0,0 +1,398 @@
+module testing
+
+import os
+import time
+import term
+import benchmark
+import sync
+import v.pref
+import v.util.vtest
+
+pub struct TestSession {
+pub mut:
+	files         []string
+	skip_files    []string
+	vexe          string
+	vroot         string
+	vtmp_dir      string
+	vargs         string
+	failed        bool
+	benchmark     benchmark.Benchmark
+	rm_binaries   bool = true
+	silent_mode   bool
+	progress_mode bool
+	root_relative bool // used by CI runs, so that the output is stable everywhere
+	nmessages     chan LogMessage // many publishers, single consumer/printer
+	nmessage_idx  int // currently printed message index
+	nprint_ended  chan int // read to block till printing ends, 1:1
+}
+
+enum MessageKind {
+	ok
+	fail
+	skip
+	sentinel
+}
+
+struct LogMessage {
+	message string
+	kind    MessageKind
+}
+
+pub fn (mut ts TestSession) append_message(kind MessageKind, msg string) {
+	ts.nmessages <- LogMessage{
+		message: msg
+		kind: kind
+	}
+}
+
+pub fn (mut ts TestSession) print_messages() {
+	empty := term.header(' ', ' ')
+	mut print_msg_time := time.new_stopwatch({})
+	for {
+		// get a message from the channel of messages to be printed:
+		mut rmessage := <-ts.nmessages
+		if rmessage.kind == .sentinel {
+			// a sentinel for stopping the printing thread
+			if !ts.silent_mode && ts.progress_mode {
+				eprintln('')
+			}
+			ts.nprint_ended <- 0
+			return
+		}
+		ts.nmessage_idx++
+		msg := rmessage.message.replace_each([
+			'TMP1',
+			'${ts.nmessage_idx:1d}',
+			'TMP2',
+			'${ts.nmessage_idx:2d}',
+			'TMP3',
+			'${ts.nmessage_idx:3d}',
+			'TMP4',
+			'${ts.nmessage_idx:4d}',
+		])
+		is_ok := rmessage.kind == .ok
+		//
+		time_passed := print_msg_time.elapsed().seconds()
+		if time_passed > 10 && ts.silent_mode && is_ok {
+			// Even if OK tests are suppressed,
+			// show *at least* 1 result every 10 seconds,
+			// otherwise the CI can seem stuck ...
+			eprintln(msg)
+			print_msg_time.restart()
+			continue
+		}
+		if ts.progress_mode {
+			// progress mode, the last line is rewritten many times:
+			if is_ok && !ts.silent_mode {
+				print('\r$empty\r$msg')
+			} else {
+				// the last \n is needed, so SKIP/FAIL messages
+				// will not get overwritten by the OK ones
+				eprint('\r$empty\r$msg\n')
+			}
+			continue
+		}
+		if !ts.silent_mode || !is_ok {
+			// normal expanded mode, or failures in -silent mode
+			eprintln(msg)
+			continue
+		}
+	}
+}
+
+pub fn new_test_session(_vargs string) TestSession {
+	mut skip_files := []string{}
+	skip_files << '_non_existing_'
+	$if solaris {
+		skip_files << 'examples/gg/gg2.v'
+		skip_files << 'examples/pico/pico.v'
+		skip_files << 'examples/sokol/fonts.v'
+		skip_files << 'examples/sokol/drawing.v'
+	}
+	vargs := _vargs.replace('-progress', '').replace('-progress', '')
+	vexe := pref.vexe_path()
+	new_vtmp_dir := setup_new_vtmp_folder()
+	return TestSession{
+		vexe: vexe
+		vroot: os.dir(vexe)
+		skip_files: skip_files
+		vargs: vargs
+		vtmp_dir: new_vtmp_dir
+		silent_mode: _vargs.contains('-silent')
+		progress_mode: _vargs.contains('-progress')
+	}
+}
+
+pub fn (mut ts TestSession) init() {
+	ts.files.sort()
+	ts.benchmark = benchmark.new_benchmark_no_cstep()
+}
+
+pub fn (mut ts TestSession) test() {
+	// Ensure that .tmp.c files generated from compiling _test.v files,
+	// are easy to delete at the end, *without* affecting the existing ones.
+	current_wd := os.getwd()
+	if current_wd == os.wd_at_startup && current_wd == ts.vroot {
+		ts.root_relative = true
+	}
+	//
+	ts.init()
+	mut remaining_files := []string{}
+	for dot_relative_file in ts.files {
+		relative_file := dot_relative_file.replace('./', '')
+		file := os.real_path(relative_file)
+		$if windows {
+			if file.contains('sqlite') || file.contains('httpbin') {
+				continue
+			}
+		}
+		$if !macos {
+			if file.contains('customer') {
+				continue
+			}
+		}
+		$if msvc {
+			if file.contains('asm') {
+				continue
+			}
+		}
+		$if tinyc {
+			if file.contains('asm') {
+				continue
+			}
+		}
+		remaining_files << dot_relative_file
+	}
+	remaining_files = vtest.filter_vtest_only(remaining_files, {
+		fix_slashes: false
+	})
+	ts.files = remaining_files
+	ts.benchmark.set_total_expected_steps(remaining_files.len)
+	mut pool_of_test_runners := sync.new_pool_processor({
+		callback: worker_trunner
+	})
+	// for handling messages across threads
+	ts.nmessages = chan LogMessage{cap: 10000}
+	ts.nprint_ended = chan int{cap: 0}
+	ts.nmessage_idx = 0
+	go ts.print_messages()
+	pool_of_test_runners.set_shared_context(ts)
+	pool_of_test_runners.work_on_pointers(remaining_files.pointers())
+	ts.benchmark.stop()
+	ts.append_message(.sentinel, '') // send the sentinel
+	_ := <-ts.nprint_ended // wait for the stop of the printing thread
+	eprintln(term.h_divider('-'))
+	// cleanup generated .tmp.c files after successfull tests:
+	if ts.benchmark.nfail == 0 {
+		if ts.rm_binaries {
+			os.rmdir_all(ts.vtmp_dir)
+		}
+	}
+}
+
+fn worker_trunner(mut p sync.PoolProcessor, idx int, thread_id int) voidptr {
+	mut ts := &TestSession(p.get_shared_context())
+	tmpd := ts.vtmp_dir
+	show_stats := '-stats' in ts.vargs.split(' ')
+	// tls_bench is used to format the step messages/timings
+	mut tls_bench := &benchmark.Benchmark(p.get_thread_context(idx))
+	if isnil(tls_bench) {
+		tls_bench = benchmark.new_benchmark_pointer()
+		tls_bench.set_total_expected_steps(ts.benchmark.nexpected_steps)
+		p.set_thread_context(idx, tls_bench)
+	}
+	tls_bench.no_cstep = true
+	dot_relative_file := p.get_string_item(idx)
+	mut relative_file := dot_relative_file.replace('./', '')
+	if ts.root_relative {
+		relative_file = relative_file.replace(ts.vroot + os.path_separator, '')
+	}
+	file := os.real_path(relative_file)
+	// Ensure that the generated binaries will be stored in the temporary folder.
+	// Remove them after a test passes/fails.
+	fname := os.file_name(file)
+	generated_binary_fname := if os.user_os() == 'windows' { fname.replace('.v', '.exe') } else { fname.replace('.v',
+			'') }
+	generated_binary_fpath := os.join_path(tmpd, generated_binary_fname)
+	if os.exists(generated_binary_fpath) {
+		if ts.rm_binaries {
+			os.rm(generated_binary_fpath)
+		}
+	}
+	mut cmd_options := [ts.vargs]
+	if !ts.vargs.contains('fmt') {
+		cmd_options << ' -o "$generated_binary_fpath"'
+	}
+	cmd := '"$ts.vexe" ' + cmd_options.join(' ') + ' "$file"'
+	ts.benchmark.step()
+	tls_bench.step()
+	if relative_file.replace('\\', '/') in ts.skip_files {
+		ts.benchmark.skip()
+		tls_bench.skip()
+		ts.append_message(.skip, tls_bench.step_message_skip(relative_file))
+		return sync.no_result
+	}
+	if show_stats {
+		ts.append_message(.ok, term.h_divider('-'))
+		status := os.system(cmd)
+		if status == 0 {
+			ts.benchmark.ok()
+			tls_bench.ok()
+		} else {
+			ts.failed = true
+			ts.benchmark.fail()
+			tls_bench.fail()
+			return sync.no_result
+		}
+	} else {
+		r := os.exec(cmd) or {
+			ts.failed = true
+			ts.benchmark.fail()
+			tls_bench.fail()
+			ts.append_message(.fail, tls_bench.step_message_fail(relative_file))
+			return sync.no_result
+		}
+		if r.exit_code != 0 {
+			ts.failed = true
+			ts.benchmark.fail()
+			tls_bench.fail()
+			ts.append_message(.fail, tls_bench.step_message_fail('$relative_file\n$r.output\n'))
+		} else {
+			ts.benchmark.ok()
+			tls_bench.ok()
+			ts.append_message(.ok, tls_bench.step_message_ok(relative_file))
+		}
+	}
+	if os.exists(generated_binary_fpath) {
+		if ts.rm_binaries {
+			os.rm(generated_binary_fpath)
+		}
+	}
+	return sync.no_result
+}
+
+pub fn vlib_should_be_present(parent_dir string) {
+	vlib_dir := os.join_path(parent_dir, 'vlib')
+	if !os.is_dir(vlib_dir) {
+		eprintln('$vlib_dir is missing, it must be next to the V executable')
+		exit(1)
+	}
+}
+
+pub fn v_build_failing(zargs string, folder string) bool {
+	return v_build_failing_skipped(zargs, folder, [])
+}
+
+pub fn prepare_test_session(zargs string, folder string, oskipped []string, main_label string) TestSession {
+	vexe := pref.vexe_path()
+	parent_dir := os.dir(vexe)
+	vlib_should_be_present(parent_dir)
+	vargs := zargs.replace(vexe, '')
+	eheader(main_label)
+	if vargs.len > 0 {
+		eprintln('v compiler args: "$vargs"')
+	}
+	mut session := new_test_session(vargs)
+	files := os.walk_ext(os.join_path(parent_dir, folder), '.v')
+	mut mains := []string{}
+	mut skipped := oskipped
+	for f in files {
+		if !f.contains('modules') && !f.contains('preludes') {
+			// $if !linux {
+			// run pg example only on linux
+			if f.contains('/pg/') {
+				continue
+			}
+			// }
+			if f.contains('life_gg') || f.contains('/graph.v') || f.contains('rune.v') {
+				continue
+			}
+			$if windows {
+				// skip pico example on windows
+				if f.ends_with('examples\\pico\\pico.v') {
+					continue
+				}
+			}
+			c := os.read_file(f) or {
+				panic(err)
+			}
+			maxc := if c.len > 300 { 300 } else { c.len }
+			start := c[0..maxc]
+			if start.contains('module ') && !start.contains('module main') {
+				skipped_f := f.replace(os.join_path(parent_dir, ''), '')
+				skipped << skipped_f
+			}
+			mains << f
+		}
+	}
+	session.files << mains
+	session.skip_files << skipped
+	return session
+}
+
+pub fn v_build_failing_skipped(zargs string, folder string, oskipped []string) bool {
+	main_label := 'Building $folder ...'
+	finish_label := 'building $folder'
+	mut session := prepare_test_session(zargs, folder, oskipped, main_label)
+	session.test()
+	eprintln(session.benchmark.total_message(finish_label))
+	return session.failed
+}
+
+pub fn build_v_cmd_failed(cmd string) bool {
+	res := os.exec(cmd) or {
+		return true
+	}
+	if res.exit_code != 0 {
+		eprintln('')
+		eprintln(res.output)
+		return true
+	}
+	return false
+}
+
+pub fn building_any_v_binaries_failed() bool {
+	eheader('Building V binaries...')
+	eprintln('VFLAGS is: "' + os.getenv('VFLAGS') + '"')
+	vexe := pref.vexe_path()
+	parent_dir := os.dir(vexe)
+	vlib_should_be_present(parent_dir)
+	os.chdir(parent_dir)
+	mut failed := false
+	v_build_commands := ['$vexe -o v_g             -g  cmd/v', '$vexe -o v_prod_g  -prod -g  cmd/v',
+		'$vexe -o v_cg            -cg cmd/v', '$vexe -o v_prod_cg -prod -cg cmd/v', '$vexe -o v_prod    -prod     cmd/v']
+	mut bmark := benchmark.new_benchmark()
+	for cmd in v_build_commands {
+		bmark.step()
+		if build_v_cmd_failed(cmd) {
+			bmark.fail()
+			failed = true
+			eprintln(bmark.step_message_fail('command: $cmd . See details above ^^^^^^^'))
+			eprintln('')
+			continue
+		}
+		bmark.ok()
+		eprintln(bmark.step_message_ok('command: $cmd'))
+	}
+	bmark.stop()
+	eprintln(term.h_divider('-'))
+	eprintln(bmark.total_message('building v binaries'))
+	return failed
+}
+
+pub fn eheader(msg string) {
+	eprintln(term.header(msg, '-'))
+}
+
+pub fn header(msg string) {
+	println(term.header(msg, '-'))
+}
+
+pub fn setup_new_vtmp_folder() string {
+	now := time.sys_mono_now()
+	new_vtmp_dir := os.join_path(os.temp_dir(), 'v', 'test_session_$now')
+	os.mkdir_all(new_vtmp_dir)
+	os.setenv('VTMP', new_vtmp_dir, true)
+	return new_vtmp_dir
+}

cmd/tools/modules/vgit/vgit.v

@@ -0,0 +1,176 @@
+module vgit
+
+import os
+import flag
+import scripting
+
+const (
+	remote_v_repo_url  = 'https://github.com/vlang/v'
+	remote_vc_repo_url = 'https://github.com/vlang/vc'
+)
+
+pub fn check_v_commit_timestamp_before_self_rebuilding(v_timestamp int) {
+	if v_timestamp >= 1561805697 {
+		return
+	}
+	eprintln('##################################################################')
+	eprintln('# WARNING: v self rebuilding, before 5b7a1e8 (2019-06-29 12:21)  #')
+	eprintln('#          required the v executable to be built *inside*        #')
+	eprintln('#          the toplevel compiler/ folder.                        #')
+	eprintln('#                                                                #')
+	eprintln('#          That is not supported by this tool.                   #')
+	eprintln('#          You will have to build it manually there.             #')
+	eprintln('##################################################################')
+}
+
+pub fn validate_commit_exists(commit string) {
+	if commit.len == 0 {
+		return
+	}
+	cmd := "git cat-file -t \'$commit\' "
+	if !scripting.exit_0_status(cmd) {
+		eprintln('Commit: "$commit" does not exist in the current repository.')
+		exit(3)
+	}
+}
+
+pub fn line_to_timestamp_and_commit(line string) (int, string) {
+	parts := line.split(' ')
+	return parts[0].int(), parts[1]
+}
+
+pub fn normalized_workpath_for_commit(workdir string, commit string) string {
+	nc := 'v_at_' + commit.replace('^', '_').replace('-', '_').replace('/', '_')
+	return os.real_path(workdir + os.path_separator + nc)
+}
+
+pub fn prepare_vc_source(vcdir string, cdir string, commit string) (string, string) {
+	scripting.chdir(cdir)
+	// Building a historic v with the latest vc is not always possible ...
+	// It is more likely, that the vc *at the time of the v commit*,
+	// or slightly before that time will be able to build the historic v:
+	vline := scripting.run('git rev-list -n1 --timestamp "$commit" ')
+	v_timestamp, v_commithash := line_to_timestamp_and_commit(vline)
+	check_v_commit_timestamp_before_self_rebuilding(v_timestamp)
+	scripting.chdir(vcdir)
+	scripting.run('git checkout master')
+	vcbefore := scripting.run('git rev-list HEAD -n1 --timestamp --before=$v_timestamp ')
+	_, vccommit_before := line_to_timestamp_and_commit(vcbefore)
+	scripting.run('git checkout "$vccommit_before" ')
+	scripting.run('wc *.c')
+	scripting.chdir(cdir)
+	return v_commithash, vccommit_before
+}
+
+pub fn clone_or_pull(remote_git_url string, local_worktree_path string) {
+	// NB: after clone_or_pull, the current repo branch is === HEAD === master
+	if os.is_dir(local_worktree_path) && os.is_dir(os.join_path(local_worktree_path, '.git')) {
+		// Already existing ... Just pulling in this case is faster usually.
+		scripting.run('git -C "$local_worktree_path"  checkout --quiet master')
+		scripting.run('git -C "$local_worktree_path"  pull     --quiet ')
+	} else {
+		// Clone a fresh
+		scripting.run('git clone --quiet "$remote_git_url"  "$local_worktree_path" ')
+	}
+}
+
+pub struct VGitContext {
+pub:
+	cc             string = 'cc' // what compiler to use
+	workdir        string = '/tmp' // the base working folder
+	commit_v       string = 'master' // the commit-ish that needs to be prepared
+	path_v         string // where is the local working copy v repo
+	path_vc        string // where is the local working copy vc repo
+	v_repo_url     string // the remote v repo URL
+	vc_repo_url    string // the remote vc repo URL
+pub mut:
+	// these will be filled by vgitcontext.compile_oldv_if_needed()
+	commit_v__hash string // the git commit of the v repo that should be prepared
+	commit_vc_hash string // the git commit of the vc repo, corresponding to commit_v__hash
+	vexename       string // v or v.exe
+	vexepath       string // the full absolute path to the prepared v/v.exe
+	vvlocation     string // v.v or compiler/ or cmd/v, depending on v version
+}
+
+pub fn (mut vgit_context VGitContext) compile_oldv_if_needed() {
+	vgit_context.vexename = if os.user_os() == 'windows' { 'v.exe' } else { 'v' }
+	vgit_context.vexepath = os.real_path(os.join_path(vgit_context.path_v, vgit_context.vexename))
+	mut command_for_building_v_from_c_source := ''
+	mut command_for_selfbuilding := ''
+	if 'windows' == os.user_os() {
+		command_for_building_v_from_c_source = '$vgit_context.cc -std=c99 -municode -w -o cv.exe  "$vgit_context.path_vc/v_win.c" '
+		command_for_selfbuilding = './cv.exe -o $vgit_context.vexename {SOURCE}'
+	} else {
+		command_for_building_v_from_c_source = '$vgit_context.cc -std=gnu11 -w -o cv "$vgit_context.path_vc/v.c"  -lm -lpthread'
+		command_for_selfbuilding = './cv -o $vgit_context.vexename {SOURCE}'
+	}
+	scripting.chdir(vgit_context.workdir)
+	clone_or_pull(vgit_context.v_repo_url, vgit_context.path_v)
+	clone_or_pull(vgit_context.vc_repo_url, vgit_context.path_vc)
+	scripting.chdir(vgit_context.path_v)
+	scripting.run('git checkout $vgit_context.commit_v')
+	v_commithash, vccommit_before := prepare_vc_source(vgit_context.path_vc, vgit_context.path_v,
+		vgit_context.commit_v)
+	vgit_context.commit_v__hash = v_commithash
+	vgit_context.commit_vc_hash = vccommit_before
+	if os.exists('cmd/v') {
+		vgit_context.vvlocation = 'cmd/v'
+	} else {
+		vgit_context.vvlocation = if os.exists('v.v') { 'v.v' } else { 'compiler' }
+	}
+	if os.is_dir(vgit_context.path_v) && os.exists(vgit_context.vexepath) {
+		// already compiled, so no need to compile v again
+		return
+	}
+	// Recompilation is needed. Just to be sure, clean up everything first.
+	scripting.run('git clean -xf')
+	scripting.run(command_for_building_v_from_c_source)
+	build_cmd := command_for_selfbuilding.replace('{SOURCE}', vgit_context.vvlocation)
+	scripting.run(build_cmd)
+	// At this point, there exists a file vgit_context.vexepath
+	// which should be a valid working V executable.
+}
+
+pub struct VGitOptions {
+pub mut:
+	workdir     string // the working folder (typically /tmp), where the tool will write
+	v_repo_url  string // the url of the V repository. It can be a local folder path, if you want to eliminate network operations...
+	vc_repo_url string // the url of the vc repository. It can be a local folder path, if you want to eliminate network operations...
+	show_help   bool // whether to show the usage screen
+	verbose     bool // should the tool be much more verbose
+}
+
+pub fn add_common_tool_options(mut context VGitOptions, mut fp flag.FlagParser) []string {
+	tdir := os.temp_dir()
+	context.workdir = os.real_path(fp.string('workdir', `w`, tdir, 'A writable base folder. Default: $tdir'))
+	context.v_repo_url = fp.string('vrepo', 0, remote_v_repo_url, 'The url of the V repository. You can clone it locally too. See also --vcrepo below.')
+	context.vc_repo_url = fp.string('vcrepo', 0, remote_vc_repo_url, 'The url of the vc repository. You can clone it
+${flag.space}beforehand, and then just give the local folder
+${flag.space}path here. That will eliminate the network ops
+${flag.space}done by this tool, which is useful, if you want
+${flag.space}to script it/run it in a restrictive vps/docker.
+')
+	context.show_help = fp.bool('help', `h`, false, 'Show this help screen.')
+	context.verbose = fp.bool('verbose', `v`, false, 'Be more verbose.')
+	if context.show_help {
+		println(fp.usage())
+		exit(0)
+	}
+	if context.verbose {
+		scripting.set_verbose(true)
+	}
+	if os.is_dir(context.v_repo_url) {
+		context.v_repo_url = os.real_path(context.v_repo_url)
+	}
+	if os.is_dir(context.vc_repo_url) {
+		context.vc_repo_url = os.real_path(context.vc_repo_url)
+	}
+	commits := fp.finalize() or {
+		eprintln('Error: ' + err)
+		exit(1)
+	}
+	for commit in commits {
+		validate_commit_exists(commit)
+	}
+	return commits
+}

cmd/tools/modules/vhelp/vhelp.v

@@ -0,0 +1,15 @@
+module vhelp
+
+import os
+
+pub fn show_topic(topic string) {
+	vexe := os.real_path(os.getenv('VEXE'))
+	vroot := os.dir(vexe)
+	target_topic := os.join_path(vroot, 'cmd', 'v', 'help', '${topic}.txt')
+	content := os.read_file(target_topic) or {
+		eprintln('Unknown topic: $topic')
+		exit(1)
+	}
+	println(content)
+}
+

cmd/tools/oldv.v

@@ -0,0 +1,110 @@
+import os
+import flag
+import scripting
+import vgit
+
+const (
+	tool_version     = '0.0.3'
+	tool_description = '  Checkout an old V and compile it as it was on specific commit.
+|     This tool is useful, when you want to discover when something broke.
+|     It is also useful, when you just want to experiment with an older historic V.
+|
+|     The VCOMMIT argument can be a git commitish like HEAD or master and so on.
+|     When oldv is used with git bisect, you probably want to give HEAD. For example:
+|          git bisect start
+|          git bisect bad
+|          git checkout known_good_commit
+|          git bisect good
+|              ## Now git will automatically checkout a middle commit between the bad and the good
+|          cmd/tools/oldv HEAD --command="run commands in oldv folder, to verify if the commit is good or bad"
+|              ## See what the result is, and either do: ...
+|          git bisect good
+|              ## ... or do:
+|          git bisect bad
+|              ## Now you just repeat the above steps, each time running oldv with the same command, then mark the result as good or bad,
+|              ## until you find the commit, where the problem first occurred.
+|              ## When you finish, do not forget to do:
+|          git bisect reset'.strip_margin()
+)
+
+struct Context {
+mut:
+	vgo           vgit.VGitOptions
+	commit_v      string = 'master'
+	// the commit from which you want to produce a working v compiler (this may be a commit-ish too)
+	commit_vc     string = 'master'
+	// this will be derived from commit_v
+	commit_v_hash string // this will be filled from the commit-ish commit_v using rev-list. It IS a commit hash.
+	path_v        string // the full path to the v folder inside workdir.
+	path_vc       string // the full path to the vc folder inside workdir.
+	cmd_to_run    string // the command that you want to run *in* the oldv repo
+	cc            string = 'cc'
+	// the C compiler to use for bootstrapping.
+	cleanup       bool // should the tool run a cleanup first
+}
+
+fn (mut c Context) compile_oldv_if_needed() {
+	mut vgit_context := vgit.VGitContext{
+		workdir: c.vgo.workdir
+		v_repo_url: c.vgo.v_repo_url
+		vc_repo_url: c.vgo.vc_repo_url
+		cc: c.cc
+		commit_v: c.commit_v
+		path_v: c.path_v
+		path_vc: c.path_vc
+	}
+	vgit_context.compile_oldv_if_needed()
+	c.commit_v_hash = vgit_context.commit_v__hash
+	if !os.exists(vgit_context.vexepath) && c.cmd_to_run.len > 0 {
+		// NB: 125 is a special code, that git bisect understands as 'skip this commit'.
+		// it is used to inform git bisect that the current commit leads to a build failure.
+		exit(125)
+	}
+}
+
+fn main() {
+	scripting.used_tools_must_exist(['git', 'cc'])
+	mut context := Context{}
+	mut fp := flag.new_flag_parser(os.args)
+	fp.application(os.file_name(os.executable()))
+	fp.version(tool_version)
+	fp.description(tool_description)
+	fp.arguments_description('VCOMMIT')
+	fp.skip_executable()
+	fp.limit_free_args(1, 1)
+	context.cleanup = fp.bool('clean', 0, true, 'Clean before running (slower).')
+	context.cmd_to_run = fp.string('command', `c`, '', 'Command to run in the old V repo.\n')
+	commits := vgit.add_common_tool_options(mut context.vgo, mut fp)
+	if commits.len > 0 {
+		context.commit_v = commits[0]
+	} else {
+		context.commit_v = scripting.run('git rev-list -n1 HEAD')
+	}
+	scripting.cprintln('#################  context.commit_v: $context.commit_v #####################')
+	context.path_v = vgit.normalized_workpath_for_commit(context.vgo.workdir, context.commit_v)
+	context.path_vc = vgit.normalized_workpath_for_commit(context.vgo.workdir, 'vc')
+	if !os.is_dir(context.vgo.workdir) {
+		eprintln('Work folder: $context.vgo.workdir , does not exist.')
+		exit(2)
+	}
+	ecc := os.getenv('CC')
+	if ecc != '' {
+		context.cc = ecc
+	}
+	if context.cleanup {
+		scripting.rmrf(context.path_v)
+		scripting.rmrf(context.path_vc)
+	}
+	context.compile_oldv_if_needed()
+	scripting.chdir(context.path_v)
+	scripting.cprintln('#     v commit hash: $context.commit_v_hash')
+	scripting.cprintln('#   checkout folder: $context.path_v')
+	if context.cmd_to_run.len > 0 {
+		cmdres := os.exec(context.cmd_to_run) or {
+			panic(err)
+		}
+		scripting.cprintln('#           command: ${context.cmd_to_run:-34s} exit code: ${cmdres.exit_code:-4d}  result:')
+		println(cmdres.output)
+		exit(cmdres.exit_code)
+	}
+}

cmd/tools/performance_compare.v

@@ -0,0 +1,194 @@
+import os
+import flag
+import scripting
+import vgit
+
+const (
+	tool_version     = '0.0.5'
+	tool_description = "  Compares V executable size and performance,
+|  between 2 commits from V\'s local git history.
+|  When only one commit is given, it is compared to master.
+|  ".strip_margin()
+)
+
+struct Context {
+	cwd           string // current working folder
+mut:
+	vgo           vgit.VGitOptions
+	a             string // the full path to the 'after' folder inside workdir
+	b             string // the full path to the 'before' folder inside workdir
+	vc            string // the full path to the vc folder inside workdir. It is used during bootstrapping v from the C source.
+	commit_before string // the git commit for the 'before' state
+	commit_after  string // the git commit for the 'after' state
+	warmups       int // how many times to execute a command before gathering stats
+	hyperfineopts string // use for additional CLI options that will be given to the hyperfine command
+	vflags        string // other v options to pass to compared v commands
+}
+
+fn new_context() Context {
+	return Context{
+		cwd: os.getwd()
+		commit_after: 'master'
+		warmups: 4
+	}
+}
+
+fn (c Context) compare_versions() {
+	// Input is validated at this point...
+	// Cleanup artifacts from previous runs of this tool:
+	scripting.chdir(c.vgo.workdir)
+	scripting.run('rm -rf "$c.a" "$c.b" "$c.vc" ')
+	// clone the VC source *just once per comparison*, and reuse it:
+	scripting.run('git clone --quiet "$c.vgo.vc_repo_url" "$c.vc" ')
+	println('Comparing V performance of commit $c.commit_before (before) vs commit $c.commit_after (after) ...')
+	c.prepare_v(c.b, c.commit_before)
+	c.prepare_v(c.a, c.commit_after)
+	scripting.chdir(c.vgo.workdir)
+	if c.vflags.len > 0 {
+		os.setenv('VFLAGS', c.vflags, true)
+	}
+	// The first is the baseline, against which all the others will be compared.
+	// It is the fastest, since hello_world.v has only a single println in it,
+	mut perf_files := []string{}
+	perf_files <<
+		c.compare_v_performance('source_hello', ['vprod @DEBUG@ -o source.c examples/hello_world.v', 'vprod         -o source.c examples/hello_world.v', 'v     @DEBUG@ -o source.c examples/hello_world.v', 'v             -o source.c examples/hello_world.v'])
+	perf_files <<
+		c.compare_v_performance('source_v', ['vprod @DEBUG@ -o source.c @COMPILER@', 'vprod         -o source.c @COMPILER@', 'v     @DEBUG@ -o source.c @COMPILER@', 'v             -o source.c @COMPILER@'])
+	perf_files <<
+		c.compare_v_performance('binary_hello', ['vprod         -o hello    examples/hello_world.v', 'v             -o hello    examples/hello_world.v'])
+	perf_files <<
+		c.compare_v_performance('binary_v', ['vprod         -o binary   @COMPILER@', 'v             -o binary   @COMPILER@'])
+	println('All performance files:')
+	for f in perf_files {
+		println('   $f')
+	}
+}
+
+fn (c &Context) prepare_v(cdir string, commit string) {
+	mut cc := os.getenv('CC')
+	if cc == '' {
+		cc = 'cc'
+	}
+	mut vgit_context := vgit.VGitContext{
+		cc: cc
+		commit_v: commit
+		path_v: cdir
+		path_vc: c.vc
+		workdir: c.vgo.workdir
+		v_repo_url: c.vgo.v_repo_url
+		vc_repo_url: c.vgo.vc_repo_url
+	}
+	vgit_context.compile_oldv_if_needed()
+	scripting.chdir(cdir)
+	println('Making a v compiler in $cdir')
+	scripting.run('./v -cc $cc       -o v     $vgit_context.vvlocation')
+	println('Making a vprod compiler in $cdir')
+	scripting.run('./v -cc $cc -prod -o vprod $vgit_context.vvlocation')
+	println('Stripping and compressing cv v and vprod binaries in $cdir')
+	scripting.run('cp    cv     cv_stripped')
+	scripting.run('cp     v      v_stripped')
+	scripting.run('cp vprod  vprod_stripped')
+	scripting.run('strip *_stripped')
+	scripting.run('cp cv_stripped cv_stripped_upxed')
+	scripting.run('cp  v_stripped  v_stripped_upxed')
+	scripting.run('cp vprod_stripped vprod_stripped_upxed')
+	scripting.run('upx -qqq --lzma    cv_stripped_upxed')
+	scripting.run('upx -qqq --lzma     v_stripped_upxed')
+	scripting.run('upx -qqq --lzma vprod_stripped_upxed')
+	scripting.show_sizes_of_files(['$cdir/cv', '$cdir/cv_stripped', '$cdir/cv_stripped_upxed'])
+	scripting.show_sizes_of_files(['$cdir/v', '$cdir/v_stripped', '$cdir/v_stripped_upxed'])
+	scripting.show_sizes_of_files(['$cdir/vprod', '$cdir/vprod_stripped', '$cdir/vprod_stripped_upxed'])
+	vversion := scripting.run('$cdir/v -version')
+	vcommit := scripting.run('git rev-parse --short  --verify HEAD')
+	println('V version is: $vversion , local source commit: $vcommit')
+	if vgit_context.vvlocation == 'cmd/v' {
+		if os.exists('vlib/v/ast/ast.v') {
+			println('Source lines of the compiler: ' +
+				scripting.run('find cmd/v/ vlib/v/ -name "*.v" | grep -v /tests/ | xargs wc | tail -n -1'))
+		} else {
+			println('Source lines of the compiler: ' +
+				scripting.run('wc cmd/v/*.v vlib/compiler/*.v | tail -n -1'))
+		}
+	} else if vgit_context.vvlocation == 'v.v' {
+		println('Source lines of the compiler: ' + scripting.run('wc v.v vlib/compiler/*.v | tail -n -1'))
+	} else {
+		println('Source lines of the compiler: ' + scripting.run('wc compiler/*.v | tail -n -1'))
+	}
+}
+
+fn (c Context) compare_v_performance(label string, commands []string) string {
+	println('---------------------------------------------------------------------------------')
+	println('Compare v performance when doing the following commands ($label):')
+	mut source_location_a := ''
+	mut source_location_b := ''
+	if os.exists('$c.a/cmd/v') {
+		source_location_a = 'cmd/v'
+	} else {
+		source_location_a = if os.exists('$c.a/v.v') { 'v.v       ' } else { 'compiler/ ' }
+	}
+	if os.exists('$c.b/cmd/v') {
+		source_location_b = 'cmd/v'
+	} else {
+		source_location_b = if os.exists('$c.b/v.v') { 'v.v       ' } else { 'compiler/ ' }
+	}
+	timestamp_a, _ := vgit.line_to_timestamp_and_commit(scripting.run('cd $c.a/ ; git rev-list -n1 --timestamp HEAD'))
+	timestamp_b, _ := vgit.line_to_timestamp_and_commit(scripting.run('cd $c.b/ ; git rev-list -n1 --timestamp HEAD'))
+	debug_option_a := if timestamp_a > 1570877641 { '-cg    ' } else { '-debug ' }
+	debug_option_b := if timestamp_b > 1570877641 { '-cg    ' } else { '-debug ' }
+	mut hyperfine_commands_arguments := []string{}
+	for cmd in commands {
+		println(cmd)
+	}
+	for cmd in commands {
+		hyperfine_commands_arguments <<
+			" \'cd ${c.b:-34s} ; ./$cmd \' ".replace_each(['@COMPILER@', source_location_b, '@DEBUG@', debug_option_b])
+	}
+	for cmd in commands {
+		hyperfine_commands_arguments <<
+			" \'cd ${c.a:-34s} ; ./$cmd \' ".replace_each(['@COMPILER@', source_location_a, '@DEBUG@', debug_option_a])
+	}
+	// /////////////////////////////////////////////////////////////////////////////
+	cmd_stats_file := os.real_path([c.vgo.workdir, 'v_performance_stats_${label}.json'].join(os.path_separator))
+	comparison_cmd := 'hyperfine $c.hyperfineopts ' + '--export-json $cmd_stats_file ' + '--time-unit millisecond ' +
+		'--style full --warmup $c.warmups ' + hyperfine_commands_arguments.join(' ')
+	// /////////////////////////////////////////////////////////////////////////////
+	if c.vgo.verbose {
+		println(comparison_cmd)
+	}
+	os.system(comparison_cmd)
+	println('The detailed performance comparison report was saved to: $cmd_stats_file .')
+	println('')
+	return cmd_stats_file
+}
+
+fn main() {
+	scripting.used_tools_must_exist(['cp', 'rm', 'strip', 'make', 'git', 'upx', 'cc', 'wc', 'tail',
+		'find', 'xargs', 'hyperfine'])
+	mut context := new_context()
+	mut fp := flag.new_flag_parser(os.args)
+	fp.application(os.file_name(os.executable()))
+	fp.version(tool_version)
+	fp.description(tool_description)
+	fp.arguments_description('COMMIT_BEFORE [COMMIT_AFTER]')
+	fp.skip_executable()
+	fp.limit_free_args(1, 2)
+	context.vflags = fp.string('vflags', 0, '', 'Additional options to pass to the v commands, for example "-cc tcc"')
+	context.hyperfineopts = fp.string('hyperfine_options', 0, '', 'Additional options passed to hyperfine.
+${flag.space}For example on linux, you may want to pass:
+$flag.space--hyperfine_options "--prepare \'sync; echo 3 | sudo tee /proc/sys/vm/drop_caches\'"
+')
+	commits := vgit.add_common_tool_options(mut context.vgo, mut fp)
+	context.commit_before = commits[0]
+	if commits.len > 1 {
+		context.commit_after = commits[1]
+	}
+	context.b = vgit.normalized_workpath_for_commit(context.vgo.workdir, context.commit_before)
+	context.a = vgit.normalized_workpath_for_commit(context.vgo.workdir, context.commit_after)
+	context.vc = vgit.normalized_workpath_for_commit(context.vgo.workdir, 'vc')
+	if !os.is_dir(context.vgo.workdir) {
+		msg := 'Work folder: ' + context.vgo.workdir + ' , does not exist.'
+		eprintln(msg)
+		exit(2)
+	}
+	context.compare_versions()
+}

cmd/tools/preludes/README.md

@@ -0,0 +1,28 @@
+# V preludes:
+
+The cmd/tools/preludes/ contains small v code snippets, that V uses when 
+compiling certain v programs. V adds the files below automatically itself.
+Each file is used in different situations (see below).
+
+NB: preludes are *NOT* intended to be used by user programs/modules.
+The folder cmd/tools/preludes/ is *NOT* a v module.
+
+## Details:
+
+### cmd/tools/preludes/live_main.v
+Used when compiling live programs. This file is used by the main executable
+live program, that starts the file change monitoring thread. Each live program
+needs module `os` and module `time`, in order for the background file change 
+monitoring thread to work properly.
+
+### cmd/tools/preludes/live_shared.v
+Used when compiling live programs, for the shared library portion of the live 
+programs, that is reloaded each time the code is changed.
+
+### cmd/tools/preludes/tests_assertions.v  
+Used when compiling `_test.v` programs. 
+It specifies how failed assertions will look.
+
+### cmd/tools/preludes/tests_with_stats.v
+Used when compiling `_test.v` programs with -stats option. 
+It specifies how the result will appear ('assert' vs 'asserts' and so on).

cmd/tools/preludes/live.v

@@ -0,0 +1,9 @@
+module main
+
+// This prelude is loaded in every v program compiled with -live,
+// in both the main executable, and in the shared library.
+import live
+
+const (
+	no_warning_live_is_used = live.is_used
+)

cmd/tools/preludes/live_main.v

@@ -0,0 +1,9 @@
+module main
+
+// This prelude is loaded in every v program compiled with -live,
+// but only for the main executable.
+import live.executable
+
+const (
+	no_warning_live_executable_is_used = executable.is_used
+)

cmd/tools/preludes/live_shared.v

@@ -0,0 +1,9 @@
+module main
+
+// This prelude is loaded in every v program compiled with -live,
+// but only for the shared library.
+import live.sharedlib
+
+const (
+	no_warning_live_shared_is_used = sharedlib.is_used
+)

cmd/tools/preludes/profiled_program.v

@@ -0,0 +1,7 @@
+module main
+
+import time
+
+const (
+	profiled_program_time_used = time.seconds_per_minute
+)

cmd/tools/preludes/tests_assertions.v

@@ -0,0 +1,44 @@
+module main
+
+import os
+import term
+
+// //////////////////////////////////////////////////////////////////
+// / This file will get compiled as part of the main program,
+// / for a _test.v file.
+// / The methods defined here are called back by the test program's
+// / assert statements, on each success/fail. The goal is to make
+// / customizing the look & feel of the assertions results easier,
+// / since it is done in normal V code, instead of in embedded C ...
+// //////////////////////////////////////////////////////////////////
+// TODO copy pasta builtin.v fn ___print_assert_failure
+fn cb_assertion_failed(i &VAssertMetaInfo) {
+	use_color := term.can_show_color_on_stderr()
+	use_relative_paths := match os.getenv('VERROR_PATHS') {
+		'absolute' { false }
+		else { true }
+	}
+	final_filename := if use_relative_paths { i.fpath } else { os.real_path(i.fpath) }
+	final_funcname := i.fn_name.replace('main.', '').replace('__', '.')
+	final_src := if use_color { term.bold(i.src) } else { i.src }
+	eprintln('')
+	eprintln('$final_filename:${i.line_nr+1}: failed assert in function $final_funcname')
+	eprintln('Source  : `$final_src`')
+	if i.op.len > 0 && i.op != 'call' {
+		mut slvalue := '$i.lvalue'
+		mut srvalue := '$i.rvalue'
+		lpostfix := if slvalue == i.llabel { '.' } else { '<= `$i.llabel`' }
+		rpostfix := if srvalue == i.rlabel { '.' } else { '<= `$i.rlabel`' }
+		if use_color {
+			slvalue = term.bold(term.yellow(slvalue))
+			srvalue = term.bold(term.yellow(srvalue))
+		}
+		eprintln('	 left value: $slvalue $lpostfix')
+		eprintln('	right value: $srvalue $rpostfix')
+	}
+}
+
+fn cb_assertion_ok(i &VAssertMetaInfo) {
+	// do nothing for now on an OK assertion
+	// println('OK ${(i.line_nr+1):5d}|${i.src}')
+}

cmd/tools/preludes/tests_with_stats.v

@@ -0,0 +1,91 @@
+module main
+
+// /////////////////////////////////////////////////////////////////////
+// / This file will get compiled as a part of the same module,
+// / in which a given _test.v file is, when v is given -stats argument
+// / The methods defined here are called back by the test program's
+// / main function, so that customizing the look & feel of the results
+// / is easy, since it is done in normal V code, instead of in embedded C ...
+// /////////////////////////////////////////////////////////////////////
+import os
+import benchmark
+
+const (
+	inner_indent = '     '
+)
+
+struct BenchedTests {
+mut:
+	bench          benchmark.Benchmark
+	oks            int
+	fails          int
+	test_suit_file string
+	step_func_name string
+}
+
+// ///////////////////////////////////////////////////////////////////
+// Called at the start of the test program produced by `v -stats file_test.v`
+fn start_testing(total_number_of_tests int, vfilename string) BenchedTests {
+	mut b := BenchedTests{
+		bench: benchmark.new_benchmark()
+	}
+	b.bench.set_total_expected_steps(total_number_of_tests)
+	b.test_suit_file = vfilename
+	println('running tests in: $b.test_suit_file')
+	return b
+}
+
+// Called before each test_ function, defined in file_test.v
+fn (mut b BenchedTests) testing_step_start(stepfunc string) {
+	b.step_func_name = stepfunc.replace('main.', '').replace('__', '.')
+	b.oks = C.g_test_oks
+	b.fails = C.g_test_fails
+	b.bench.step()
+}
+
+// Called after each test_ function, defined in file_test.v
+fn (mut b BenchedTests) testing_step_end() {
+	ok_diff := C.g_test_oks - b.oks
+	fail_diff := C.g_test_fails - b.fails
+	// ////////////////////////////////////////////////////////////////
+	if ok_diff == 0 && fail_diff == 0 {
+		b.bench.neither_fail_nor_ok()
+		println(inner_indent + b.bench.step_message_ok('   NO asserts | ') + b.fn_name())
+		return
+	}
+	// ////////////////////////////////////////////////////////////////
+	if ok_diff > 0 {
+		b.bench.ok_many(ok_diff)
+	}
+	if fail_diff > 0 {
+		b.bench.fail_many(fail_diff)
+	}
+	// ////////////////////////////////////////////////////////////////
+	if ok_diff > 0 && fail_diff == 0 {
+		println(inner_indent + b.bench.step_message_ok(nasserts(ok_diff)) + b.fn_name())
+		return
+	}
+	if fail_diff > 0 {
+		println(inner_indent + b.bench.step_message_fail(nasserts(fail_diff)) + b.fn_name())
+		return
+	}
+}
+
+fn (b &BenchedTests) fn_name() string {
+	return b.step_func_name + '()'
+}
+
+// Called at the end of the test program produced by `v -stats file_test.v`
+fn (mut b BenchedTests) end_testing() {
+	b.bench.stop()
+	println(inner_indent + b.bench.total_message('running V tests in "' + os.file_name(b.test_suit_file) +
+		'"'))
+}
+
+// ///////////////////////////////////////////////////////////////////
+fn nasserts(n int) string {
+	if n == 1 {
+		return '${n:5d} assert  | '
+	}
+	return '${n:5d} asserts | '
+}

cmd/tools/repeat.v

@@ -0,0 +1,297 @@
+module main
+
+import os
+import flag
+import time
+import term
+import math
+import scripting
+import v.util
+
+struct CmdResult {
+mut:
+	runs    int
+	cmd     string
+	icmd    int
+	outputs []string
+	oms     map[string][]int
+	summary map[string]Aints
+	timings []int
+	atiming Aints
+}
+
+struct Context {
+mut:
+	count                   int
+	series                  int
+	warmup                  int
+	show_help               bool
+	show_output             bool
+	fail_on_regress_percent int
+	fail_on_maxtime         int // in ms
+	verbose                 bool
+	commands                []string
+	results                 []CmdResult
+	cmd_template            string // {T} will be substituted with the current command
+	cmd_params              map[string][]string
+	cline                   string // a terminal clearing line
+}
+
+struct Aints {
+	values  []int
+mut:
+	imin    int
+	imax    int
+	average f64
+	stddev  f64
+}
+
+fn new_aints(vals []int) Aints {
+	mut res := Aints{
+		values: vals
+	}
+	mut sum := i64(0)
+	mut imin := math.max_i32
+	mut imax := -math.max_i32
+	for i in vals {
+		sum += i
+		if i < imin {
+			imin = i
+		}
+		if i > imax {
+			imax = i
+		}
+	}
+	res.imin = imin
+	res.imax = imax
+	if vals.len > 0 {
+		res.average = sum / f64(vals.len)
+	}
+	//
+	mut devsum := f64(0.0)
+	for i in vals {
+		x := f64(i) - res.average
+		devsum += (x * x)
+	}
+	res.stddev = math.sqrt(devsum / f64(vals.len))
+	return res
+}
+
+fn (a Aints) str() string {
+	return util.bold('${a.average:9.3f}') +
+		'ms ± σ: ${a.stddev:-5.1f}ms, min … max: ${a.imin}ms … ${a.imax}ms'
+}
+
+const (
+	max_fail_percent             = 100000
+	max_time                     = 60 * 1000 // ms
+	performance_regression_label = 'Performance regression detected, failing since '
+)
+
+fn main() {
+	mut context := Context{}
+	context.parse_options()
+	context.run()
+	context.show_diff_summary()
+}
+
+fn (mut context Context) parse_options() {
+	mut fp := flag.new_flag_parser(os.args)
+	fp.application(os.file_name(os.executable()))
+	fp.version('0.0.1')
+	fp.description('Repeat command(s) and collect statistics. NB: you have to quote each command, if it contains spaces.')
+	fp.arguments_description('CMD1 CMD2 ...')
+	fp.skip_executable()
+	fp.limit_free_args_to_at_least(1)
+	context.count = fp.int('count', `c`, 10, 'Repetition count.')
+	context.series = fp.int('series', `s`, 2, 'Series count. `-s 2 -c 4 a b` => aaaabbbbaaaabbbb, while `-s 3 -c 2 a b` => aabbaabbaabb.')
+	context.warmup = fp.int('warmup', `w`, 2, 'Warmup runs. These are done *only at the start*, and are ignored.')
+	context.show_help = fp.bool('help', `h`, false, 'Show this help screen.')
+	context.show_output = fp.bool('output', `O`, false, 'Show command stdout/stderr in the progress indicator for each command. NB: slower, for verbose commands.')
+	context.verbose = fp.bool('verbose', `v`, false, 'Be more verbose.')
+	context.fail_on_maxtime = fp.int('max_time', `m`, max_time, 'Fail with exit code 2, when first cmd takes above M milliseconds (regression).')
+	context.fail_on_regress_percent = fp.int('fail_percent', `f`, max_fail_percent, 'Fail with exit code 3, when first cmd is X% slower than the rest (regression).')
+	context.cmd_template = fp.string('template', `t`, '{T}', 'Command template. {T} will be substituted with the current command.')
+	cmd_params := fp.string_multi('parameter', `p`, 'A parameter substitution list. `{p}=val1,val2,val2` means that {p} in the template, will be substituted with each of val1, val2, val3.')
+	for p in cmd_params {
+		parts := p.split(':')
+		if parts.len > 1 {
+			context.cmd_params[parts[0]] = parts[1].split(',')
+		}
+	}
+	if context.show_help {
+		println(fp.usage())
+		exit(0)
+	}
+	if context.verbose {
+		scripting.set_verbose(true)
+	}
+	commands := fp.finalize() or {
+		eprintln('Error: ' + err)
+		exit(1)
+	}
+	context.commands = context.expand_all_commands(commands)
+	context.results = []CmdResult{len: context.commands.len, init: CmdResult{}}
+	context.cline = '\r' + term.h_divider('')
+}
+
+fn (mut context Context) clear_line() {
+	print(context.cline)
+}
+
+fn (mut context Context) expand_all_commands(commands []string) []string {
+	mut all_commands := []string{}
+	for cmd in commands {
+		maincmd := context.cmd_template.replace('{T}', cmd)
+		mut substituted_commands := [maincmd]
+		for paramk, paramlist in context.cmd_params {
+			for paramv in paramlist {
+				mut new_substituted_commands := []string{}
+				for cscmd in substituted_commands {
+					scmd := cscmd.replace(paramk, paramv)
+					new_substituted_commands << scmd
+				}
+				substituted_commands << new_substituted_commands
+			}
+		}
+		all_commands << substituted_commands
+	}
+	mut unique := map[string]int{}
+	for x in all_commands {
+		if x.contains('{') && x.contains('}') {
+			continue
+		}
+		unique[x] = 1
+	}
+	return unique.keys()
+}
+
+fn (mut context Context) run() {
+	mut run_warmups := 0
+	for si in 1 .. context.series + 1 {
+		for icmd, cmd in context.commands {
+			mut runs := 0
+			mut duration := 0
+			mut sum := 0
+			mut oldres := ''
+			println('Series: ${si:4}/${context.series:-4}, command: $cmd')
+			if context.warmup > 0 && run_warmups < context.commands.len {
+				for i in 1 .. context.warmup + 1 {
+					print('\r warming up run: ${i:4}/${context.warmup:-4} for ${cmd:-50s} took ${duration:6} ms ...')
+					mut sw := time.new_stopwatch({})
+					os.exec(cmd) or {
+						continue
+					}
+					duration = int(sw.elapsed().milliseconds())
+				}
+				run_warmups++
+			}
+			context.clear_line()
+			for i in 1 .. (context.count + 1) {
+				avg := f64(sum) / f64(i)
+				print('\rAverage: ${avg:9.3f}ms | run: ${i:4}/${context.count:-4} | took ${duration:6} ms')
+				if context.show_output {
+					print(' | result: ${oldres:s}')
+				}
+				mut sw := time.new_stopwatch({})
+				res := scripting.exec(cmd) or {
+					continue
+				}
+				duration = int(sw.elapsed().milliseconds())
+				if res.exit_code != 0 {
+					eprintln('${i:10} non 0 exit code for cmd: $cmd')
+					continue
+				}
+				context.results[icmd].outputs <<
+					res.output.trim_right('\r\n').replace('\r\n', '\n').split('\n')
+				context.results[icmd].timings << duration
+				sum += duration
+				runs++
+				oldres = res.output.replace('\n', ' ')
+			}
+			context.results[icmd].cmd = cmd
+			context.results[icmd].icmd = icmd
+			context.results[icmd].runs += runs
+			context.results[icmd].atiming = new_aints(context.results[icmd].timings)
+			context.clear_line()
+			print('\r')
+			mut m := map[string][]int{}
+			for o in context.results[icmd].outputs {
+				x := o.split(':')
+				if x.len > 1 {
+					k := x[0]
+					v := x[1].trim_left(' ').int()
+					m[k] << v
+				}
+			}
+			mut summary := map[string]Aints{}
+			for k, v in m {
+				// show a temporary summary for the current series/cmd cycle
+				s := new_aints(v)
+				println('  $k: $s')
+				summary[k] = s
+			}
+			// merge current raw results to the previous ones
+			old_oms := context.results[icmd].oms
+			mut new_oms := map[string][]int{}
+			for k, v in m {
+				if old_oms[k].len == 0 {
+					new_oms[k] = v
+				} else {
+					new_oms[k] << old_oms[k]
+					new_oms[k] << v
+				}
+			}
+			context.results[icmd].oms = new_oms
+			// println('')
+		}
+	}
+	// create full summaries, taking account of all runs
+	for icmd in 0 .. context.results.len {
+		mut new_full_summary := map[string]Aints{}
+		for k, v in context.results[icmd].oms {
+			new_full_summary[k] = new_aints(v)
+		}
+		context.results[icmd].summary = new_full_summary
+	}
+}
+
+fn (mut context Context) show_diff_summary() {
+	context.results.sort_with_compare(fn (a &CmdResult, b &CmdResult) int {
+		if a.atiming.average < b.atiming.average {
+			return -1
+		}
+		if a.atiming.average > b.atiming.average {
+			return 1
+		}
+		return 0
+	})
+	println('Summary (commands are ordered by ascending mean time), after $context.series series of $context.count repetitions:')
+	base := context.results[0].atiming.average
+	mut first_cmd_percentage := f64(100.0)
+	for i, r in context.results {
+		cpercent := (r.atiming.average / base) * 100 - 100
+		first_marker := if r.icmd == 0 { util.bold('>') } else { ' ' }
+		if r.icmd == 0 {
+			first_cmd_percentage = cpercent
+		}
+		println(' $first_marker${(i + 1):3} | ${cpercent:6.1f}% slower | ${r.cmd:-55s} | $r.atiming')
+	}
+	$if debugcontext ? {
+		println('context: $context')
+	}
+	if int(base) > context.fail_on_maxtime {
+		print(performance_regression_label)
+		println('average time: ${base:6.1f} ms > $context.fail_on_maxtime ms threshold.')
+		exit(2)
+	}
+	if context.fail_on_regress_percent == max_fail_percent || context.results.len < 2 {
+		return
+	}
+	fail_threshold_max := f64(context.fail_on_regress_percent)
+	if first_cmd_percentage > fail_threshold_max {
+		print(performance_regression_label)
+		println('${first_cmd_percentage:5.1f}% > ${fail_threshold_max:5.1f}% threshold.')
+		exit(3)
+	}
+}

cmd/tools/test_os_process.v

@@ -0,0 +1,81 @@
+module main
+
+import os
+import time
+import os.cmdline
+
+enum Target {
+	both
+	stderr
+	stdout
+	alternate
+}
+
+fn s2target(s string) Target {
+	return match s {
+		'both' { Target.both }
+		'stderr' { Target.stderr }
+		'alternate' { Target.alternate }
+		else { Target.stdout }
+	}
+}
+
+struct Context {
+mut:
+	timeout_ms int
+	period_ms  int
+	exitcode   int
+	target     Target
+	omode      Target
+	is_verbose bool
+}
+
+fn (mut ctx Context) println(s string) {
+	if ctx.target == .alternate {
+		ctx.omode = if ctx.omode == .stderr { Target.stdout } else { Target.stderr }
+	}
+	if ctx.target in [.both, .stdout] || ctx.omode == .stdout {
+		println('stdout, $s')
+	}
+	if ctx.target in [.both, .stderr] || ctx.omode == .stderr {
+		eprintln('stderr, $s')
+	}
+}
+
+fn do_timeout(c &Context) {
+	mut ctx := c
+	time.sleep_ms(ctx.timeout_ms)
+	exit(ctx.exitcode)
+}
+
+fn main() {
+	mut ctx := Context{}
+	args := os.args[1..]
+	if '-h' in args || '--help' in args {
+		println("Usage:
+	test_os_process [-v] [-h] [-target stderr/stdout/both/alternate] [-exitcode 0] [-timeout_ms 1000] [-period_ms 100]
+		Prints lines periodically (-period_ms), to stdout/stderr (-target). 
+		After a while (-timeout_ms), exit with (-exitcode).
+		This program is useful for platform independent testing
+		of child process/standart input/output control.
+		It is used in V\'s `os` module tests.
+")
+	}
+	ctx.is_verbose = '-v' in args
+	ctx.target = s2target(cmdline.option(args, '-target', 'both'))
+	ctx.exitcode = cmdline.option(args, '-exitcode', '0').int()
+	ctx.timeout_ms = cmdline.option(args, '-timeout_ms', '1000').int()
+	ctx.period_ms = cmdline.option(args, '-period_ms', '100').int()
+	if ctx.target == .alternate {
+		ctx.omode = .stdout
+	}
+	if ctx.is_verbose {
+		eprintln('> args: $args | context: $ctx')
+	}
+	go do_timeout(&ctx)
+	for i := 1; true; i++ {
+		ctx.println('$i')
+		time.sleep_ms(ctx.period_ms)
+	}
+	time.sleep(100000)
+}

cmd/tools/vbin2v.v

@@ -0,0 +1,149 @@
+module main
+
+import os
+import flag
+import strings
+
+const (
+	tool_version     = '0.0.4'
+	tool_description = 'Converts a list of arbitrary files into a single v module file.'
+)
+
+struct Context {
+mut:
+	files       []string
+	prefix      string
+	show_help   bool
+	module_name string
+	write_file  string
+}
+
+fn (context Context) header() string {
+	mut header_s := ''
+	header_s += 'module $context.module_name\n'
+	header_s += '\n'
+	allfiles := context.files.join(' ')
+	mut options := []string{}
+	if context.prefix.len > 0 {
+		options << '-p $context.prefix'
+	}
+	if context.module_name.len > 0 {
+		options << '-m $context.module_name'
+	}
+	if context.write_file.len > 0 {
+		options << '-w $context.write_file'
+	}
+	soptions := options.join(' ')
+	header_s += '// File generated by:\n'
+	header_s += '// v bin2v $allfiles $soptions\n'
+	header_s += '// Please, do not edit this file.\n'
+	header_s += '// Your changes may be overwritten.\n'
+	header_s += 'const (\n'
+	return header_s
+}
+
+fn (context Context) footer() string {
+	return ')\n'
+}
+
+fn (context Context) file2v(bname string, fbytes []byte, bn_max int) string {
+	mut sb := strings.new_builder(1000)
+	bn_diff_len := bn_max - bname.len
+	sb.write('\t${bname}_len' + ' '.repeat(bn_diff_len - 4) + ' = $fbytes.len\n')
+	mut last_len := sb.len
+	fbyte := fbytes[0]
+	sb.write('\t$bname' + ' '.repeat(bn_diff_len) + ' = [byte($fbyte), ')
+	for i := 1; i < fbytes.len; i++ {
+		b := int(fbytes[i]).str()
+		sb_diff_len := sb.len - last_len
+		if i < 30 && sb_diff_len > 86 {
+			sb.write('$b,\n\t\t')
+			last_len = sb.len
+		} else if sb_diff_len > 88 && 92 - sb_diff_len < b.len {
+			sb.write('$b,\n\t\t')
+			last_len = sb.len
+		} else if i == fbytes.len - 1 {
+			sb.write(b)
+		} else {
+			sb.write('$b, ')
+		}
+	}
+	sb.write(']!!\n')
+	return sb.str()
+}
+
+fn (context Context) bname_and_bytes(file string) ?(string, []byte) {
+	fname := os.file_name(file)
+	fname_no_dots := fname.replace('.', '_')
+	byte_name := '$context.prefix$fname_no_dots'.to_lower()
+	fbytes := os.read_bytes(file) or {
+		return error('Error: $err')
+	}
+	return byte_name, fbytes
+}
+
+fn (context Context) max_bname_len(bnames []string) int {
+	mut max := 0
+	for n in bnames {
+		if n.len > max {
+			max = n.len
+		}
+	}
+	// Add 4 to max due to "_len" suffix
+	return max + 4
+}
+
+fn main() {
+	mut context := Context{}
+	mut fp := flag.new_flag_parser(os.args[1..])
+	fp.application('v bin2v')
+	fp.version(tool_version)
+	fp.description(tool_description)
+	fp.arguments_description('FILE [FILE]...')
+	context.show_help = fp.bool('help', `h`, false, 'Show this help screen.')
+	context.module_name = fp.string('module', `m`, 'binary', 'Name of the generated module.')
+	context.prefix = fp.string('prefix', `p`, '', 'A prefix put before each resource name.')
+	context.write_file = fp.string('write', `w`, '', 'Write directly to a file with the given name.')
+	if context.show_help {
+		println(fp.usage())
+		exit(0)
+	}
+	files := fp.finalize() or {
+		eprintln('Error: ' + err)
+		exit(1)
+	}
+	real_files := files.filter(it != 'bin2v')
+	if real_files.len == 0 {
+		println(fp.usage())
+		exit(0)
+	}
+	context.files = real_files
+	if context.write_file != '' && !context.write_file.ends_with('.v') {
+		context.write_file += '.v'
+	}
+	mut file_byte_map := map[string][]byte{}
+	for file in real_files {
+		bname, fbytes := context.bname_and_bytes(file) or {
+			eprintln(err)
+			continue
+		}
+		file_byte_map[bname] = fbytes
+	}
+	max_bname := context.max_bname_len(file_byte_map.keys())
+	if context.write_file.len > 0 {
+		mut out_file := os.create(context.write_file) or {
+			panic(err)
+		}
+		out_file.write_str(context.header())
+		for bname, fbytes in file_byte_map {
+			out_file.write_str(context.file2v(bname, fbytes, max_bname))
+		}
+		out_file.write_str(context.footer())
+	} else {
+		println(context.header())
+		for bname, fbytes in file_byte_map {
+			println(context.file2v(bname, fbytes, max_bname))
+		}
+		println(context.footer())
+	}
+}

cmd/tools/vbuild-examples.v

@@ -0,0 +1,16 @@
+module main
+
+import os
+import testing
+
+fn main() {
+	args := os.args
+	args_string := args[1..].join(' ')
+	params := args_string.all_before('build-examples')
+	if testing.v_build_failing(params, 'examples') {
+		exit(1)
+	}
+	if testing.v_build_failing(params + '-live', os.join_path('examples', 'hot_reload')) {
+		exit(1)
+	}
+}

cmd/tools/vbuild-tools.v

@@ -0,0 +1,36 @@
+module main
+
+import os
+import testing
+import v.util
+
+fn p(s string) string {
+	println(s)
+	return s
+}
+
+fn main() {
+	args := os.args
+	args_string := args[1..].join(' ')
+	skips := []string{}
+	vexe := os.getenv('VEXE')
+	vroot := os.dir(vexe)
+	util.ensure_modules_for_all_tools_are_installed('-v' in args)
+	folder := 'cmd/tools'
+	main_label := 'Building $folder ...'
+	finish_label := 'building $folder'
+	mut session := testing.prepare_test_session(args_string.all_before('build-tools'), folder, skips, main_label)
+	session.rm_binaries = false
+	session.test()
+	eprintln(session.benchmark.total_message(finish_label))
+	if session.failed {
+		exit(1)
+	}
+	//
+	mut executables := os.ls(session.vtmp_dir)?
+	executables.sort()
+	executables = executables.filter(it !in ['gen1m', 'gen_vc', 'fast', 'wyhash'])
+	for exe in executables {
+		os.mv_by_cp(os.join_path(session.vtmp_dir, exe), os.join_path(vroot, 'cmd', 'tools', exe))
+	}
+}

cmd/tools/vbuild-vbinaries.v

@@ -0,0 +1,9 @@
+module main
+
+import testing
+
+fn main() {
+	if testing.building_any_v_binaries_failed() {
+		exit(1)
+	}
+}

cmd/tools/vcomplete.v

@@ -0,0 +1,424 @@
+// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
+// Use of this source code is governed by an MIT license
+// that can be found in the LICENSE file.
+//
+// Utility functions helping integrate with various shell auto-completion systems.
+// The install process and communication is inspired from that of [kitty](https://sw.kovidgoyal.net/kitty/#completion-for-kitty)
+// This method avoids writing and maintaining external files on the user's file system.
+// The user will be responsible for adding a small line to their .*rc - that will ensure *live* (i.e. not-static)
+// auto-completion features.
+//
+// # bash
+// To install auto-completion for V in bash, simply add this code to your `~/.bashrc`:
+// `source /dev/stdin <<<"$(v complete setup bash)"`
+// On more recent versions of bash (>3.2) this should suffice:
+// `source <(v complete setup bash)`
+//
+// # fish
+// For versions of fish <3.0.0, add the following to your `~/.config/fish/config.fish`
+// `v complete setup fish | source`
+// Later versions of fish source completions by default.
+//
+// # zsh
+// To install auto-completion for V in zsh - please add the following to your `~/.zshrc`:
+// ```
+// autoload -Uz compinit
+// compinit
+// # Completion for v
+// v complete setup zsh | source /dev/stdin
+// ```
+// Please note that you should let v load the zsh completions after the call to compinit
+//
+// # powershell //TODO
+//
+module main
+
+import os
+
+const (
+	auto_complete_shells = ['bash', 'fish', 'zsh', 'powershell'] // list of supported shells
+	vexe                 = os.getenv('VEXE')
+)
+
+// Snooped from cmd/v/v.v, vlib/v/pref/pref.v
+const (
+	auto_complete_commands    = [
+		/* simple_cmd */
+		'fmt',
+		'up',
+		'vet',
+		'self',
+		'tracev',
+		'symlink',
+		'bin2v',
+		'test',
+		'test-fmt',
+		'test-compiler',
+		'test-fixed',
+		'test-cleancode',
+		'repl',
+		'complete',
+		'build-tools',
+		'build-examples',
+		'build-vbinaries',
+		'setup-freetype',
+		'doc',
+		'doctor',
+		/* commands */
+		'help',
+		'new',
+		'init',
+		'complete',
+		'translate',
+		'self',
+		'search',
+		'install',
+		'update',
+		'upgrade',
+		'outdated',
+		'list',
+		'remove',
+		'vlib-docs',
+		'get',
+		'version',
+		'run',
+		'build',
+		'build-module',
+	]
+	auto_complete_flags       = [
+		'-apk',
+		'-show-timings',
+		'-check-syntax',
+		'-v',
+		'-progress',
+		'-silent',
+		'-g',
+		'-cg',
+		'-repl',
+		'-live',
+		'-sharedlive',
+		'-shared',
+		'--enable-globals',
+		'-enable-globals',
+		'-autofree',
+		'-compress',
+		'-freestanding',
+		'-no-preludes',
+		'-prof',
+		'-profile',
+		'-profile-no-inline',
+		'-prod',
+		'-simulator',
+		'-stats',
+		'-obfuscate',
+		'-translated',
+		'-color',
+		'-nocolor',
+		'-showcc',
+		'-show-c-output',
+		'-experimental',
+		'-usecache',
+		'-prealloc',
+		'-parallel',
+		'-x64',
+		'-W',
+		'-keepc',
+		'-w',
+		'-print_v_files',
+		'-error-limit',
+		'-os',
+		'-printfn',
+		'-cflags',
+		'-define',
+		'-d',
+		'-cc',
+		'-o',
+		'-b',
+		'-path',
+		'-custom-prelude',
+		'-name',
+		'-bundle',
+		'-V',
+		'-version',
+		'--version',
+	]
+	auto_complete_flags_doc   = [
+		'-all',
+		'-f',
+		'-h',
+		'-help',
+		'-m',
+		'-o',
+		'-readme',
+		'-v',
+		'-filename',
+		'-pos',
+		'-no-timestamp',
+		'-inline-assets',
+		'-open',
+		'-p',
+		'-s',
+		'-l',
+	]
+	auto_complete_flags_fmt   = [
+		'-c',
+		'-diff',
+		'-l',
+		'-w',
+		'-debug',
+		'-verify',
+	]
+	auto_complete_flags_bin2v = [
+		'-h',
+		'--help',
+		'-m',
+		'--module',
+		'-p',
+		'--prefix',
+		'-w',
+		'--write',
+	]
+	auto_complete_flags_self  = [
+		'-prod',
+	]
+	auto_complete_compilers   = [
+		'cc',
+		'gcc',
+		'tcc',
+		'tinyc',
+		'clang',
+		'mingw',
+		'msvc',
+	]
+)
+
+fn auto_complete(args []string) {
+	if args.len <= 1 || args[0] != 'complete' {
+		if args.len == 1 {
+			eprintln('auto completion require arguments to work.')
+		} else {
+			eprintln('auto completion failed for "$args".')
+		}
+		exit(1)
+	}
+	sub := args[1]
+	sub_args := args[1..]
+	match sub {
+		'setup' {
+			if sub_args.len <= 1 || sub_args[1] !in auto_complete_shells {
+				eprintln('please specify a shell to setup auto completion for ($auto_complete_shells).')
+				exit(1)
+			}
+			shell := sub_args[1]
+			mut setup := ''
+			match shell {
+				'bash' { setup = '
+_v_completions() {
+	local src
+	local limit
+	# Send all words up to the word the cursor is currently on
+	let limit=1+\$COMP_CWORD
+	src=\$($vexe complete bash \$(printf "%s\\n" \${COMP_WORDS[@]: 0:\$limit}))
+	if [[ \$? == 0 ]]; then
+		eval \${src}
+		#echo \${src}
+	fi
+}
+
+complete -o nospace -F _v_completions v
+' }
+				'fish' { setup = '
+function __v_completions
+	# Send all words up to the one before the cursor
+	$vexe complete fish (commandline -cop)
+end
+complete -f -c v -a "(__v_completions)"
+' }
+				'zsh' { setup = '
+#compdef v
+_v() {
+	local src
+	# Send all words up to the word the cursor is currently on
+	src=\$($vexe complete zsh \$(printf "%s\\n" \${(@)words[1,\$CURRENT]}))
+	if [[ \$? == 0 ]]; then
+		eval \${src}
+		#echo \${src}
+	fi
+}
+compdef _v v
+' }
+				// 'powershell' {} //TODO
+				else {}
+			}
+			println(setup)
+		}
+		'bash' {
+			if sub_args.len <= 1 {
+				exit(0)
+			}
+			mut lines := []string{}
+			list := auto_complete_request(sub_args[1..])
+			for entry in list {
+				lines << "COMPREPLY+=(\'$entry\')"
+			}
+			println(lines.join('\n'))
+		}
+		'fish' {
+			if sub_args.len <= 1 {
+				exit(0)
+			}
+			mut lines := []string{}
+			list := auto_complete_request(sub_args[1..])
+			for entry in list {
+				lines << '$entry'
+			}
+			println(lines.join('\n'))
+		}
+		'zsh' {
+			if sub_args.len <= 1 {
+				exit(0)
+			}
+			mut lines := []string{}
+			list := auto_complete_request(sub_args[1..])
+			for entry in list {
+				lines << 'compadd -U -S \"\" -- \'$entry\';'
+			}
+			println(lines.join('\n'))
+		}
+		// 'powershell' {} //TODO
+		else {}
+	}
+	exit(0)
+}
+
+fn auto_complete_request(args []string) []string {
+	// Using space will ensure a uniform input in cases where the shell
+	// returns the completion input as a string (['v','run'] vs. ['v run']).
+	split_by := ' '
+	request := args.join(split_by)
+	mut list := []string{}
+	// new_part := request.ends_with('\n\n')
+	mut parts := request.trim_right(' ').split(split_by)
+	if parts.len <= 1 { // 'v <tab>' -> top level commands.
+		for command in auto_complete_commands {
+			list << command
+		}
+	} else {
+		part := parts.last().trim(' ')
+		mut parent_command := ''
+		for i := parts.len - 1; i >= 0; i-- {
+			if parts[i].starts_with('-') {
+				continue
+			}
+			parent_command = parts[i]
+			break
+		}
+		get_flags := fn (base []string, flag string) []string {
+			if flag.len == 1 { return base
+			 } else { return base.filter(it.starts_with(flag))
+			 }
+		}
+		if part.starts_with('-') { // 'v -<tab>' -> flags.
+			match parent_command {
+				'bin2v' { // 'v bin2v -<tab>'
+					list = get_flags(auto_complete_flags_bin2v, part)
+				}
+				'build' { // 'v build -<tab>' -> flags.
+					list = get_flags(auto_complete_flags, part)
+				}
+				'doc' { // 'v doc -<tab>' -> flags.
+					list = get_flags(auto_complete_flags_doc, part)
+				}
+				'fmt' { // 'v fmt -<tab>' -> flags.
+					list = get_flags(auto_complete_flags_fmt, part)
+				}
+				'self' { // 'v self -<tab>' -> flags.
+					list = get_flags(auto_complete_flags_self, part)
+				}
+				else {
+					for flag in auto_complete_flags {
+						if flag == part {
+							if flag == '-cc' { // 'v -cc <tab>' -> list of available compilers.
+								for compiler in auto_complete_compilers {
+									path := os.find_abs_path_of_executable(compiler) or {
+										''
+									}
+									if path != '' {
+										list << compiler
+									}
+								}
+							}
+						} else if flag.starts_with(part) { // 'v -<char(s)><tab>' -> flags matching "<char(s)>".
+							list << flag
+						}
+					}
+				}
+			}
+		} else {
+			match part {
+				'help' { // 'v help <tab>' -> top level commands except "help".
+					list = auto_complete_commands.filter(it != part && it != 'complete')
+				}
+				else {
+					// 'v <char(s)><tab>' -> commands matching "<char(s)>".
+					// Don't include if part matches a full command - instead go to path completion below.
+					for command in auto_complete_commands {
+						if part != command && command.starts_with(part) {
+							list << command
+						}
+					}
+				}
+			}
+		}
+		// Nothing of value was found.
+		// Mimic shell dir and file completion
+		if list.len == 0 {
+			mut ls_path := '.'
+			mut collect_all := part in auto_complete_commands
+			mut path_complete := false
+			if part.ends_with(os.path_separator) || part == '.' || part == '..' {
+				// 'v <command>(.*/$|.|..)<tab>' -> output full directory list
+				ls_path = '.' + os.path_separator + part
+				collect_all = true
+			} else if !collect_all && part.contains(os.path_separator) && os.is_dir(os.dir(part)) {
+				// 'v <command>(.*/.* && os.is_dir)<tab>'  -> output completion friendly directory list
+				ls_path = os.dir(part)
+				path_complete = true
+			}
+			entries := os.ls(ls_path) or {
+				return list
+			}
+			last := part.all_after_last(os.path_separator)
+			if path_complete {
+				path := part.all_before_last(os.path_separator)
+				for entry in entries {
+					if entry.starts_with(last) {
+						list << os.join_path(path, entry)
+					}
+				}
+				// If only one possible file - send full path to completion system.
+				// Please note that this might be bash specific - needs more testing.
+				if list.len == 1 {
+					list = [list[0]]
+				}
+			} else {
+				for entry in entries {
+					if collect_all {
+						list << entry
+					} else {
+						if entry.starts_with(last) {
+							list << entry
+						}
+					}
+				}
+			}
+		}
+	}
+	return list
+}
+
+fn main() {
+	args := os.args[1..]
+	// println('"$args"')
+	auto_complete(args)
+}

cmd/tools/vcreate.v

@@ -0,0 +1,145 @@
+module main
+
+// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
+// Use of this source code is governed by an MIT license that can be found in the LICENSE file.
+//
+// This module follows a similar convention to Rust: `init` makes the
+// structure of the program in the _current_ directory, while `new`
+// makes the program structure in a _sub_ directory. Besides that, the
+// functionality is essentially the same.
+import os
+
+struct Create {
+mut:
+	name        string
+	description string
+}
+
+fn cerror(e string) {
+	eprintln('\nerror: $e')
+}
+
+fn vmod_content(name string, desc string) string {
+	return [
+		'Module {',
+		"	name: '$name'",
+		"	description: '$desc'",
+		"	version: '0.0.0'",
+		'	dependencies: []',
+		'}',
+	].join('\n')
+}
+
+fn main_content() string {
+	return [
+		'module main\n',
+		'fn main() {',
+		"	println('Hello World!')",
+		'}',
+	].join('\n')
+}
+
+fn gen_gitignore(name string) string {
+	return [
+		'# Binaries for programs and plugins',
+		'main',
+		'$name',
+		'*.exe',
+		'*.exe~',
+		'*.so',
+		'*.dylib',
+		'*.dll',
+	].join('\n')
+}
+
+fn (c &Create) write_vmod(new bool) {
+	vmod_path := if new { '$c.name/v.mod' } else { 'v.mod' }
+	mut vmod := os.create(vmod_path) or {
+		cerror(err)
+		exit(1)
+	}
+	vmod.write_str(vmod_content(c.name, c.description))
+	vmod.close()
+}
+
+fn (c &Create) write_main(new bool) {
+	if !new && (os.exists('${c.name}.v') || os.exists('src/${c.name}.v')) {
+		return
+	}
+	main_path := if new { '$c.name/${c.name}.v' } else { '${c.name}.v' }
+	mut main := os.create(main_path) or {
+		cerror(err)
+		exit(2)
+	}
+	main.write_str(main_content())
+	main.close()
+}
+
+fn (c &Create) create_git_repo(dir string) {
+	// Create Git Repo and .gitignore file
+	if !os.is_dir('$dir/.git') {
+		os.exec('git init $dir') or {
+			cerror('Unable to create git repo')
+			exit(4)
+		}
+		if !os.exists('$dir/.gitignore') {
+			mut fl := os.create('$dir/.gitignore') or {
+				// We don't really need a .gitignore, it's just a nice-to-have
+				return
+			}
+			fl.write_str(gen_gitignore(c.name))
+			fl.close()
+		}
+	}
+}
+
+fn create() {
+	mut c := Create{}
+	c.name = os.input('Input your project name: ')
+	if c.name == '' {
+		cerror('project name cannot be empty')
+		exit(1)
+	}
+	if c.name.contains('-') {
+		cerror('"$c.name" should not contain hyphens')
+		exit(1)
+	}
+	if os.is_dir(c.name) {
+		cerror('$c.name folder already exists')
+		exit(3)
+	}
+	c.description = os.input('Input your project description: ')
+	println('Initialising ...')
+	os.mkdir(c.name) or {
+		panic(err)
+	}
+	c.write_vmod(true)
+	c.write_main(true)
+	c.create_git_repo(c.name)
+}
+
+fn init_project() {
+	if os.exists('v.mod') {
+		cerror('`v init` cannot be run on existing v modules')
+		exit(3)
+	}
+	mut c := Create{}
+	c.name = os.file_name(os.getwd())
+	c.description = ''
+	c.write_vmod(false)
+	c.write_main(false)
+	c.create_git_repo('')
+	println("Change your module's description in `v.mod`")
+}
+
+fn main() {
+	if os.args[1] == 'new' {
+		create()
+	} else if os.args[1] == 'init' {
+		init_project()
+	} else {
+		cerror('Unknown command: ${os.args[1]}')
+		exit(1)
+	}
+	println('Complete!')
+}

cmd/tools/vdoc-resources/arrow.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" class="dropdown-arrow" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M7 10l5 5 5-5z"/></svg>

cmd/tools/vdoc-resources/dark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" class="dark-icon" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24"><g><rect fill="none" height="24" width="24"/></g><g><g><g><path d="M11.1,12.08C8.77,7.57,10.6,3.6,11.63,2.01C6.27,2.2,1.98,6.59,1.98,12c0,0.14,0.02,0.28,0.02,0.42 C2.62,12.15,3.29,12,4,12c1.66,0,3.18,0.83,4.1,2.15C9.77,14.63,11,16.17,11,18c0,1.52-0.87,2.83-2.12,3.51 c0.98,0.32,2.03,0.5,3.11,0.5c3.5,0,6.58-1.8,8.37-4.52C18,17.72,13.38,16.52,11.1,12.08z"/></g><path d="M7,16l-0.18,0C6.4,14.84,5.3,14,4,14c-1.66,0-3,1.34-3,3s1.34,3,3,3c0.62,0,2.49,0,3,0c1.1,0,2-0.9,2-2 C9,16.9,8.1,16,7,16z"/></g></g></svg>

cmd/tools/vdoc-resources/doc.css

@@ -0,0 +1,582 @@
+:root {
+	--background-color: #fff;
+	--link-color: #2779bd;
+	--text-color: #000;
+	--ref-symbol-color: #dae1e7;
+	--ref-symbol-hover-color: #b8c2cc;
+	--title-bottom-line-color: #f1f5f8;
+	--footer-top-line-color: #f1f5f8;
+	--footer-text-color: #616161;
+	--code-signature-border-color: #a0aec0;
+	--menu-background-color: #4b6c88;
+	--menu-text-color: #fff;
+	--menu-indent-line-color: #3b3b3b66;
+	--menu-indent-line-active-color: #00000066;
+	--menu-scrollbar-color: #a0aec0;
+	--menu-toggle-icon-color: #fff;
+	--menu-toggle-icon-hover-color: #00000044;
+	--menu-search-background-color: #00000044;
+	--menu-search-font-color: #fff;
+	--toc-text-color: #2779bd;
+	--toc-indicator-color: #4299e1;
+	--code-default-text-color: #5c6e74;
+	--code-background-color: #edf2f7;
+	--code-keyword-text-color: #2b6cb0;
+	--code-builtin-text-color: #0a0a0a;
+	--code-function-text-color: #319795;
+	--code-comment-text-color: #93a1a1;
+	--code-punctuation-text-color: #999999;
+	--code-symbol-text-color: #702459;
+	--code-operator-text-color: #a67f59;
+}
+:root.dark .dark-icon {
+	display: none;
+}
+:root:not(.dark) .light-icon {
+	display: none;
+}
+
+.dark body {
+	--background-color: #1a202c;
+	--text-color: #fff;
+	--link-color: #90cdf4;
+	--ref-symbol-color: #2d3748;
+	--ref-symbol-hover-color: #4a5568;
+	--title-bottom-line-color: #2d3748;
+	--footer-top-line-color: #2d3748;
+	--footer-text-color: #bbd3e1;
+	--code-signature-border-color: #4a5568;
+	--menu-background-color: #2d3748;
+	--menu-text-color: #fff;
+	--menu-indent-line-color: #4a5568;
+	--menu-indent-line-active-color: #90cdf4;
+	--menu-scrollbar-color: #4a5568;
+	--menu-toggle-icon-color: #fff;
+	--menu-search-background-color: #4a5568;
+	--menu-search-font-color: #fff;
+	--toc-text-color: #90cdf4;
+	--toc-indicator-color: #4299e1;
+	--code-default-text-color: #cbd5e0;
+	--code-background-color: #2d3748;
+	--code-builtin-text-color: #68d391;
+	--code-keyword-text-color: #63b3ed;
+	--code-function-text-color: #4fd1c5;
+	--code-comment-text-color: #a0aec0;
+	--code-punctuation-text-color: #a0aec0;
+	--code-symbol-text-color: #ed64a6;
+}
+body {
+	margin: 0;
+	font-family: Roboto, -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+	background-color: #fff;
+	background-color: var(--background-color);
+	color: #000;
+	color: var(--text-color);
+	overflow-y: scroll;
+}
+
+/** Reset for menus */
+.doc-nav ul,
+.doc-toc ul {
+	list-style: none;
+	padding: 0;
+	margin: 0;
+}
+
+/* Left nav */
+.doc-nav {
+	position: fixed;
+	width: 100%;
+	left: 0;
+	right: 0;
+	top: 0;
+	display: flex;
+	background-color: #4b6c88;
+	background-color: var(--menu-background-color);
+	color: #fff;
+	color: var(--menu-text-color);
+	flex-direction: column;
+	overflow-y: auto;
+	height: 100vh;
+	z-index: 10;
+	scrollbar-width: thin;
+	scrollbar-color: #a0aec0 transparent;
+	scrollbar-color: var(--menu-scrollbar-color) transparent;
+}
+*::-webkit-scrollbar {
+	width: 8px;
+	height: 8px;
+}
+*::-webkit-scrollbar-track {
+	background: transparent;
+}
+*::-webkit-scrollbar-thumb {
+	background-color: #a0aec0;
+	background-color: var(--menu-scrollbar-color);
+	border: 3px solid transparent;
+}
+.doc-nav li {
+	line-height: 1.8;
+	font-weight: 300;
+}
+.doc-nav .content.show {
+	display: flex;
+}
+.doc-nav .content.hidden {
+	display: none;
+}
+.doc-nav #toggle-menu {
+	cursor: pointer;
+	padding: 0.3rem;
+	fill: #fff;
+	fill: var(--menu-toggle-icon-color);
+}
+.doc-nav #toggle-menu:active {
+	background-color: #00000044;
+	background-color: var(--menu-toggle-icon-hover-color);
+	border-radius: 5rem;
+}
+.doc-nav > .heading-container {
+	position: relative;
+	/* IE11 */
+	position: sticky;
+	position: -webkit-sticky;
+	top: 0;
+	background-color: #4b6c88;
+	background-color: var(--menu-background-color);
+	z-index: 10;
+}
+.doc-nav > .heading-container > .heading {
+	display: flex;
+	padding: 0 1rem;
+	height: 56px;
+}
+.doc-nav > .heading-container > .heading > .module {
+	font-size: 1.6rem;
+	font-weight: 500;
+	margin: 0;
+}
+.doc-nav > .heading-container > .heading > .toggle-version-container {
+	display: flex;
+	align-items: center;
+}
+.doc-nav > .heading-container > .heading > .toggle-version-container > #dark-mode-toggle {
+	cursor: pointer;
+	fill: #fff;
+	display: flex;
+	visibility: hidden;
+}
+.doc-nav > .heading-container > .heading > .toggle-version-container > #dark-mode-toggle > svg {
+	width: 1.2rem;
+	height: 1.2rem;
+}
+.doc-nav > .heading-container > .heading > #search {
+	margin-top: 1rem;
+	border: none;
+	border-radius: 0.2rem;
+	padding: 0.5rem 1rem;
+	outline: none;
+	background-color: #00000044;
+	background-color: var(--menu-search-background-color);
+	color: #fff;
+	color: var(--menu-search-text-color);
+	margin-left: -0.6rem;
+	margin-right: -0.6rem;
+}
+.doc-nav > .heading-container > .heading > #search::placeholder {
+	color: #edf2f7;
+	text-transform: uppercase;
+	font-size: 12px;
+	font-weight: 600;
+}
+.doc-nav > .heading-container > .heading > #search:-ms-input-placeholder {
+	color: #edf2f7;
+	text-transform: uppercase;
+	font-size: 12px;
+	font-weight: 600;
+}
+.doc-nav > .content {
+	padding: 0 2rem 2rem 2rem;
+	display: flex;
+	flex-direction: column;
+}
+.doc-nav > .content > ul > li.active {
+	font-weight: 600;
+}
+.doc-nav > .content > ul > li.open ul {
+	display: initial;
+}
+.doc-nav > .content > ul > li.open > .menu-row > .dropdown-arrow {
+	transform: initial;
+}
+.doc-nav > .content > ul > li > .menu-row {
+	display: flex;
+	align-items: center;
+}
+.doc-nav > .content > ul > li > .menu-row > .dropdown-arrow {
+	transform: rotate(-90deg);
+	height: 18px;
+	width: 18px;
+	margin-left: calc(-18px - 0.3rem);
+	margin-right: 0.3rem;
+	cursor: pointer;
+	fill: #fff;
+	pointer-events: all;
+}
+.doc-nav > .content > ul > li > ul {
+	margin: 0.4rem 0;
+	display: none;
+}
+.doc-nav > .content > ul > li > ul > li {
+	border-color: #ffffff66;
+	border-color: var(--menu-indent-line-color);
+	border-left-width: 1.7px;
+	border-left-style: solid;
+	padding-left: 0.7rem;
+}
+.doc-nav > .content > ul > li > ul > li.active {
+	border-color: #00000066;
+	border-color: var(--menu-indent-line-active-color);
+}
+.doc-nav > .content a {
+	color: #fff;
+	color: var(--menu-text-color);
+	text-decoration: none;
+	user-select: none;
+}
+.doc-nav > .content a:hover {
+	text-decoration: underline;
+}
+
+/* Main content */
+.doc-container {
+	display: flex;
+	flex-direction: column-reverse;
+	margin-top: 56px;
+}
+.doc-content {
+	display: flex;
+	flex-direction: column;
+	padding: 1rem;
+	overflow: hidden;
+}
+.doc-content p {
+	line-height: 1.4;
+}
+.doc-content a {
+	color: #2779bd;
+	color: var(--link-color);
+}
+.doc-content > .doc-node {
+	padding: 5rem 0 2rem 0;
+	margin-top: -4rem;
+	overflow: hidden;
+	word-break: break-all; /* IE11 */
+	word-break: break-word;
+}
+.doc-content > .doc-node.const:nth-child(2) {
+  padding-bottom: 0 !important;
+}
+.doc-content > .doc-node.const:not(:first-child) {
+	padding-top: 4rem;
+}
+.doc-content > .doc-node.const:not(:last-child) {
+	padding-bottom: 2rem;
+}
+.doc-content > .timestamp {
+	font-size: 0.8rem;
+	color: #b8c2cc;
+	color: var(--timestamp-color);
+}
+.doc-content > .doc-node > .title {
+	display: flex;
+	align-items: center;
+	margin-bottom: 1rem;
+	border-bottom: 1px solid #f1f5f8;
+	border-bottom: 1px solid var(--title-bottom-line-color);
+}
+.doc-content > .doc-node > .title > .link {
+	display: flex;
+	margin-left: auto;
+	fill: #dae1e7;
+	fill: var(--ref-symbol-color);
+}
+.doc-content > .doc-node > .title > .link:hover {
+	fill: #b8c2cc;
+	fill: var(--ref-symbol-hover-color);
+}
+.doc-content > .doc-node h1 {
+	font-size: 2.5rem;
+	font-weight: 400;
+}
+.doc-content > .doc-node .signature {
+	border-color: #a0aec0;
+	border-color: var(--code-signature-border-color);
+	border-left-width: 3px;
+	border-left-style: solid;
+}
+.doc-content > .doc-node > ul > li .task-list-item-checkbox {
+	margin-right: 0.5rem;
+}
+.doc-content > .doc-node > .title h1,
+.doc-content > .doc-node > .title h2,
+.doc-content > .doc-node > .title h3,
+.doc-content > .doc-node > .title h4,
+.doc-content > .doc-node > .title h5,
+.doc-content > .doc-node > .title h6 {
+	font-weight: 400;
+	padding-top: 0.6rem 0;
+	margin: 0;
+}
+.doc-content > .doc-node > .title h1 a,
+.doc-content > .doc-node > .title h2 a,
+.doc-content > .doc-node > .title h3 a,
+.doc-content > .doc-node > .title h4 a,
+.doc-content > .doc-node > .title h5 a,
+.doc-content > .doc-node > .title h6 a {
+	text-decoration: none;
+	color: #dae1e7;
+	color: var(--ref-symbol-color);
+}
+.doc-content > .doc-node > .title h1 a:hover,
+.doc-content > .doc-node > .title h2 a:hover,
+.doc-content > .doc-node > .title h3 a:hover,
+.doc-content > .doc-node > .title h4 a:hover,
+.doc-content > .doc-node > .title h5 a:hover,
+.doc-content > .doc-node > .title h6 a:hover {
+	color: #b8c2cc;
+	color: var(--ref-symbol-hover-color);
+}
+.doc-content > .footer {
+	padding-top: 1rem;
+	margin-top: auto;
+	bottom: 1rem;
+	color: 616161;
+	color: var(--footer-text-color);
+	border-color: #f1f5f8;
+	border-color: var(--footer-top-line-color);
+	border-top-style: solid;
+	border-top-width: 1px;
+	font-size: 0.8rem;
+	font-weight: 500;
+}
+
+/* Right menu */
+.doc-toc {
+	right: 0;
+	top: 0;
+	height: 100%;
+	overflow-y: auto;
+	padding: 1rem 1rem 0 1rem;
+	width: 100%;
+	box-sizing: border-box;
+	-ms-overflow-style: none;
+	scrollbar-width: none;
+}
+.doc-toc::-webkit-scrollbar {
+	display: none;
+}
+.doc-toc li {
+	line-height: 1.5;
+}
+.doc-toc a {
+	color: #2779bd;
+	color: var(--toc-text-color);
+	font-size: 0.9rem;
+	font-weight: 600;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	display: block;
+	text-decoration: none;
+	border-left-width: 2px;
+	border-left-style: solid;
+	border-color: transparent;
+	padding-left: 0.4rem;
+}
+.doc-toc a:hover {
+	text-decoration: underline;
+}
+.doc-toc a.active {
+	border-color: #4299e1;
+	border-color: var(--toc-indicator-color);
+}
+.doc-toc li ul {
+	margin: 0.2rem 0 0.2rem;
+	font-size: 0.7rem;
+	list-style: none;
+}
+.doc-toc li ul a {
+	font-weight: 400;
+	padding-left: 0.8rem;
+}
+
+/* Code highlight */
+pre, code, pre code {
+  color: #5c6e74;
+  color: var(--code-default-text-color);
+  font-size: 0.948em;
+  text-shadow: none;
+  font-family: monospace;
+  background-color: #edf2f7;
+  background-color: var(--code-background-color);
+  border-radius: 0.25rem;
+}
+pre code {
+  direction: ltr;
+  text-align: left;
+  white-space: pre;
+  word-spacing: normal;
+  word-break: normal;
+  line-height: 1.5;
+  -moz-tab-size: 4;
+  -o-tab-size: 4;
+  tab-size: 4;
+  -webkit-hyphens: none;
+  -moz-hyphens: none;
+  -ms-hyphens: none;
+  hyphens: none;
+  display: block;
+  overflow-x: auto;
+  padding: 1rem;
+}
+code {
+  padding: 0.2rem;
+  vertical-align: middle;
+}
+pre {
+  overflow: auto;
+  margin: 0;
+}
+.namespace {
+  opacity: .7;
+}
+.token.comment {
+  color: #93a1a1;
+  color: var(--code-comment-text-color)
+}
+.token.punctuation {
+  color: #999999;
+  color: var(--code-punctuation-text-color);
+}
+.token.number,
+.token.symbol {
+  color: #702459;
+  color: var(--code-symbol-text-color);
+}
+.token.string,
+.token.char,
+.token.builtin {
+  color: #38a169;
+  color: var(--code-builtin-text-color);
+}
+.token.operator,
+.token.entity,
+.token.url,
+.language-css .token.string,
+.style .token.string {
+  color: #a67f59;
+  color: var(--code-operator-text-color);
+  background: transparent;
+}
+.token.boolean,
+.token.keyword {
+  color: #2b6cb0;
+  color: var(--code-keyword-text-color);
+}
+.token.function {
+  color: #319795;
+  color: var(--code-function-text-color);
+}
+
+/* Medium screen and up */
+@media (min-width: 768px) {
+	.doc-container {
+		flex-direction: row;
+	}
+	.doc-content {
+		font-size: 0.95rem;
+		flex: 1;
+		padding: 1rem 2rem;
+	}
+	.doc-toc {
+		position: relative;
+		/* IE11 */
+		position: sticky;
+		position: -webkit-sticky;
+		align-self: flex-start;
+		top: 56px;
+		height: auto;
+		height: 100vh;
+		min-width: 200px;
+		width: auto;
+		max-width: 300px;
+	}
+	.doc-toc > ul {
+		padding-bottom: 1rem;
+	}
+}
+
+@media (max-width: 1023px) {
+	.doc-nav.hidden {
+		height: auto;
+	}
+	.doc-nav > .heading-container > .heading {
+		align-items: center;
+	}
+	.doc-nav > .heading-container > .heading > .toggle-version-container {
+		flex-grow: 1;
+		padding: 0 1rem;
+		justify-content: space-between;
+	}
+	.doc-nav > .heading-container > .heading > #search {
+		display: none;
+	}
+}
+
+@media (min-width: 1024px) {
+	.doc-nav {
+		width: 300px;
+	}
+	.doc-nav #toggle-menu {
+		display: none;
+	}
+	.doc-nav > .heading-container > .heading {
+		height: auto;
+		padding: 1rem 2rem;
+		flex-direction: column-reverse;
+		justify-content: center;
+	}
+	.doc-nav > .heading-container > .heading > .toggle-version-container {
+		align-items: center;
+		margin-bottom: 0.2rem;
+		display: flex;
+		flex-direction: row-reverse;
+	}
+	.doc-nav > .heading-container > .heading > .toggle-version-container > #dark-mode-toggle {
+		margin-right: auto;
+	}
+	.doc-nav .content.show,
+	.doc-nav .content.hidden {
+		display: flex;
+	}
+	.doc-content > .doc-node.const:nth-child(2) {
+		padding-bottom: 0 !important;
+	}
+	.doc-content > .doc-node.const:not(:first-child) {
+		padding-top: 0;
+	}
+	.doc-content > .doc-node.const:not(:last-child) {
+		padding-bottom: 1rem;
+	}
+	.doc-container {
+		margin-top: 0;
+		margin-left: 300px;
+	}
+	.doc-node {
+		padding-top: 1rem !important;
+		margin-top: 0 !important;
+	}
+	.doc-toc {
+		top: 0;
+	}
+}

cmd/tools/vdoc-resources/doc.js

@@ -0,0 +1,121 @@
+(function() {
+    if (document.body.scrollIntoView) {
+        var docnav = document.querySelector('.doc-nav');
+        var active = docnav.querySelector('li.active');
+        if (active) {
+            active.scrollIntoView({ block: 'center', inline: 'nearest' });
+        }
+    }
+    setupScrollSpy();
+    setupMobileToggle();
+    setupDarkMode();
+    setupSearch();
+    setupCollapse();
+})();
+
+function setupScrollSpy() {
+    var sectionPositions = [];
+    var sections = document.querySelectorAll('section');
+    sections.forEach(function(section) {
+        sectionPositions.push(section.offsetTop);
+    });
+    var scrollPos = 0;
+    window.addEventListener('scroll', function(e) {
+        // Reset classes
+        document.querySelectorAll('.doc-toc a[class="active"]').forEach(function(link) {
+            link.classList.remove('active');
+        });
+        // Set current menu link as active
+        var scrollPosition = document.documentElement.scrollTop || document.body.scrollTop;
+        for (var i = 0; i < sectionPositions.length; i++) {
+            var section = sections[i];
+            var position = sectionPositions[i];
+            if (position >= scrollPosition) {
+                var link = document.querySelector('.doc-toc a[href="#' + section.id + '"]');
+                if (link) {
+                    link.classList.add('active');
+                    var docToc = document.querySelector('.doc-toc');
+                    var tocHeight = docToc.clientHeight;
+                    var scrollTop = docToc.scrollTop;
+                    if ((document.body.getBoundingClientRect()).top < scrollPos && scrollTop < link.offsetTop - 10) {
+                        docToc.scrollTop = link.clientHeight + link.offsetTop - tocHeight + 10;
+                    } else if (scrollTop > link.offsetTop - 10) {
+                        docToc.scrollTop = link.offsetTop - 10;
+                    }
+                }
+                break;
+            }
+        }
+        scrollPos = (document.body.getBoundingClientRect()).top;
+    });
+}
+
+function setupMobileToggle() {
+    var toggle = document.getElementById('toggle-menu');
+    toggle.addEventListener('click', function(ev) {
+        document.querySelectorAll('.doc-nav').forEach(function(el) {
+            el.classList.toggle('hidden');
+        });
+        document.querySelectorAll('.doc-nav .content').forEach(function(el) {
+            el.classList.toggle('hidden');
+            el.classList.toggle('show');
+        });
+    });
+}
+
+function setupDarkMode() {
+    var html = document.getElementsByTagName('html')[0];
+    var darkModeToggle = document.getElementById('dark-mode-toggle');
+    darkModeToggle.addEventListener('click', function() {
+        html.classList.toggle('dark');
+        var isDarkModeEnabled = html.classList.contains('dark');
+        localStorage.setItem('dark-mode', isDarkModeEnabled);
+        darkModeToggle.setAttribute('aria-checked', isDarkModeEnabled)
+    });
+    if (localStorage.getItem('dark-mode') === 'true') {
+        html.classList.add('dark');
+    }
+
+    // Check if css var() is supported and enable dark mode toggle
+    if (window.CSS && CSS.supports('color', 'var(--fake-var)')) {
+        darkModeToggle.style.visibility = 'unset';
+    }
+}
+
+function setupSearch() {
+    var searchInput = document.getElementById('search');
+    searchInput.addEventListener('input', function(e) {
+        var searchValue = e.target.value.toLowerCase();
+        var menuItems = document.querySelectorAll('.content > ul > li');
+        for (var i = 0; i < menuItems.length; i++) {
+            var menuItem = menuItems[i];
+            var links = menuItem.querySelectorAll('a');
+            var hasResult = false;
+            for (var li = 0; li < links.length; li++) {
+                var link = links[li];
+                if (!searchValue || link.text.toLowerCase().indexOf(searchValue) !== -1) {
+                    hasResult = true;
+                }
+                if (li > 0) {
+                    if (!searchValue || link.text.toLowerCase().indexOf(searchValue) !== -1) {
+                        link.style.display = '';
+                    } else {
+                        link.style.display = 'none';
+                    }
+                }
+            }
+            menuItem.style.display = !searchValue || hasResult ? '' : 'none';
+        }
+    });
+}
+
+function setupCollapse() {
+    var dropdownArrows = document.querySelectorAll('.dropdown-arrow');
+    for (var i = 0; i < dropdownArrows.length; i++) {
+        var dropdownArrow = dropdownArrows[i];
+        dropdownArrow.addEventListener('click', function(e) {
+            var parent = e.target.parentElement.parentElement.parentElement;
+            parent.classList.toggle('open');
+        });
+    }
+}

cmd/tools/vdoc-resources/light.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" class="light-icon" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"/></svg>

cmd/tools/vdoc-resources/link.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"/></svg>

cmd/tools/vdoc-resources/menu.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" id="toggle-menu" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z"/></svg>

cmd/tools/vdoc-resources/normalize.css

@@ -0,0 +1,171 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+html {
+	line-height: 1.15;
+	-webkit-text-size-adjust: 100%;
+}
+
+main {
+	display: block;
+}
+
+h1 {
+	font-size: 2em;
+	margin: 0.67em 0;
+}
+
+hr {
+	box-sizing: content-box;
+	height: 0;
+	overflow: visible;
+}
+
+pre {
+	font-family: monospace, monospace;
+	font-size: 1em;
+}
+
+a {
+	background-color: transparent;
+}
+
+abbr[title] {
+	border-bottom: none;
+	text-decoration: underline;
+	text-decoration: underline dotted;
+}
+
+b,
+strong {
+	font-weight: bolder;
+}
+
+kbd,
+samp {
+	font-family: monospace, monospace;
+	font-size: 1em;
+}
+
+small {
+	font-size: 80%;
+}
+
+sub,
+sup {
+	font-size: 75%;
+	line-height: 0;
+	position: relative;
+	vertical-align: baseline;
+}
+
+sub {
+	bottom: -0.25em;
+}
+
+sup {
+	top: -0.5em;
+}
+
+img {
+	border-style: none;
+}
+
+button,
+input,
+optgroup,
+select,
+textarea {
+	font-family: inherit;
+	font-size: 100%;
+	line-height: 1.15;
+	margin: 0;
+}
+
+button,
+input {
+	overflow: visible;
+}
+
+button,
+select {
+	text-transform: none;
+}
+
+button,
+[type="button"],
+[type="reset"],
+[type="submit"] {
+	-webkit-appearance: button;
+}
+
+button::-moz-focus-inner,
+[type="button"]::-moz-focus-inner,
+[type="reset"]::-moz-focus-inner,
+[type="submit"]::-moz-focus-inner {
+	border-style: none;
+	padding: 0;
+}
+
+button:-moz-focusring,
+[type="button"]:-moz-focusring,
+[type="reset"]:-moz-focusring,
+[type="submit"]:-moz-focusring {
+	outline: 1px dotted ButtonText;
+}
+
+fieldset {
+	padding: 0.35em 0.75em 0.625em;
+}
+
+legend {
+	box-sizing: border-box;
+	color: inherit;
+	display: table;
+	max-width: 100%;
+	padding: 0;
+	white-space: normal;
+}
+
+progress {
+	vertical-align: baseline;
+}
+
+textarea {
+	overflow: auto;
+}
+
+[type="checkbox"],
+[type="radio"] {
+	box-sizing: border-box;
+	padding: 0;
+}
+
+[type="number"]::-webkit-inner-spin-button,
+[type="number"]::-webkit-outer-spin-button {
+	height: auto;
+}
+
+[type="search"] {
+	-webkit-appearance: textfield;
+	outline-offset: -2px;
+}
+
+[type="search"]::-webkit-search-decoration {
+	-webkit-appearance: none;
+}
+
+::-webkit-file-upload-button {
+	-webkit-appearance: button;
+	font: inherit;
+}
+
+summary {
+	display: list-item;
+}
+
+template {
+	display: none;
+}
+
+[hidden] {
+	display: none;
+}

cmd/tools/vdoctor.v

@@ -0,0 +1,286 @@
+import os
+import time
+import v.util
+import runtime
+
+struct App {
+mut:
+	report_lines   []string
+	cached_cpuinfo map[string]string
+}
+
+fn (mut a App) println(s string) {
+	a.report_lines << s
+}
+
+fn (mut a App) collect_info() {
+	mut os_kind := os.user_os()
+	mut arch_details := []string{}
+	arch_details << '$runtime.nr_cpus() cpus'
+	if runtime.is_32bit() {
+		arch_details << '32bit'
+	}
+	if runtime.is_64bit() {
+		arch_details << '64bit'
+	}
+	if runtime.is_big_endian() {
+		arch_details << 'big endian'
+	}
+	if runtime.is_little_endian() {
+		arch_details << 'little endian'
+	}
+	if os_kind == 'macos' {
+		arch_details << a.cmd({
+			command: 'sysctl -n machdep.cpu.brand_string'
+		})
+	}
+	if os_kind == 'linux' {
+		info := a.cpu_info()
+		mut cpu_details := ''
+		if cpu_details == '' {
+			cpu_details = info['model name']
+		}
+		if cpu_details == '' {
+			cpu_details = info['hardware']
+		}
+		if cpu_details == '' {
+			cpu_details = os.uname().machine
+		}
+		arch_details << cpu_details
+	}
+	if os_kind == 'windows' {
+		arch_details << a.cmd({
+			command: 'wmic cpu get name /format:table'
+			line: 1
+		})
+	}
+	//
+	mut os_details := ''
+	wsl_check := a.cmd({
+		command: 'cat /proc/sys/kernel/osrelease'
+	})
+	if os_kind == 'linux' {
+		os_details = a.get_linux_os_name()
+		info := a.cpu_info()
+		if 'hypervisor' in info['flags'] {
+			if 'microsoft' in wsl_check {
+				// WSL 2 is a Managed VM and Full Linux Kernel
+				// See https://docs.microsoft.com/en-us/windows/wsl/compare-versions
+				os_details += ' (WSL 2)'
+			} else {
+				os_details += ' (VM)'
+			}
+		}
+		// WSL 1 is NOT a Managed VM and Full Linux Kernel
+		// See https://docs.microsoft.com/en-us/windows/wsl/compare-versions
+		if 'Microsoft' in wsl_check {
+			os_details += ' (WSL)'
+		}
+		// From https://unix.stackexchange.com/a/14346
+		if a.cmd(command: '[ "$(awk \'\$5=="/" {print \$1}\' </proc/1/mountinfo)" != "$(awk \'\$5=="/" {print \$1}\' </proc/$$/mountinfo)" ] ; echo \$?') == '0' {
+			os_details += ' (chroot)'
+		}
+	} else if os_kind == 'macos' {
+		mut details := []string{}
+		details << a.cmd({
+			command: 'sw_vers -productName'
+		})
+		details << a.cmd({
+			command: 'sw_vers -productVersion'
+		})
+		details << a.cmd({
+			command: 'sw_vers -buildVersion'
+		})
+		os_details = details.join(', ')
+	} else if os_kind == 'windows' {
+		wmic_info := a.cmd({
+			command: 'wmic os get * /format:value'
+			line: -1
+		})
+		p := a.parse(wmic_info, '=')
+		caption, build_number, os_arch := p['caption'], p['buildnumber'], p['osarchitecture']
+		os_details = '$caption v$build_number $os_arch'
+	} else {
+		ouname := os.uname()
+		os_details = '$ouname.release, $ouname.version'
+	}
+	a.line('OS', '$os_kind, $os_details')
+	a.line('Processor', arch_details.join(', '))
+	a.line('CC version', a.cmd({
+		command: 'cc --version'
+	}))
+	a.println('')
+	a.line('getwd', os.getwd())
+	vexe := os.getenv('VEXE')
+	vroot := os.dir(vexe)
+	os.chdir(vroot)
+	a.line('vroot', vroot)
+	a.line('vexe', vexe)
+	a.line('vexe mtime', time.unix(os.file_last_mod_unix(vexe)).str())
+	is_writable_vroot := os.is_writable_folder(vroot) or {
+		false
+	}
+	a.line('is vroot writable', is_writable_vroot.str())
+	a.line('V full version', util.full_v_version(true))
+	vtmp := os.getenv('VTMP')
+	if vtmp != '' {
+		a.line('env VTMP', '"$vtmp"')
+	}
+	vflags := os.getenv('VFLAGS')
+	if vflags != '' {
+		a.line('env VFLAGS', '"$vflags"')
+	}
+	a.println('')
+	a.line('Git version', a.cmd({
+		command: 'git --version'
+	}))
+	a.line('Git vroot status', a.git_info())
+	a.line('.git/config present', os.is_file('.git/config').str())
+	//
+	a.report_tcc_version('thirdparty/tcc')
+}
+
+struct CmdConfig {
+	line    int
+	command string
+}
+
+fn (mut a App) cmd(c CmdConfig) string {
+	x := os.exec(c.command) or {
+		return 'N/A'
+	}
+	if x.exit_code == 0 {
+		if c.line < 0 {
+			return x.output
+		}
+		output := x.output.split_into_lines()
+		if output.len > 0 && output.len > c.line {
+			return output[c.line]
+		}
+	}
+	return 'Error: $x.output'
+}
+
+fn (mut a App) line(label string, value string) {
+	a.println('$label: ${util.bold(value)}')
+}
+
+fn (app &App) parse(config string, sep string) map[string]string {
+	mut m := map[string]string{}
+	for line in config.split_into_lines() {
+		sline := line.trim_space()
+		if sline.len == 0 || sline[0] == `#` {
+			continue
+		}
+		x := sline.split(sep)
+		if x.len < 2 {
+			continue
+		}
+		m[x[0].trim_space().to_lower()] = x[1].trim_space().trim('"')
+	}
+	return m
+}
+
+fn (mut a App) get_linux_os_name() string {
+	mut os_details := ''
+	linux_os_methods := ['os-release', 'lsb_release', 'kernel', 'uname']
+	for m in linux_os_methods {
+		match m {
+			'os-release' {
+				if !os.is_file('/etc/os-release') {
+					continue
+				}
+				lines := os.read_file('/etc/os-release') or {
+					continue
+				}
+				vals := a.parse(lines, '=')
+				if vals['PRETTY_NAME'] == '' {
+					continue
+				}
+				os_details = vals['PRETTY_NAME']
+				break
+			}
+			'lsb_release' {
+				exists := a.cmd({
+					command: 'type lsb_release'
+				})
+				if exists.starts_with('Error') {
+					continue
+				}
+				os_details = a.cmd({
+					command: 'lsb_release -d -s'
+				})
+				break
+			}
+			'kernel' {
+				if !os.is_file('/proc/version') {
+					continue
+				}
+				os_details = a.cmd({
+					command: 'cat /proc/version'
+				})
+				break
+			}
+			'uname' {
+				ouname := os.uname()
+				os_details = '$ouname.release, $ouname.version'
+				break
+			}
+			else {}
+		}
+	}
+	return os_details
+}
+
+fn (mut a App) cpu_info() map[string]string {
+	if a.cached_cpuinfo.len > 0 {
+		return a.cached_cpuinfo
+	}
+	info := os.exec('cat /proc/cpuinfo') or {
+		return a.cached_cpuinfo
+	}
+	vals := a.parse(info.output, ':')
+	a.cached_cpuinfo = vals
+	return vals
+}
+
+fn (mut a App) git_info() string {
+	mut out := a.cmd({
+		command: 'git -C . describe --abbrev=8 --dirty --always --tags'
+	}).trim_space()
+	os.exec('git -C . remote add V_REPO https://github.com/vlang/v') or { } // ignore failure (i.e. remote exists)
+	os.exec('git -C . fetch V_REPO') or { }
+	commit_count := a.cmd({
+		command: 'git rev-list @{0}...V_REPO/master --right-only --count'
+	}).int()
+	if commit_count > 0 {
+		out += ' ($commit_count commit(s) behind V master)'
+	}
+	return out
+}
+
+fn (mut a App) report_tcc_version(tccfolder string) {
+	if !os.is_file(os.join_path(tccfolder, '.git', 'config')) {
+		a.line(tccfolder, 'N/A')
+		return
+	}
+	tcc_branch_name := a.cmd({
+		command: 'git -C $tccfolder rev-parse --abbrev-ref HEAD'
+	})
+	tcc_commit := a.cmd({
+		command: 'git -C $tccfolder describe --abbrev=8 --dirty --always --tags'
+	})
+	a.line('$tccfolder status', '$tcc_branch_name $tcc_commit')
+}
+
+fn (mut a App) report_info() {
+	for x in a.report_lines {
+		println(x)
+	}
+}
+
+fn main() {
+	mut app := App{}
+	app.collect_info()
+	app.report_info()
+}

cmd/tools/vfmt.v

@@ -0,0 +1,344 @@
+// Copyright (c) 2019-2020 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 os
+import os.cmdline
+import rand
+import v.ast
+import v.pref
+import v.fmt
+import v.util
+import v.parser
+import v.table
+import vhelp
+
+struct FormatOptions {
+	is_l       bool
+	is_c       bool // NB: This refers to the '-c' fmt flag, NOT the C backend
+	is_w       bool
+	is_diff    bool
+	is_verbose bool
+	is_all     bool
+	is_worker  bool
+	is_debug   bool
+	is_noerror bool
+	is_verify  bool // exit(1) if the file is not vfmt'ed
+}
+
+const (
+	formatted_file_token         = '\@\@\@' + 'FORMATTED_FILE: '
+	platform_and_file_extensions = [
+		['windows', '_windows.v'],
+		['linux', '_lin.v', '_linux.v', '_nix.v'],
+		['macos', '_mac.v', '_darwin.v'],
+		['freebsd', '_bsd.v', '_freebsd.v'],
+		['netbsd', '_bsd.v', '_netbsd.v'],
+		['openbsd', '_bsd.v', '_openbsd.v'],
+		['solaris', '_solaris.v'],
+		['haiku', '_haiku.v'],
+		['qnx', '_qnx.v'],
+	]
+)
+
+fn main() {
+	// if os.getenv('VFMT_ENABLE') == '' {
+	// eprintln('v fmt is disabled for now')
+	// exit(1)
+	// }
+	toolexe := os.executable()
+	util.set_vroot_folder(os.dir(os.dir(os.dir(toolexe))))
+	args := util.join_env_vflags_and_os_args()
+	foptions := FormatOptions{
+		is_c: '-c' in args
+		is_l: '-l' in args
+		is_w: '-w' in args
+		is_diff: '-diff' in args
+		is_verbose: '-verbose' in args || '--verbose' in args
+		is_all: '-all' in args || '--all' in args
+		is_worker: '-worker' in args
+		is_debug: '-debug' in args
+		is_noerror: '-noerror' in args
+		is_verify: '-verify' in args
+	}
+	if foptions.is_verbose {
+		eprintln('vfmt foptions: $foptions')
+	}
+	if foptions.is_worker {
+		// -worker should be added by a parent vfmt process.
+		// We launch a sub process for each file because
+		// the v compiler can do an early exit if it detects
+		// a syntax error, but we want to process ALL passed
+		// files if possible.
+		foptions.format_file(cmdline.option(args, '-worker', ''))
+		exit(0)
+	}
+	// we are NOT a worker at this stage, i.e. we are a parent vfmt process
+	possible_files := cmdline.only_non_options(cmdline.options_after(args, ['fmt']))
+	if foptions.is_verbose {
+		eprintln('vfmt toolexe: $toolexe')
+		eprintln('vfmt args: ' + os.args.str())
+		eprintln('vfmt env_vflags_and_os_args: ' + args.str())
+		eprintln('vfmt possible_files: ' + possible_files.str())
+	}
+	mut files := []string{}
+	for file in possible_files {
+		if os.is_dir(file) {
+			files << os.walk_ext(file, '.v')
+			files << os.walk_ext(file, '.vsh')
+			continue
+		}
+		if !file.ends_with('.v') && !file.ends_with('.vv') && !file.ends_with('.vsh') {
+			verror('v fmt can only be used on .v files.\nOffending file: "$file"')
+			continue
+		}
+		if !os.exists(file) {
+			verror('"$file" does not exist')
+			continue
+		}
+		files << file
+	}
+	if files.len == 0 {
+		vhelp.show_topic('fmt')
+		exit(0)
+	}
+	mut cli_args_no_files := []string{}
+	for a in os.args {
+		if a !in files {
+			cli_args_no_files << a
+		}
+	}
+	mut errors := 0
+	for file in files {
+		fpath := os.real_path(file)
+		mut worker_command_array := cli_args_no_files.clone()
+		worker_command_array << ['-worker', util.quote_path(fpath)]
+		worker_cmd := worker_command_array.join(' ')
+		if foptions.is_verbose {
+			eprintln('vfmt worker_cmd: $worker_cmd')
+		}
+		worker_result := os.exec(worker_cmd) or {
+			errors++
+			continue
+		}
+		if worker_result.exit_code != 0 {
+			eprintln(worker_result.output)
+			if worker_result.exit_code == 1 {
+				eprintln('vfmt error while formatting file: $file .')
+			}
+			errors++
+			continue
+		}
+		if worker_result.output.len > 0 {
+			if worker_result.output.contains(formatted_file_token) {
+				wresult := worker_result.output.split(formatted_file_token)
+				formatted_warn_errs := wresult[0]
+				formatted_file_path := wresult[1].trim_right('\n\r')
+				foptions.post_process_file(fpath, formatted_file_path)
+				if formatted_warn_errs.len > 0 {
+					eprintln(formatted_warn_errs)
+				}
+				continue
+			}
+		}
+		errors++
+	}
+	if errors > 0 {
+		eprintln('Encountered a total of: $errors errors.')
+		if foptions.is_noerror {
+			exit(0)
+		}
+		exit(1)
+	}
+}
+
+fn (foptions &FormatOptions) format_file(file string) {
+	mut prefs := pref.new_preferences()
+	prefs.is_fmt = true
+	if foptions.is_verbose {
+		eprintln('vfmt2 running fmt.fmt over file: $file')
+	}
+	table := table.new_table()
+	// checker := checker.new_checker(table, prefs)
+	file_ast := parser.parse_file(file, table, .parse_comments, prefs, &ast.Scope{
+		parent: 0
+	})
+	// checker.check(file_ast)
+	formatted_content := fmt.fmt(file_ast, table, foptions.is_debug)
+	file_name := os.file_name(file)
+	ulid := rand.ulid()
+	vfmt_output_path := os.join_path(os.temp_dir(), 'vfmt_${ulid}_$file_name')
+	os.write_file(vfmt_output_path, formatted_content)
+	if foptions.is_verbose {
+		eprintln('fmt.fmt worked and $formatted_content.len bytes were written to $vfmt_output_path .')
+	}
+	eprintln('$formatted_file_token$vfmt_output_path')
+}
+
+fn print_compiler_options(compiler_params &pref.Preferences) {
+	eprintln('         os: ' + compiler_params.os.str())
+	eprintln('  ccompiler: $compiler_params.ccompiler')
+	eprintln('       path: $compiler_params.path ')
+	eprintln('   out_name: $compiler_params.out_name ')
+	eprintln('      vroot: $compiler_params.vroot ')
+	eprintln('lookup_path: $compiler_params.lookup_path ')
+	eprintln('   out_name: $compiler_params.out_name ')
+	eprintln('     cflags: $compiler_params.cflags ')
+	eprintln('    is_test: $compiler_params.is_test ')
+	eprintln('  is_script: $compiler_params.is_script ')
+}
+
+fn (foptions &FormatOptions) post_process_file(file string, formatted_file_path string) {
+	if formatted_file_path.len == 0 {
+		return
+	}
+	if foptions.is_diff {
+		diff_cmd := util.find_working_diff_command() or {
+			eprintln(err)
+			return
+		}
+		if foptions.is_verbose {
+			eprintln('Using diff command: $diff_cmd')
+		}
+		println(util.color_compare_files(diff_cmd, file, formatted_file_path))
+		return
+	}
+	if foptions.is_verify {
+		diff_cmd := util.find_working_diff_command() or {
+			eprintln(err)
+			return
+		}
+		x := util.color_compare_files(diff_cmd, file, formatted_file_path)
+		if x.len != 0 {
+			println("$file is not vfmt'ed")
+			exit(1)
+		}
+		return
+	}
+	fc := os.read_file(file) or {
+		eprintln('File $file could not be read')
+		return
+	}
+	formatted_fc := os.read_file(formatted_file_path) or {
+		eprintln('File $formatted_file_path could not be read')
+		return
+	}
+	is_formatted_different := fc != formatted_fc
+	if foptions.is_c {
+		if is_formatted_different {
+			eprintln('File is not formatted: $file')
+			exit(2)
+		}
+		return
+	}
+	if foptions.is_l {
+		if is_formatted_different {
+			eprintln('File needs formatting: $file')
+		}
+		return
+	}
+	if foptions.is_w {
+		if is_formatted_different {
+			os.mv_by_cp(formatted_file_path, file) or {
+				panic(err)
+			}
+			eprintln('Reformatted file: $file')
+		} else {
+			eprintln('Already formatted file: $file')
+		}
+		return
+	}
+	print(formatted_fc)
+}
+
+fn (f FormatOptions) str() string {
+	return 'FormatOptions{ is_l: $f.is_l, is_w: $f.is_w, is_diff: $f.is_diff, is_verbose: $f.is_verbose,' +
+		' is_all: $f.is_all, is_worker: $f.is_worker, is_debug: $f.is_debug, is_noerror: $f.is_noerror,' +
+		' is_verify: $f.is_verify" }'
+}
+
+fn file_to_target_os(file string) string {
+	for extensions in platform_and_file_extensions {
+		for ext in extensions {
+			if file.ends_with(ext) {
+				return extensions[0]
+			}
+		}
+	}
+	return ''
+}
+
+fn file_to_mod_name_and_is_module_file(file string) (string, bool) {
+	mut mod_name := 'main'
+	mut is_module_file := false
+	flines := read_source_lines(file) or {
+		return mod_name, is_module_file
+	}
+	for fline in flines {
+		line := fline.trim_space()
+		if line.starts_with('module ') {
+			if !line.starts_with('module main') {
+				is_module_file = true
+				mod_name = line.replace('module ', ' ').trim_space()
+			}
+			break
+		}
+	}
+	return mod_name, is_module_file
+}
+
+fn read_source_lines(file string) ?[]string {
+	source_lines := os.read_lines(file) or {
+		return error('can not read $file')
+	}
+	return source_lines
+}
+
+fn get_compile_name_of_potential_v_project(file string) string {
+	// This function get_compile_name_of_potential_v_project returns:
+	// a) the file's folder, if file is part of a v project
+	// b) the file itself, if the file is a standalone v program
+	pfolder := os.real_path(os.dir(file))
+	// a .v project has many 'module main' files in one folder
+	// if there is only one .v file, then it must be a standalone
+	all_files_in_pfolder := os.ls(pfolder) or {
+		panic(err)
+	}
+	mut vfiles := []string{}
+	for f in all_files_in_pfolder {
+		vf := os.join_path(pfolder, f)
+		if f.starts_with('.') || !f.ends_with('.v') || os.is_dir(vf) {
+			continue
+		}
+		vfiles << vf
+	}
+	if vfiles.len == 1 {
+		return file
+	}
+	// /////////////////////////////////////////////////////////////
+	// At this point, we know there are many .v files in the folder
+	// We will have to read them all, and if there are more than one
+	// containing `fn main` then the folder contains multiple standalone
+	// v programs. If only one contains `fn main` then the folder is
+	// a project folder, that should be compiled with `v pfolder`.
+	mut main_fns := 0
+	for f in vfiles {
+		slines := read_source_lines(f) or {
+			panic(err)
+		}
+		for line in slines {
+			if line.contains('fn main()') {
+				main_fns++
+				if main_fns > 1 {
+					return file
+				}
+			}
+		}
+	}
+	return pfolder
+}
+
+fn verror(s string) {
+	util.verror('vfmt error', s)
+}

cmd/tools/vpm.v

@@ -0,0 +1,601 @@
+// Copyright (c) 2019-2020 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 os
+import os.cmdline
+import net.http
+import json
+import vhelp
+import v.vmod
+
+const (
+	default_vpm_server_urls      = ['https://vpm.vlang.io']
+	valid_vpm_commands           = ['help', 'search', 'install', 'update', 'upgrade', 'outdated',
+		'list', 'remove']
+	excluded_dirs                = ['cache', 'vlib']
+	supported_vcs_systems        = ['git', 'hg']
+	supported_vcs_folders        = ['.git', '.hg']
+	supported_vcs_update_cmds    = {
+		'git': 'git pull'
+		'hg': 'hg pull --update'
+	}
+	supported_vcs_install_cmds   = {
+		'git': 'git clone --depth=1'
+		'hg': 'hg clone'
+	}
+	supported_vcs_outdated_steps = {
+		'git': ['git fetch', 'git rev-parse @', 'git rev-parse @{u}']
+		'hg': ['hg incoming']
+	}
+)
+
+struct Mod {
+	id           int
+	name         string
+	url          string
+	nr_downloads int
+	vcs          string
+}
+
+struct Vmod {
+mut:
+	name    string
+	version string
+	deps    []string
+}
+
+fn main() {
+	init_settings()
+	// This tool is intended to be launched by the v frontend,
+	// which provides the path to V inside os.getenv('VEXE')
+	args := os.args // args are: vpm [options] SUBCOMMAND module names
+	params := cmdline.only_non_options(args[1..])
+	verbose_println('cli params: $params')
+	if params.len < 1 {
+		vpm_help()
+		exit(5)
+	}
+	vpm_command := params[0]
+	mut module_names := params[1..]
+	ensure_vmodules_dir_exist()
+	// println('module names: ') println(module_names)
+	match vpm_command {
+		'help' {
+			vpm_help()
+		}
+		'search' {
+			vpm_search(module_names)
+		}
+		'install' {
+			if module_names.len == 0 && os.exists('./v.mod') {
+				println('Detected v.mod file inside the project directory. Using it...')
+				manifest := vmod.from_file('./v.mod') or {
+					panic(err)
+				}
+				module_names = manifest.dependencies
+			}
+			vpm_install(module_names)
+		}
+		'update' {
+			vpm_update(module_names)
+		}
+		'upgrade' {
+			vpm_upgrade()
+		}
+		'outdated' {
+			vpm_outdated()
+		}
+		'list' {
+			vpm_list()
+		}
+		'remove' {
+			vpm_remove(module_names)
+		}
+		else {
+			println('Error: you tried to run "v $vpm_command"')
+			println('... but the v package management tool vpm only knows about these commands:')
+			for validcmd in valid_vpm_commands {
+				println('    v $validcmd')
+			}
+			exit(3)
+		}
+	}
+}
+
+fn vpm_search(keywords []string) {
+	search_keys := keywords.map(it.replace('_', '-'))
+	if settings.is_help {
+		vhelp.show_topic('search')
+		exit(0)
+	}
+	if search_keys.len == 0 {
+		println('  v search requires *at least one* keyword')
+		exit(2)
+	}
+	modules := get_all_modules()
+	installed_modules := get_installed_modules()
+	joined := search_keys.join(', ')
+	mut index := 0
+	for mod in modules {
+		// TODO for some reason .filter results in substr error, so do it manually
+		for k in search_keys {
+			if !mod.contains(k) {
+				continue
+			}
+			if index == 0 {
+				println('Search results for "$joined":\n')
+			}
+			index++
+			mut parts := mod.split('.')
+			// in case the author isn't present
+			if parts.len == 1 {
+				parts << parts[0]
+				parts[0] = ' '
+			} else {
+				parts[0] = ' by ${parts[0]} '
+			}
+			installed := if mod in installed_modules { ' (installed)' } else { '' }
+			println('${index}. ${parts[1]}${parts[0]}[$mod]$installed')
+			break
+		}
+	}
+	if index == 0 {
+		vexe := os.getenv('VEXE')
+		vroot := os.real_path(os.dir(vexe))
+		mut messages := ['No module(s) found for `$joined` .']
+		for vlibmod in search_keys {
+			if os.is_dir(os.join_path(vroot, 'vlib', vlibmod)) {
+				messages << 'There is already an existing "$vlibmod" module in vlib, so you can just `import $vlibmod` .'
+			}
+		}
+		for m in messages {
+			println(m)
+		}
+	} else {
+		println('\nUse "v install author_name.module_name" to install the module.')
+	}
+}
+
+fn vpm_install(module_names []string) {
+	if settings.is_help {
+		vhelp.show_topic('install')
+		exit(0)
+	}
+	if module_names.len == 0 {
+		println('  v install requires *at least one* module name')
+		exit(2)
+	}
+	mut errors := 0
+	for n in module_names {
+		name := n.trim_space().replace('_', '-')
+		mod := get_module_meta_info(name) or {
+			errors++
+			println('Errors while retrieving meta data for module $name:')
+			println(err)
+			continue
+		}
+		mut vcs := mod.vcs
+		if vcs == '' {
+			vcs = supported_vcs_systems[0]
+		}
+		if vcs !in supported_vcs_systems {
+			errors++
+			println('Skipping module "$name", since it uses an unsupported VCS {$vcs} .')
+			continue
+		}
+		mod_name_as_path := mod.name.replace('.', os.path_separator).replace('-', '_').to_lower()
+		final_module_path := os.real_path(os.join_path(settings.vmodules_path, mod_name_as_path))
+		if os.exists(final_module_path) {
+			vpm_update([name])
+			continue
+		}
+		println('Installing module "$name" from $mod.url to $final_module_path ...')
+		vcs_install_cmd := supported_vcs_install_cmds[vcs]
+		cmd := '$vcs_install_cmd "$mod.url" "$final_module_path"'
+		verbose_println('      command: $cmd')
+		cmdres := os.exec(cmd) or {
+			errors++
+			println('Could not install module "$name" to "$final_module_path" .')
+			verbose_println('Error command: $cmd')
+			verbose_println('Error details: $err')
+			continue
+		}
+		if cmdres.exit_code != 0 {
+			errors++
+			println('Failed installing module "$name" to "$final_module_path" .')
+			verbose_println('Failed command: $cmd')
+			verbose_println('Failed command output:\n$cmdres.output')
+			continue
+		}
+		resolve_dependencies(name, final_module_path, module_names)
+	}
+	if errors > 0 {
+		exit(1)
+	}
+}
+
+fn vpm_update(m []string) {
+	mut module_names := m
+	if settings.is_help {
+		vhelp.show_topic('update')
+		exit(0)
+	}
+	if module_names.len == 0 {
+		module_names = get_installed_modules()
+	}
+	mut errors := 0
+	for name in module_names {
+		final_module_path := valid_final_path_of_existing_module(name) or {
+			continue
+		}
+		os.chdir(final_module_path)
+		println('Updating module "$name"...')
+		verbose_println('  work folder: $final_module_path')
+		vcs := vcs_used_in_dir(final_module_path) or {
+			continue
+		}
+		vcs_cmd := supported_vcs_update_cmds[vcs[0]]
+		verbose_println('    command: $vcs_cmd')
+		vcs_res := os.exec('$vcs_cmd') or {
+			errors++
+			println('Could not update module "$name".')
+			verbose_println('Error command: $vcs_cmd')
+			verbose_println('Error details:\n$err')
+			continue
+		}
+		if vcs_res.exit_code != 0 {
+			errors++
+			println('Failed updating module "$name".')
+			verbose_println('Failed command: $vcs_cmd')
+			verbose_println('Failed details:\n$vcs_res.output')
+			continue
+		} else {
+			verbose_println('    $vcs_res.output.trim_space()')
+		}
+		resolve_dependencies(name, final_module_path, module_names)
+	}
+	if errors > 0 {
+		exit(1)
+	}
+}
+
+fn get_outdated() ?[]string {
+	module_names := get_installed_modules()
+	mut outdated := []string{}
+	for name in module_names {
+		final_module_path := valid_final_path_of_existing_module(name) or {
+			continue
+		}
+		os.chdir(final_module_path)
+		vcs := vcs_used_in_dir(final_module_path) or {
+			continue
+		}
+		vcs_cmd_steps := supported_vcs_outdated_steps[vcs[0]]
+		mut outputs := []string{}
+		for step in vcs_cmd_steps {
+			res := os.exec(step) or {
+				verbose_println('Error command: $step')
+				verbose_println('Error details:\n$err')
+				return error('Error while checking latest commits for "$name".')
+			}
+			if vcs[0] == 'hg' {
+				if res.exit_code == 1 {
+					outdated << name
+				}
+			} else {
+				outputs << res.output
+			}
+		}
+		if vcs[0] == 'git' && outputs[1] != outputs[2] {
+			outdated << name
+		}
+	}
+	return outdated
+}
+
+fn vpm_upgrade() {
+	outdated := get_outdated() or {
+		exit(1)
+	}
+	if outdated.len > 0 {
+		vpm_update(outdated)
+	} else {
+		println('Modules are up to date.')
+	}
+}
+
+fn vpm_outdated() {
+	outdated := get_outdated() or {
+		exit(1)
+	}
+	if outdated.len > 0 {
+		println('Outdated modules:')
+		for m in outdated {
+			println('  $m')
+		}
+	} else {
+		println('Modules are up to date.')
+	}
+}
+
+fn vpm_list() {
+	module_names := get_installed_modules()
+	if module_names.len == 0 {
+		println('You have no modules installed.')
+		exit(0)
+	}
+	println('Installed modules:')
+	for mod in module_names {
+		println('  $mod')
+	}
+}
+
+fn vpm_remove(module_names []string) {
+	if settings.is_help {
+		vhelp.show_topic('remove')
+		exit(0)
+	}
+	if module_names.len == 0 {
+		println('  v update requires *at least one* module name')
+		exit(2)
+	}
+	for name in module_names {
+		final_module_path := valid_final_path_of_existing_module(name) or {
+			continue
+		}
+		println('Removing module "$name"...')
+		verbose_println('removing folder $final_module_path')
+		os.rmdir_all(final_module_path)
+		// delete author directory if it is empty
+		author := name.split('.')[0]
+		author_dir := os.real_path(os.join_path(settings.vmodules_path, author))
+		if os.is_dir_empty(author_dir) {
+			verbose_println('removing author folder $author_dir')
+			os.rmdir(author_dir)
+		}
+	}
+}
+
+fn valid_final_path_of_existing_module(name string) ?string {
+	mod_name_as_path := name.replace('.', os.path_separator).replace('-', '_').to_lower()
+	name_of_vmodules_folder := os.join_path(settings.vmodules_path, mod_name_as_path)
+	final_module_path := os.real_path(name_of_vmodules_folder)
+	if !os.exists(final_module_path) {
+		println('No module with name "$name" exists at $name_of_vmodules_folder')
+		return none
+	}
+	if !os.is_dir(final_module_path) {
+		println('Skipping "$name_of_vmodules_folder", since it is not a folder.')
+		return none
+	}
+	vcs_used_in_dir(final_module_path) or {
+		println('Skipping "$name_of_vmodules_folder", since it does not use a supported vcs.')
+		return none
+	}
+	return final_module_path
+}
+
+fn ensure_vmodules_dir_exist() {
+	if !os.is_dir(settings.vmodules_path) {
+		println('Creating $settings.vmodules_path/ ...')
+		os.mkdir(settings.vmodules_path) or {
+			panic(err)
+		}
+	}
+}
+
+fn vpm_help() {
+	vhelp.show_topic('vpm')
+}
+
+fn vcs_used_in_dir(dir string) ?[]string {
+	mut vcs := []string{}
+	for repo_subfolder in supported_vcs_folders {
+		checked_folder := os.real_path(os.join_path(dir, repo_subfolder))
+		if os.is_dir(checked_folder) {
+			vcs << repo_subfolder.replace('.', '')
+		}
+	}
+	if vcs.len == 0 {
+		return none
+	}
+	return vcs
+}
+
+fn get_installed_modules() []string {
+	dirs := os.ls(settings.vmodules_path) or {
+		return []
+	}
+	mut modules := []string{}
+	for dir in dirs {
+		adir := os.join_path(settings.vmodules_path, dir)
+		if dir in excluded_dirs || !os.is_dir(adir) {
+			continue
+		}
+		if os.exists(os.join_path(adir, 'v.mod')) && os.exists(os.join_path(adir, '.git', 'config')) {
+			// an official vlang module with a short module name, like `vsl`, `ui` or `markdown`
+			modules << dir
+			continue
+		}
+		author := dir
+		mods := os.ls(adir) or {
+			continue
+		}
+		for m in mods {
+			vcs_used_in_dir(os.join_path(adir, m)) or {
+				continue
+			}
+			modules << '${author}.$m'
+		}
+	}
+	return modules
+}
+
+fn get_all_modules() []string {
+	url := get_working_server_url()
+	r := http.get(url) or {
+		panic(err)
+	}
+	if r.status_code != 200 {
+		println('Failed to search vpm.vlang.io. Status code: $r.status_code')
+		exit(1)
+	}
+	s := r.text
+	mut read_len := 0
+	mut modules := []string{}
+	for read_len < s.len {
+		mut start_token := '<a href="/mod'
+		end_token := '</a>'
+		// get the start index of the module entry
+		mut start_index := s.index_after(start_token, read_len)
+		if start_index == -1 {
+			break
+		}
+		// get the index of the end of anchor (a) opening tag
+		// we use the previous start_index to make sure we are getting a module and not just a random 'a' tag
+		start_token = '">'
+		start_index = s.index_after(start_token, start_index) + start_token.len
+		// get the index of the end of module entry
+		end_index := s.index_after(end_token, start_index)
+		if end_index == -1 {
+			break
+		}
+		modules << s[start_index..end_index]
+		read_len = end_index
+		if read_len >= s.len {
+			break
+		}
+	}
+	return modules
+}
+
+fn resolve_dependencies(name string, module_path string, module_names []string) {
+	vmod_path := os.join_path(module_path, 'v.mod')
+	if !os.exists(vmod_path) {
+		return
+	}
+	data := os.read_file(vmod_path) or {
+		return
+	}
+	vmod := parse_vmod(data)
+	mut deps := []string{}
+	// filter out dependencies that were already specified by the user
+	for d in vmod.deps {
+		if d !in module_names {
+			deps << d
+		}
+	}
+	if deps.len > 0 {
+		println('Resolving $deps.len dependencies for module "$name"...')
+		verbose_println('Found dependencies: $deps')
+		vpm_install(deps)
+	}
+}
+
+fn parse_vmod(data string) Vmod {
+	keys := ['name', 'version', 'deps']
+	mut m := {
+		'name': ''
+		'version': ''
+		'deps': ''
+	}
+	for key in keys {
+		mut key_index := data.index('$key:') or {
+			continue
+		}
+		key_index += key.len + 1
+		m[key] = data[key_index..data.index_after('\n', key_index)].trim_space().replace("'",
+			'').replace('[', '').replace(']', '')
+	}
+	mut vmod := Vmod{}
+	vmod.name = m['name']
+	vmod.version = m['version']
+	if m['deps'].len > 0 {
+		vmod.deps = m['deps'].split(',')
+	}
+	return vmod
+}
+
+fn get_working_server_url() string {
+	server_urls := if settings.server_urls.len > 0 { settings.server_urls } else { default_vpm_server_urls }
+	for url in server_urls {
+		verbose_println('Trying server url: $url')
+		http.head(url) or {
+			verbose_println('                   $url failed.')
+			continue
+		}
+		return url
+	}
+	panic('No responding vpm server found. Please check your network connectivity and try again later.')
+}
+
+// settings context:
+struct VpmSettings {
+mut:
+	is_help       bool
+	is_verbose    bool
+	server_urls   []string
+	vmodules_path string
+}
+
+const (
+	settings = &VpmSettings{}
+)
+
+fn init_settings() {
+	mut s := &VpmSettings(0)
+	unsafe {
+		s = settings
+	}
+	s.is_help = '-h' in os.args || '--help' in os.args || 'help' in os.args
+	s.is_verbose = '-v' in os.args
+	s.server_urls = cmdline.options(os.args, '-server-url')
+	s.vmodules_path = os.vmodules_dir()
+}
+
+fn verbose_println(s string) {
+	if settings.is_verbose {
+		println(s)
+	}
+}
+
+fn get_module_meta_info(name string) ?Mod {
+	mut errors := []string{}
+	for server_url in default_vpm_server_urls {
+		modurl := server_url + '/jsmod/$name'
+		verbose_println('Retrieving module metadata from: $modurl ...')
+		r := http.get(modurl) or {
+			errors << 'Http server did not respond to our request for ${modurl}.'
+			errors << 'Error details: $err'
+			continue
+		}
+		if r.status_code == 404 || r.text.contains('404') {
+			errors <<
+				'Skipping module "$name", since $server_url reported that "$name" does not exist.'
+			continue
+		}
+		if r.status_code != 200 {
+			errors <<
+				'Skipping module "$name", since $server_url responded with $r.status_code http status code. Please try again later.'
+			continue
+		}
+		s := r.text
+		if s.len > 0 && s[0] != `{` {
+			errors << 'Invalid json data'
+			errors << s.trim_space().limit(100) + '...'
+			continue
+		}
+		mod := json.decode(Mod, s) or {
+			errors << 'Skipping module "$name", since its information is not in json format.'
+			continue
+		}
+		if '' == mod.url || '' == mod.name {
+			errors << 'Skipping module "$name", since it is missing name or url information.'
+			continue
+		}
+		return mod
+	}
+	return error(errors.join_lines())
+}

cmd/tools/vrepl.v

@@ -0,0 +1,362 @@
+// Copyright (c) 2019-2020 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 os
+import term
+import readline
+import os.cmdline
+import v.util
+
+struct Repl {
+mut:
+	indent         int // indentation level
+	in_func        bool // are we inside a new custom user function
+	line           string // the current line entered by the user
+	//
+	modules        []string // all the import modules
+	includes       []string // all the #include statements
+	functions      []string // all the user function declarations
+	functions_name []string // all the user function names
+	lines          []string // all the other lines/statements
+	temp_lines     []string // all the temporary expressions/printlns
+}
+
+const (
+	is_stdin_a_pipe = (is_atty(0) == 0)
+)
+
+fn new_repl() &Repl {
+	return &Repl{
+		modules: ['os', 'time', 'math']
+	}
+}
+
+fn (mut r Repl) checks() bool {
+	mut in_string := false
+	was_indent := r.indent > 0
+	for i := 0; i < r.line.len; i++ {
+		if r.line[i] == `\'` && (i == 0 || r.line[i - 1] != `\\`) {
+			in_string = !in_string
+		}
+		if r.line[i] == `{` && !in_string {
+			r.line = r.line[..i + 1] + '\n' + r.line[i + 1..]
+			i++
+			r.indent++
+		}
+		if r.line[i] == `}` && !in_string {
+			r.line = r.line[..i] + '\n' + r.line[i..]
+			i++
+			r.indent--
+			if r.indent == 0 {
+				r.in_func = false
+			}
+		}
+		if i + 2 < r.line.len && r.indent == 0 && r.line[i + 1] == `f` && r.line[i + 2] == `n` {
+			r.in_func = true
+		}
+	}
+	return r.in_func || (was_indent && r.indent <= 0) || r.indent > 0
+}
+
+fn (r &Repl) function_call(line string) bool {
+	for function in r.functions_name {
+		is_function_definition := line.replace(' ', '').starts_with('$function:=')
+		if line.starts_with(function) && !is_function_definition {
+			return true
+		}
+	}
+	return false
+}
+
+fn (r &Repl) current_source_code(should_add_temp_lines bool) string {
+	mut all_lines := []string{}
+	for mod in r.modules {
+		all_lines << 'import $mod\n'
+	}
+	all_lines << r.includes
+	all_lines << r.functions
+	all_lines << r.lines
+	if should_add_temp_lines {
+		all_lines << r.temp_lines
+	}
+	return all_lines.join('\n')
+}
+
+fn repl_help() {
+	println(util.full_v_version(false))
+	println('
+	|help                   Displays this information.
+	|list                   Show the program so far.
+	|reset                  Clears the accumulated program, so you can start a fresh.
+	|Ctrl-C, Ctrl-D, exit   Exits the REPL.
+	|clear                  Clears the screen.
+'.strip_margin())
+}
+
+fn run_repl(workdir string, vrepl_prefix string) {
+	if !is_stdin_a_pipe {
+		println(util.full_v_version(false))
+		println('Use Ctrl-C or `exit` to exit, or `help` to see other available commands')
+	}
+	file := os.join_path(workdir, '.${vrepl_prefix}vrepl.v')
+	temp_file := os.join_path(workdir, '.${vrepl_prefix}vrepl_temp.v')
+	mut prompt := '>>> '
+	defer {
+		if !is_stdin_a_pipe {
+			println('')
+		}
+		os.rm(file)
+		os.rm(temp_file)
+		$if windows {
+			os.rm(file[..file.len - 2] + '.exe')
+			os.rm(temp_file[..temp_file.len - 2] + '.exe')
+			$if msvc {
+				os.rm(file[..file.len - 2] + '.ilk')
+				os.rm(file[..file.len - 2] + '.pdb')
+				os.rm(temp_file[..temp_file.len - 2] + '.ilk')
+				os.rm(temp_file[..temp_file.len - 2] + '.pdb')
+			}
+		} $else {
+			os.rm(file[..file.len - 2])
+			os.rm(temp_file[..temp_file.len - 2])
+		}
+	}
+	mut r := new_repl()
+	vexe := os.getenv('VEXE')
+	for {
+		if r.indent == 0 {
+			prompt = '>>> '
+		} else {
+			prompt = '... '
+		}
+		oline := r.get_one_line(prompt) or {
+			break
+		}
+		line := oline.trim_space()
+		if line == '' && oline.ends_with('\n') {
+			continue
+		}
+		if line.len <= -1 || line == '' || line == 'exit' {
+			break
+		}
+		r.line = line
+		if r.line == '\n' {
+			continue
+		}
+		if r.line == 'clear' {
+			term.erase_display('2')
+			continue
+		}
+		if r.line == 'help' {
+			repl_help()
+			continue
+		}
+		if r.line.contains(':=') && r.line.contains('fn(') {
+			r.in_func = true
+			r.functions_name << r.line.all_before(':= fn(').trim_space()
+		}
+		if r.line.starts_with('fn') {
+			r.in_func = true
+			r.functions_name << r.line.all_after('fn').all_before('(').trim_space()
+		}
+		was_func := r.in_func
+		if r.checks() {
+			for rline in r.line.split('\n') {
+				if r.in_func || was_func {
+					r.functions << rline
+				} else {
+					r.temp_lines << rline
+				}
+			}
+			if r.indent > 0 {
+				continue
+			}
+			r.line = ''
+		}
+		if r.line == 'debug_repl' {
+			eprintln('repl: $r')
+			continue
+		}
+		if r.line == 'reset' {
+			r = new_repl()
+			continue
+		}
+		if r.line == 'list' {
+			source_code := r.current_source_code(true)
+			println('//////////////////////////////////////////////////////////////////////////////////////')
+			println(source_code)
+			println('//////////////////////////////////////////////////////////////////////////////////////')
+			continue
+		}
+		// Save the source only if the user is printing something,
+		// but don't add this print call to the `lines` array,
+		// so that it doesn't get called during the next print.
+		if r.line.starts_with('=') {
+			r.line = 'println(' + r.line[1..] + ')'
+		}
+		if r.line.starts_with('print') {
+			source_code := r.current_source_code(false) + '\n$r.line\n'
+			os.write_file(file, source_code)
+			s := os.exec('"$vexe" -repl run "$file"') or {
+				rerror(err)
+				return
+			}
+			print_output(s)
+		} else {
+			mut temp_line := r.line
+			mut temp_flag := false
+			func_call := r.function_call(r.line)
+			filter_line := r.line.replace(r.line.find_between("\'", "\'"), '').replace(r.line.find_between('"',
+				'"'), '')
+			possible_statement_patterns := [
+				'=',
+				'++',
+				'--',
+				'<<',
+				'//',
+				'/*',
+				'fn ',
+				'pub ',
+				'mut ',
+				'enum ',
+				'const ',
+				'struct ',
+				'interface ',
+				'import ',
+				'#include ',
+				':=',
+				'for ',
+				'or ',
+				'insert',
+				'delete',
+				'prepend',
+				'sort',
+				'clear',
+				'trim',
+			]
+			mut is_statement := false
+			for pattern in possible_statement_patterns {
+				if filter_line.contains(pattern) {
+					is_statement = true
+					break
+				}
+			}
+			// NB: starting a line with 2 spaces escapes the println heuristic
+			if oline.starts_with('  ') {
+				is_statement = true
+			}
+			if !is_statement && !func_call && r.line != '' {
+				temp_line = 'println($r.line)'
+				temp_flag = true
+			}
+			mut temp_source_code := ''
+			if temp_line.starts_with('import ') {
+				mod := r.line.fields()[1]
+				if mod !in r.modules {
+					temp_source_code = '$temp_line\n' + r.current_source_code(false)
+				}
+			} else if temp_line.starts_with('#include ') {
+				temp_source_code = '$temp_line\n' + r.current_source_code(false)
+			} else {
+				for i, l in r.lines {
+					if (l.starts_with('for ') || l.starts_with('if ')) && l.contains('println') {
+						r.lines.delete(i)
+						break
+					}
+				}
+				temp_source_code = r.current_source_code(true) + '\n$temp_line\n'
+			}
+			os.write_file(temp_file, temp_source_code)
+			s := os.exec('"$vexe" -repl run "$temp_file"') or {
+				rerror(err)
+				return
+			}
+			if !func_call && s.exit_code == 0 && !temp_flag {
+				for r.temp_lines.len > 0 {
+					if !r.temp_lines[0].starts_with('print') {
+						r.lines << r.temp_lines[0]
+					}
+					r.temp_lines.delete(0)
+				}
+				if r.line.starts_with('import ') {
+					mod := r.line.fields()[1]
+					if mod !in r.modules {
+						r.modules << mod
+					}
+				} else if r.line.starts_with('#include ') {
+					r.includes << r.line
+				} else {
+					r.lines << r.line
+				}
+			} else {
+				for r.temp_lines.len > 0 {
+					r.temp_lines.delete(0)
+				}
+			}
+			print_output(s)
+		}
+	}
+}
+
+fn print_output(s os.Result) {
+	lines := s.output.trim_right('\n\r').split('\n')
+	for line in lines {
+		if line.contains('.vrepl_temp.v:') {
+			// Hide the temporary file name
+			sline := line.all_after('.vrepl_temp.v:')
+			idx := sline.index(' ') or {
+				println(sline)
+				return
+			}
+			println(sline[idx + 1..])
+		} else if line.contains('.vrepl.v:') {
+			// Ensure that .vrepl.v: is at the start, ignore the path
+			// This is needed to have stable .repl tests.
+			idx := line.index('.vrepl.v:') or {
+				return
+			}
+			println(line[idx..])
+		} else {
+			println(line)
+		}
+	}
+}
+
+fn main() {
+	// Support for the parameters replfolder and replprefix is needed
+	// so that the repl can be launched in parallel by several different
+	// threads by the REPL test runner.
+	args := cmdline.options_after(os.args, ['repl'])
+	replfolder := os.real_path(cmdline.option(args, '-replfolder', '.'))
+	replprefix := cmdline.option(args, '-replprefix', 'noprefix.')
+	os.chdir(replfolder)
+	if !os.exists(os.getenv('VEXE')) {
+		println('Usage:')
+		println('  VEXE=vexepath vrepl\n')
+		println('  ... where vexepath is the full path to the v executable file')
+		return
+	}
+	run_repl(replfolder, replprefix)
+}
+
+fn rerror(s string) {
+	println('V repl error: $s')
+	os.flush()
+}
+
+fn (mut r Repl) get_one_line(prompt string) ?string {
+	mut readline := readline.Readline{}
+	if is_stdin_a_pipe {
+		iline := os.get_raw_line()
+		if iline.len == 0 {
+			return none
+		}
+		return iline
+	}
+	rline := readline.read_line(prompt) or {
+		return none
+	}
+	return rline
+}

cmd/tools/vself.v

@@ -0,0 +1,51 @@
+module main
+
+import os
+import os.cmdline
+import v.pref
+
+fn main() {
+	vexe := pref.vexe_path()
+	vroot := os.dir(vexe)
+	os.chdir(vroot)
+	os.setenv('VCOLORS', 'always', true)
+	self_idx := os.args.index('self')
+	args := os.args[1..self_idx]
+	jargs := args.join(' ')
+	obinary := cmdline.option(args, '-o', '')
+	sargs := if obinary != '' { jargs } else { '$jargs -o v2 ' }
+	cmd := '$vexe $sargs cmd/v'
+	options := if args.len > 0 { '($sargs)' } else { '' }
+	println('V self compiling ${options}...')
+	compile(vroot, cmd)
+	if obinary != '' {
+		// When -o was given, there is no need to backup/rename the original.
+		// The user just wants an independent copy of v, and so we are done.
+		return
+	}
+	backup_old_version_and_rename_newer()
+}
+
+fn compile(vroot string, cmd string) {
+	result := os.exec(cmd) or {
+		panic(err)
+	}
+	if result.exit_code != 0 {
+		eprintln('cannot compile to `$vroot`: \n$result.output')
+		exit(1)
+	}
+	if result.output.len > 0 {
+		println(result.output.trim_space())
+	}
+}
+
+fn backup_old_version_and_rename_newer() {
+	v_file := if os.user_os() == 'windows' { 'v.exe' } else { 'v' }
+	v2_file := if os.user_os() == 'windows' { 'v2.exe' } else { 'v2' }
+	bak_file := if os.user_os() == 'windows' { 'v_old.exe' } else { 'v_old' }
+	if os.exists(bak_file) {
+		os.rm(bak_file)
+	}
+	os.mv(v_file, bak_file)
+	os.mv(v2_file, v_file)
+}

cmd/tools/vsetup-freetype.v

@@ -0,0 +1,23 @@
+module main
+
+import os
+import v.pref
+
+fn main() {
+	$if windows {
+		println('Setup freetype...')
+		vroot := os.dir(pref.vexe_path())
+		os.chdir(vroot)
+		if os.is_dir('./thirdparty/freetype') {
+			println('Thirdparty "freetype" is already installed.')
+		} else {
+			s := os.exec('git clone --depth=1 https://github.com/ubawurinna/freetype-windows-binaries ./thirdparty/freetype/') or {
+				panic(err)
+			}
+			println(s.output)
+			println('Thirdparty "freetype" installed successfully.')
+		}
+	} $else {
+		println('It is only for Windows to setup thirdparty "freetype".')
+	}
+}

cmd/tools/vsymlink.v

@@ -0,0 +1,181 @@
+import os
+import v.pref
+
+$if windows {
+	$if tinyc {
+		#flag -lAdvapi32
+		#flag -lUser32
+	}
+}
+fn main() {
+	vexe := os.real_path(pref.vexe_path())
+	$if windows {
+		setup_symlink_windows(vexe)
+	} $else {
+		setup_symlink(vexe)
+	}
+}
+
+fn setup_symlink(vexe string) {
+	link_dir := '/usr/local/bin'
+	if !os.exists(link_dir) {
+		os.mkdir_all(link_dir)
+	}
+	mut link_path := link_dir + '/v'
+	mut ret := os.exec('ln -sf $vexe $link_path') or {
+		panic(err)
+	}
+	if ret.exit_code == 0 {
+		println('Symlink "$link_path" has been created')
+	} else if os.system("uname -o | grep -q \'[A/a]ndroid\'") == 0 {
+		println('Failed to create symlink "$link_path". Trying again with Termux path for Android.')
+		link_path = '/data/data/com.termux/files/usr/bin/v'
+		ret = os.exec('ln -sf $vexe $link_path') or {
+			panic(err)
+		}
+		if ret.exit_code == 0 {
+			println('Symlink "$link_path" has been created')
+		} else {
+			eprintln('Failed to create symlink "$link_path". Try again with sudo.')
+		}
+	} else {
+		eprintln('Failed to create symlink "$link_path". Try again with sudo.')
+	}
+}
+
+fn setup_symlink_windows(vexe string) {
+	$if windows {
+		// Create a symlink in a new local folder (.\.bin\.v.exe)
+		// Puts `v` in %PATH% without polluting it with anything else (like make.bat).
+		// This will make `v` available on cmd.exe, PowerShell, and MinGW(MSYS)/WSL/Cygwin
+		vdir := os.real_path(os.dir(vexe))
+		vsymlinkdir := os.join_path(vdir, '.bin')
+		mut vsymlink := os.join_path(vsymlinkdir, 'v.exe')
+		if !os.exists(vsymlinkdir) {
+			os.mkdir_all(vsymlinkdir) // will panic if fails
+		} else {
+			os.rm(vsymlink)
+		}
+		// First, try to create a native symlink at .\.bin\v.exe
+		os.symlink(vsymlink, vexe) or {
+			// typically only fails if you're on a network drive (VirtualBox)
+			// do batch file creation instead
+			eprintln('Could not create a native symlink: $err')
+			eprintln('Creating a batch file instead...')
+			vsymlink = os.join_path(vsymlinkdir, 'v.bat')
+			if os.exists(vsymlink) {
+				os.rm(vsymlink)
+			}
+			os.write_file(vsymlink, '@echo off\n$vexe %*')
+			eprintln('$vsymlink file written.')
+		}
+		if !os.exists(vsymlink) {
+			warn_and_exit('Could not create $vsymlink')
+		}
+		println('Symlink $vsymlink to $vexe created.')
+		println('Checking system %PATH%...')
+		reg_sys_env_handle := get_reg_sys_env_handle() or {
+			warn_and_exit(err)
+			return
+		}
+		// TODO: Fix defers inside ifs
+		// defer {
+		// C.RegCloseKey(reg_sys_env_handle)
+		// }
+		// if the above succeeded, and we cannot get the value, it may simply be empty
+		sys_env_path := get_reg_value(reg_sys_env_handle, 'Path') or {
+			''
+		}
+		current_sys_paths := sys_env_path.split(os.path_delimiter).map(it.trim('/$os.path_separator'))
+		mut new_paths := [vsymlinkdir]
+		for p in current_sys_paths {
+			if p == '' {
+				continue
+			}
+			if p !in new_paths {
+				new_paths << p
+			}
+		}
+		new_sys_env_path := new_paths.join(';')
+		if new_sys_env_path == sys_env_path {
+			println('System %PATH% was already configured.')
+		} else {
+			println('System %PATH% was not configured.')
+			println('Adding symlink directory to system %PATH%...')
+			set_reg_value(reg_sys_env_handle, 'Path', new_sys_env_path) or {
+				warn_and_exit(err)
+				C.RegCloseKey(reg_sys_env_handle)
+				return
+			}
+			println('done.')
+		}
+		println('Notifying running processes to update their Environment...')
+		send_setting_change_msg('Environment') or {
+			eprintln(err)
+			warn_and_exit('You might need to run this again to have the `v` command in your %PATH%')
+			C.RegCloseKey(reg_sys_env_handle)
+			return
+		}
+		C.RegCloseKey(reg_sys_env_handle)
+		println('')
+		println('Note: restart your shell/IDE to load the new %PATH%.')
+		println('After restarting your shell/IDE, give `v version` a try in another dir!')
+	}
+}
+
+fn warn_and_exit(err string) {
+	eprintln(err)
+	exit(1)
+}
+
+// get the system environment registry handle
+fn get_reg_sys_env_handle() ?voidptr {
+	$if windows { // wrap for cross-compile compat
+		// open the registry key
+		reg_key_path := 'Environment'
+		reg_env_key := voidptr(0) // or HKEY (HANDLE)
+		if C.RegOpenKeyEx(os.hkey_current_user, reg_key_path.to_wide(), 0, 1 | 2, &reg_env_key) != 0 {
+			return error('Could not open "$reg_key_path" in the registry')
+		}
+		return reg_env_key
+	}
+	return error('not on windows')
+}
+
+// get a value from a given $key
+fn get_reg_value(reg_env_key voidptr, key string) ?string {
+	$if windows {
+		// query the value (shortcut the sizing step)
+		reg_value_size := 4095 // this is the max length (not for the registry, but for the system %PATH%)
+		mut reg_value := &u16(malloc(reg_value_size))
+		if C.RegQueryValueEx(reg_env_key, key.to_wide(), 0, 0, reg_value, &reg_value_size) != 0 {
+			return error('Unable to get registry value for "$key", try rerunning as an Administrator')
+		}
+		return string_from_wide(reg_value)
+	}
+	return error('not on windows')
+}
+
+// sets the value for the given $key to the given  $value
+fn set_reg_value(reg_key voidptr, key string, value string) ?bool {
+	$if windows {
+		if C.RegSetValueEx(reg_key, key.to_wide(), 0, 1, value.to_wide(), 4095) != 0 {
+			return error('Unable to set registry value for "$key", are you running as an Administrator?')
+		}
+		return true
+	}
+	return error('not on windows')
+}
+
+// Broadcasts a message to all listening windows (explorer.exe in particular)
+// letting them know that the system environment has changed and should be reloaded
+fn send_setting_change_msg(message_data string) ?bool {
+	$if windows {
+		if C.SendMessageTimeout(os.hwnd_broadcast, os.wm_settingchange, 0, message_data.to_wide(), os.smto_abortifhung, 5000, 0) ==
+			0 {
+			return error('Could not broadcast WM_SETTINGCHANGE')
+		}
+		return true
+	}
+	return error('not on windows')
+}

cmd/tools/vtest-cleancode.v

@@ -0,0 +1,96 @@
+module main
+
+import os
+import testing
+import v.util
+
+const (
+	vet_known_failing_exceptions    = [
+		'nonexistent',
+	]
+	vet_folders                     = [
+		'vlib/sqlite',
+		'vlib/v',
+		'cmd/v',
+		'cmd/tools',
+	]
+	verify_known_failing_exceptions = [
+		'nonexistant',
+	]
+	vfmt_verify_list                = [
+		'cmd/v/v.v',
+		'vlib/builtin/array.v',
+		'vlib/os/file.v',
+		'vlib/math/bits/bits.v',
+		'vlib/time/time.v',
+		'vlib/term/colors.v',
+		'vlib/term/term.v',
+		'vlib/v/ast/',
+		'vlib/v/builder/',
+		'vlib/v/cflag/',
+		'vlib/v/checker/',
+		'vlib/v/depgraph/',
+		'vlib/v/doc/',
+		'vlib/v/errors/',
+		'vlib/v/eval/',
+		'vlib/v/fmt/',
+		'vlib/v/gen/auto_str_methods.v',
+		'vlib/v/gen/cgen.v',
+		'vlib/v/gen/cgen_test.v',
+		'vlib/v/gen/cmain.v',
+		'vlib/v/gen/comptime.v',
+		'vlib/v/gen/fn.v',
+		'vlib/v/gen/json.v',
+		'vlib/v/gen/live.v',
+		'vlib/v/gen/profile.v',
+		'vlib/v/gen/sql.v',
+		'vlib/v/gen/str.v',
+		'vlib/v/gen/x64/elf.v',
+		'vlib/v/gen/x64/elf_obj.v',
+		'vlib/v/gen/x64/gen.v',
+		'vlib/v/parser/',
+		'vlib/v/pref/',
+		'vlib/v/scanner/',
+		'vlib/v/table/',
+		'vlib/v/util/',
+		'vlib/v/vet/',
+		'vlib/v/vmod/',
+		'vlib/gg/gg.v',
+	]
+)
+
+fn main() {
+	args := os.args
+	args_string := args[1..].join(' ')
+	pass_args := args_string.all_before('test-cleancode')
+	v_test_vetting(pass_args)
+}
+
+fn tsession(vargs string, tool_source string, tool_cmd string, tool_args string, flist []string, slist []string) testing.TestSession {
+	testing.setup_new_vtmp_folder()
+	util.prepare_tool_when_needed(tool_source)
+	testing.eheader('Run `$tool_cmd` over most .v files')
+	mut test_session := testing.new_test_session('$vargs $tool_args')
+	test_session.files << flist
+	test_session.skip_files << slist
+	test_session.test()
+	eprintln(test_session.benchmark.total_message('running `$tool_cmd` over most .v files'))
+	return test_session
+}
+
+fn v_test_vetting(vargs string) {
+	vet_session := tsession(vargs, 'vvet.v', 'v vet', 'vet', vet_folders, vet_known_failing_exceptions)
+	verify_session := tsession(vargs, 'vfmt.v', 'v fmt -verify', 'fmt -verify', vfmt_verify_list,
+		verify_known_failing_exceptions)
+	//
+	if vet_session.benchmark.nfail > 0 || verify_session.benchmark.nfail > 0 {
+		eprintln('\n')
+		if vet_session.benchmark.nfail > 0 {
+			eprintln('WARNING: `v vet` failed $vet_session.benchmark.nfail times.')
+		}
+		if verify_session.benchmark.nfail > 0 {
+			eprintln('WARNING: `v fmt -verify` failed $verify_session.benchmark.nfail times.')
+		}
+		exit(1)
+	}
+}

cmd/tools/vtest-compiler.v

@@ -0,0 +1,71 @@
+module main
+
+import os
+import testing
+import benchmark
+import v.pref
+
+fn main() {
+	args := os.args
+	args_string := args[1..].join(' ')
+	v_test_compiler(args_string.all_before('test-compiler'))
+}
+
+fn v_test_compiler(vargs string) {
+	vexe := pref.vexe_path()
+	parent_dir := os.dir(vexe)
+	testing.vlib_should_be_present(parent_dir)
+	// Changing the current directory is needed for some of the compiler tests,
+	// vlib/v/tests/local_test.v and vlib/v/tests/repl/repl_test.v
+	os.chdir(parent_dir)
+	/*
+	if !os.exists(parent_dir + '/v.v') {
+		eprintln('v.v is missing, it must be next to the V executable')
+		exit(1)
+	}
+	*/
+	// Make sure v.c can be compiled without warnings
+	$if macos {
+		if os.exists('/cmd/v') {
+			os.system('$vexe -o v.c cmd/v')
+			if os.system('cc -Werror v.c') != 0 {
+				eprintln('cc failed to build v.c without warnings')
+				exit(1)
+			}
+			eprintln('v.c can be compiled without warnings. This is good :)')
+		}
+	}
+	building_tools_failed := testing.v_build_failing(vargs, 'cmd/tools')
+	eprintln('')
+	testing.eheader('Testing all _test.v files...')
+	mut compiler_test_session := testing.new_test_session(vargs)
+	compiler_test_session.files << os.walk_ext(parent_dir, '_test.v')
+	compiler_test_session.test()
+	eprintln(compiler_test_session.benchmark.total_message('running V tests'))
+	eprintln('')
+	building_examples_failed := testing.v_build_failing(vargs, 'examples')
+	eprintln('')
+	building_live_failed := testing.v_build_failing(vargs + '-live', os.join_path('examples',
+		'hot_reload'))
+	eprintln('')
+	//
+	testing.setup_new_vtmp_folder()
+	v_module_install_cmd := '$vexe install nedpals.args'
+	eprintln('')
+	testing.eheader('Installing a v module with: $v_module_install_cmd')
+	mut vmark := benchmark.new_benchmark()
+	ret := os.system(v_module_install_cmd)
+	if ret != 0 {
+		eprintln('failed to run v install')
+	}
+	desired_path := os.join_path(pref.default_module_path, 'nedpals', 'args')
+	if !(os.exists(desired_path) && os.is_dir(desired_path)) {
+		eprintln('v failed to install a test module')
+	}
+	vmark.stop()
+	eprintln('Installing a v module took: ' + vmark.total_duration().str() + 'ms')
+	//
+	if building_tools_failed || compiler_test_session.failed || building_examples_failed || building_live_failed {
+		exit(1)
+	}
+}

cmd/tools/vtest-fixed.v

@@ -0,0 +1,85 @@
+module main
+
+import os
+import testing
+import v.pref
+
+const (
+	skip_test_files     = [
+		'vlib/net/http/http_httpbin_test.v',
+	]
+	skip_on_musl        = []string{}
+	skip_on_ubuntu_musl = [
+		// 'vlib/v/gen/js/jsgen_test.v',
+		'vlib/net/http/cookie_test.v',
+		'vlib/net/http/http_test.v',
+		'vlib/net/http/status_test.v',
+		'vlib/net/websocket/ws_test.v',
+		'vlib/sqlite/sqlite_test.v',
+		'vlib/orm/orm_test.v',
+		'vlib/clipboard/clipboard_test.v',
+		'vlib/vweb/tests/vweb_test.v',
+		'vlib/x/websocket/websocket_test.v',
+	]
+	skip_on_linux       = []string{}
+	skip_on_non_linux   = [
+		'vlib/net/websocket/ws_test.v',
+	]
+	skip_on_windows     = [
+		'vlib/orm/orm_test.v',
+		'vlib/net/websocket/ws_test.v',
+		'vlib/x/websocket/websocket_test.v',
+		'vlib/vweb/tests/vweb_test.v',
+	]
+	skip_on_non_windows = []string{}
+	skip_on_macos       = []string{}
+	skip_on_non_macos   = []string{}
+)
+
+// NB: musl misses openssl, thus the http tests can not be done there
+// NB: http_httpbin_test.v: fails with 'cgen error: json: map_string_string is not struct'
+fn main() {
+	vexe := pref.vexe_path()
+	vroot := os.dir(vexe)
+	os.chdir(vroot)
+	args := os.args
+	args_string := args[1..].join(' ')
+	cmd_prefix := args_string.all_before('test-fixed')
+	title := 'testing all fixed tests'
+	all_test_files := os.walk_ext(os.join_path(vroot, 'vlib'), '_test.v')
+	testing.eheader(title)
+	mut tsession := testing.new_test_session(cmd_prefix)
+	tsession.files << all_test_files
+	tsession.skip_files << skip_test_files
+	//
+	if os.getenv('V_CI_MUSL').len > 0 {
+		tsession.skip_files << skip_on_musl
+	}
+	if os.getenv('V_CI_UBUNTU_MUSL').len > 0 {
+		tsession.skip_files << skip_on_ubuntu_musl
+	}
+	$if !linux {
+		tsession.skip_files << skip_on_non_linux
+	}
+	$if linux {
+		tsession.skip_files << skip_on_linux
+	}
+	$if windows {
+		tsession.skip_files << skip_on_windows
+	}
+	$if !windows {
+		tsession.skip_files << skip_on_non_windows
+	}
+	$if macos {
+		tsession.skip_files << skip_on_macos
+	}
+	$if !macos {
+		tsession.skip_files << skip_on_non_macos
+	}
+	tsession.test()
+	eprintln(tsession.benchmark.total_message(title))
+	if tsession.benchmark.nfail > 0 {
+		eprintln('\nWARNING: failed $tsession.benchmark.nfail times.\n')
+		exit(1)
+	}
+}

cmd/tools/vtest-fmt.v

@@ -0,0 +1,59 @@
+module main
+
+import os
+import testing
+import v.util
+
+const (
+	known_failing_exceptions = [
+		'vlib/crypto/aes/const.v',
+		/* multiple narrow columns of []string turned to 1 long single column, otherwise works */
+		'vlib/vweb/vweb.v',
+		/* $for method in T.methods { => $for method in T(methods) { , `return // xx` => parse expr error */
+		'vlib/v/gen/js/tests/life.v',
+		/* error: unexpected `,`, expecting ), on JS.setInterval(fn () { show(game) game = step(game) }, 500) */
+		'vlib/builtin/js/builtin.v',
+		/* JS.console.error(s) => JS.error(s), JS.process.exit(c) => JS.exit(c) */
+		'vlib/builtin/js/jsfns_node.js.v',
+		'vlib/builtin/js/jsfns.js.v',
+		'vlib/builtin/js/jsfns_browser.js.v',
+		'vlib/builtin/bare/linuxsys_bare.v',
+		/* error: expr(): bad token `asm`, on `asm {}` */
+		'vlib/picoev/picoev.v',
+		/* the fn args are removed, then `cb fn (picohttpparser.Request, mut picohttpparser.Response)` can not be reparsed */
+		'vlib/os/os.v' /* os.v - `a := [ c'/bin/sh', c'-c', byteptr(cmd.str), 0 ]` */,
+	]
+)
+
+fn main() {
+	args := os.args
+	args_string := args[1..].join(' ')
+	v_test_formatting(args_string.all_before('test-fmt'))
+}
+
+fn v_test_formatting(vargs string) {
+	all_v_files := v_files()
+	util.prepare_tool_when_needed('vfmt.v')
+	testing.eheader('Run "v fmt" over all .v files')
+	mut vfmt_test_session := testing.new_test_session('$vargs fmt -worker')
+	vfmt_test_session.files << all_v_files
+	vfmt_test_session.skip_files << known_failing_exceptions
+	vfmt_test_session.test()
+	eprintln(vfmt_test_session.benchmark.total_message('running vfmt over V files'))
+	if vfmt_test_session.benchmark.nfail > 0 {
+		eprintln('\nWARNING: v fmt failed $vfmt_test_session.benchmark.nfail times.\n')
+		exit(1)
+	}
+}
+
+fn v_files() []string {
+	mut files_that_can_be_formatted := []string{}
+	all_test_files := os.walk_ext('.', '.v')
+	for tfile in all_test_files {
+		if tfile.starts_with('./vlib/v/cgen/tests') {
+			continue
+		}
+		files_that_can_be_formatted << tfile
+	}
+	return files_that_can_be_formatted
+}

cmd/tools/vtest.v

@@ -0,0 +1,48 @@
+module main
+
+import os
+import os.cmdline
+import testing
+
+fn main() {
+	args := os.args
+	if args.last() == 'test' {
+		println('Usage:')
+		println('   A)')
+		println('      v test folder/ : run all v tests in the given folder.')
+		println('      v -stats test folder/ : the same, but print more stats.')
+		println('   B)')
+		println('      v test file_test.v : run test functions in a given test file.')
+		println('      v -stats test file_test.v : as above, but with more stats.')
+		println('   NB: you can also give many and mixed folder/ file_test.v arguments after test.')
+		println('')
+		return
+	}
+	args_to_executable := args[1..]
+	args_before := cmdline.options_before(args_to_executable, ['test'])
+	args_after := cmdline.options_after(args_to_executable, ['test'])
+	if args_after.join(' ') == 'v' {
+		eprintln('`v test v` has been deprecated.')
+		eprintln('Use `v test-compiler` instead.')
+		exit(1)
+	}
+	mut ts := testing.new_test_session(args_before.join(' '))
+	for targ in args_after {
+		if os.exists(targ) && targ.ends_with('_test.v') {
+			ts.files << targ
+			continue
+		}
+		if os.is_dir(targ) {
+			// Fetch all tests from the directory
+			ts.files << os.walk_ext(targ.trim_right(os.path_separator), '_test.v')
+			continue
+		}
+		println('Unrecognized test file $targ .')
+	}
+	testing.header('Testing...')
+	ts.test()
+	println(ts.benchmark.total_message('running V _test.v files'))
+	if ts.failed {
+		exit(1)
+	}
+}

cmd/tools/vtracev.v

@@ -0,0 +1,17 @@
+module main
+
+import os
+import v.pref
+
+fn main() {
+	vexe := pref.vexe_path()
+	vroot := os.dir(vexe)
+	os.chdir(vroot)
+	os.setenv('VCOLORS', 'always', true)
+	self_idx := os.args.index('tracev')
+	args := os.args[1..self_idx]
+	args_str := args.join(' ')
+	options := if args.len > 0 { '($args_str)' } else { '' }
+	println('Compiling a `tracev` executable ${options}...')
+	os.system('$vexe -cg -d trace_parser -d trace_checker -d trace_gen -o tracev $args_str cmd/v')
+}

cmd/tools/vup.v

@@ -0,0 +1,129 @@
+module main
+
+import os
+import v.pref
+import v.util
+
+struct App {
+	is_verbose bool
+	vexe       string
+	vroot      string
+}
+
+fn new_app() App {
+	vexe := os.real_path(pref.vexe_path())
+	return App{
+		is_verbose: '-v' in os.args
+		vexe: vexe
+		vroot: os.dir(vexe)
+	}
+}
+
+fn main() {
+	app := new_app()
+	os.chdir(app.vroot)
+	println('Updating V...')
+	app.update_from_master()
+	v_hash := util.githash(false)
+	current_hash := util.githash(true)
+	// println(v_hash)
+	// println(current_hash)
+	if v_hash == current_hash {
+		app.show_current_v_version()
+		return
+	}
+	$if windows {
+		app.backup('cmd/tools/vup.exe')
+	}
+	app.recompile_v()
+	os.exec('"$app.vexe" cmd/tools/vup.v') or {
+		panic(err)
+	}
+	app.show_current_v_version()
+}
+
+fn (app App) update_from_master() {
+	if app.is_verbose {
+		println('> updating from master ...')
+	}
+	if !os.exists('.git') {
+		// initialize as if it had been cloned
+		app.git_command('init')
+		app.git_command('remote add origin https://github.com/vlang/v')
+		app.git_command('fetch')
+		app.git_command('reset --hard origin/master')
+		app.git_command('clean --quiet -xdf --exclude v.exe --exclude cmd/tools/vup.exe')
+	} else {
+		// pull latest
+		app.git_command('pull https://github.com/vlang/v master')
+	}
+}
+
+fn (app App) recompile_v() {
+	// NB: app.vexe is more reliable than just v (which may be a symlink)
+	vself := '"$app.vexe" self'
+	if app.is_verbose {
+		println('> recompiling v itself with `$vself` ...')
+	}
+	if self_result := os.exec(vself) {
+		println(self_result.output.trim_space())
+		if self_result.exit_code == 0 {
+			return
+		}
+	}
+	app.make(vself)
+}
+
+fn (app App) make(vself string) {
+	mut make := 'make'
+	$if windows {
+		make = 'make.bat'
+	}
+	println('`$vself` failed, running `$make`...')
+	make_result := os.exec(make) or {
+		panic(err)
+	}
+	println(make_result.output)
+}
+
+fn (app App) show_current_v_version() {
+	if vout := os.exec('"$app.vexe" version') {
+		mut vversion := vout.output.trim_space()
+		if vout.exit_code == 0 {
+			latest_v_commit := vversion.split(' ').last().all_after('.')
+			if latest_v_commit_time := os.exec('git show -s --format=%ci $latest_v_commit') {
+				if latest_v_commit_time.exit_code == 0 {
+					vversion += ', timestamp: ' + latest_v_commit_time.output.trim_space()
+				}
+			}
+		}
+		println('Current V version:')
+		println(vversion)
+	}
+}
+
+fn (app App) backup(file string) {
+	backup_file := '${file}_old.exe'
+	if os.exists(backup_file) {
+		os.rm(backup_file)
+	}
+	os.mv(file, backup_file)
+}
+
+fn (app App) git_command(command string) {
+	git_result := os.exec('git $command') or {
+		panic(err)
+	}
+	if git_result.exit_code != 0 {
+		if git_result.output.contains('Permission denied') {
+			eprintln('No access to `$app.vroot`: Permission denied')
+		} else {
+			eprintln(git_result.output)
+		}
+		exit(1)
+	} else {
+		if app.is_verbose {
+			println(git_result.output)
+		}
+	}
+}

cmd/tools/vvet.v

@@ -0,0 +1,75 @@
+// Copyright (c) 2019-2020 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 v.vet
+import v.pref
+import v.parser
+import v.util
+import v.table
+import os
+import os.cmdline
+
+struct VetOptions {
+	is_verbose bool
+mut:
+	errors     []string
+}
+
+fn (vet_options &VetOptions) vprintln(s string) {
+	if !vet_options.is_verbose {
+		return
+	}
+	println(s)
+}
+
+fn main() {
+	args := util.join_env_vflags_and_os_args()
+	paths := cmdline.only_non_options(cmdline.options_after(args, ['vet']))
+	mut vet_options := VetOptions{
+		is_verbose: '-verbose' in args || '-v' in args
+	}
+	for path in paths {
+		if !os.exists(path) {
+			eprintln('File/folder $path does not exist')
+			continue
+		}
+		if path.ends_with('_test.v') || (path.contains('/tests/') && !path.contains('vlib/v/vet/')) {
+			eprintln('skipping $path')
+			continue
+		}
+		if path.ends_with('.v') || path.ends_with('.vv') {
+			vet_options.vet_file(path)
+		} else if os.is_dir(path) {
+			vet_options.vprintln("vetting folder '$path'...")
+			vfiles := os.walk_ext(path, '.v')
+			vvfiles := os.walk_ext(path, '.vv')
+			mut files := []string{}
+			files << vfiles
+			files << vvfiles
+			for file in files {
+				if file.ends_with('_test.v') || file.contains('/tests/') { // TODO copy pasta
+					continue
+				}
+				vet_options.vet_file(file)
+			}
+		}
+	}
+	if vet_options.errors.len > 0 {
+		for err in vet_options.errors {
+			eprintln(err)
+		}
+		eprintln('NB: You can run `v fmt -w file.v` to fix these automatically')
+		exit(1)
+	}
+}
+
+fn (mut vet_options VetOptions) vet_file(path string) {
+	mut prefs := pref.new_preferences()
+	prefs.is_vet = true
+	table := table.new_table()
+	vet_options.vprintln("vetting file '$path'...")
+	file_ast, errors := parser.parse_vet_file(path, table, prefs)
+	vet_options.errors << errors
+	vet.vet(file_ast, table, true)
+}

cmd/v/help/bin2v.txt

@@ -0,0 +1,14 @@
+Usage:
+v bin2v [options] FILE [FILE]...
+
+Converts a list of arbitrary files into a single v module file.
+
+You can use this tool to embed binary files, like pictures or fonts inside
+the executable of a v program, such that it would not need access to external
+resources during runtime, and it would be as self-contained as possible.
+
+Options:
+  -h, --help                Show this help screen.
+  -m, --module <string>     Name of the generated module.
+  -p, --prefix <string>     A prefix put before each resource name.
+  -w, --write <string>      Write directly to a file with the given name.

cmd/v/help/build-c.txt

@@ -0,0 +1,69 @@
+Usage: v [build flags] ['build'] <file.v|directory>
+
+This command compiles the given target, along with their dependencies, into an executable.
+
+This help topic explores C-backend specific build flags.
+For help regarding building an executable, see `v help build`.
+
+These build flags are enabled on `build` and `run` as long as the backend is set to `c`:
+
+   -cc <compiler>
+      Change the C compiler V invokes to the specified compiler.
+      The C compiler is required to support C99.
+      Officially supported/tested C compilers include: `clang`, `gcc`, `tcc`, `mingw-w64` and `msvc`.
+
+   -cflags <flag>
+      Pass the provided flag as is to the C compiler.
+      Can be specified multiple times to provide multiple flags.
+      Use quotes to wrap the flag argument if it contains spaces.
+
+   -printfn <fn_name>
+      Prints the content of the generated C function named fn_name. You can repeat that many times.
+      This is useful when you just want to quickly tweak the generated C code,
+      without opening the generated .c file in an text editor.
+
+   -cg
+      Enable generating more debug information in the compiled executable.
+      This makes program backtraces more useful.
+      Using debuggers like gdb/lldb with such executables is easier too.
+
+   -compress
+      Strip the compiled executable to compress it.
+
+   -freestanding
+      Build the executable without dependency on libc.
+      Supported only on `linux` targets currently.
+
+   -live
+      Build the executable with live capabilities (`[live]`).
+
+   -os <os>, -target-os <os>
+      Change the target OS that V tries to compile for.
+      By default, the target OS is the host system.
+      When OS is `cross`, V will attempt to output cross-platform C code.
+      List of OS supported by V: `linux`, `windows`, `ios`, `mac`, `freebsd`, `openbsd`,
+                                 `netbsd`, `dragonfly`, `solaris`, `android` and `haiku`.
+
+   -m32, -m64
+      Specify whether 32-bit or 64-bit machine code is generated.
+
+   -sanitize
+      Pass flags related to sanitization to the C compiler.
+
+   -shared
+      Tell V to compile a shared object instead of an executable.
+      The resulting file extension will be `.dll` on Windows and `.so` on Unix systems
+
+   -no-prelude
+      Prevents V from generating a prelude in generated .c files, useful for freestanding targets
+      where eg. you replace C standard library with your own, or some definitions/headers break something.
+
+   -custom-prelude <path>
+      Useful for similar use-case as above option, except it replaces V-generated prelude with
+      your custom one loaded from specified <path>.
+
+   -showcc
+      Prints the C command that is used to build the program.
+
+   -keepc
+      Do not remove the temporary .tmp.c and .tmp.c.rsp files. Also do not use a random prefix for them, so they would be fixed and predictable.

cmd/v/help/build.txt

@@ -0,0 +1,131 @@
+Usage: v [build flags] ['build'] <file.v|directory>
+
+This command compiles the given target, along with their dependencies, into an executable.
+
+When compiling packages, build ignores files that end in '_test.v'.
+
+When compiling a single main package, build writes the resulting executable to an output file
+named after the build target. ('v abc.v' and 'v abc/' both write either 'abc' or 'abc.exe')
+The '.exe' suffix is added when writing a Windows executable.
+By default, the executable is stored in the same directory as the compiled source code.
+
+The -o flag forces build to write the resulting executable or object to the d output file or directory,
+instead of the default behavior described in the last two paragraphs.
+
+You can put common options inside an environment variable named VFLAGS, so that
+you don't have to repeat them.
+
+You can set it like this: `export VFLAGS="-cc clang -debug"` on *nix,
+`set VFLAGS=-cc msvc` on Windows.
+
+V respects the TMPDIR environment variable, and will put .tmp.c files in TMPDIR/v/ .
+If you have not set it, a suitable platform specific folder (like /tmp) will be used.
+
+The build flags are shared by the build and run commands:
+
+   -b <backend>, -backend <backend>
+      Specify the backend to use while building the executable.
+      Current list of supported backends:
+      * `c` (default)       - V outputs C source code which is passed to a C compiler to be compiled.
+      * `js`                - V outputs JS source code which can be passed to NodeJS to be ran.
+      * `x64`               - V outputs Linux 64-bit executable directly (highly experimental!).
+
+   -d <flag>[=<value>], -define <flag>[=<value>]
+      Define the provided flag.
+      If value is not provided, it is assumed to be set to `true`.
+      `value` should be `1` or `0` to indicate `true` and `false` respectively otherwise.
+
+   -e <experiment>, -experiments <experiment>
+      Enable the specified experiment.
+      Currently, the only experiment available is: `prealloc`
+
+   -cg
+      Compile the executable in debug mode, allowing code to be debugged more easily.
+
+   -o <output>, -output <output>
+      Force V to output the executable in a specific location
+      (relative to the current working directory if not absolute).
+
+   -obf, -obfuscate
+      Turn on obfuscation for the code being built. Currently only renames symbols.
+
+   -path
+      Specify the order of path V looks up in while searching for imported dependencies,
+      separated by pipes (`|`). In addition to absolute paths, you can
+      also use these special strings too:
+           @vmodules - replaced with the location of the global ~/.vmodules/ folder
+                       (modules installed with `v install` are there). You can change 
+                       its location by setting the environment variable VMODULES.
+           @vlib - replaced with the location of the v's vlib folder.
+      Using these, you can arrange for very flexible search orders for you project, for example:
+           -path "/v/my_project_private_modules|@vlib|@vmodules"
+      By default, -path is just "@vlib|@vmodules" .
+
+   -prod
+      Compile the executable in production mode where most optimizations are enabled.
+
+   -prof, -profile <file.txt>
+      Compile the executable with all functions profiled.
+      The profile results will be stored in `file.txt`.
+      The format is 4 fields, separated by a space, for each v function:
+         a) how many times it was called
+         b) how much *nanoseconds in total* it took
+         c) an average for each function (i.e. (b) / (a) )
+         d) the function name
+      NB: if you want to output the profile info to stdout, use `-profile -`.
+
+   -profile-no-inline
+      Skip [inline] functions when profiling.
+
+   -stats
+      Enable more detailed statistics reporting, while compiling test files.
+      You can use that with `v test` too, for example:
+        v -stats test vlib/
+      ... will run test_ functions inside all _test.v files inside vlib/ ,
+      and will report detailed statistics about how much time each test_ function took, how many
+      assertions were made, how many tests passed/failed and so on.
+
+   -translated
+      Enable features that are discouraged in regular V code but required for translated V code.
+
+   -v
+      Enable verbosity in the V compiler while compiling
+
+   -print_v_files
+      Just print the list of all parsed .v files, then stop processing further.
+      This is useful for running external processing tools:
+        ./v -print_v_files cmd/v | etags -L -
+      ... will generate a TAGS file, that emacs can then use to jump
+      to the definition of functions used by v itself. For vim:
+        ./v -print_v_files cmd/v | ctags -L -
+      ... will generate a simillar tags file, that vi compatible editors can use.
+      NB: an useful, although not entirely accurate regexp based Universal Ctags options file
+      for V is located in `.ctags.d/v.ctags` . If you use https://ctags.io/ , it will be used
+      up automatically, or you can specify it explicitly with --options=.ctags.d/v.ctags .
+
+   -color, -nocolor
+      Force the use of ANSI colors for the error/warning messages, or disable them completely.
+      By default V tries to show its errors/warnings in ANSI color. The heuristic that it uses
+      to detect whether or not to use ANSI colors may not work in all cases.
+      These options allow you to override the default detection.
+
+   -check-syntax
+      Only scan and parse the files, but then stop. Useful for very quick syntax checks.
+
+   -show-timings
+      Print a summary about how long each compiler stage took, for example:
+         PARSE: 152ms
+         CHECK: 62ms
+         C GEN: 103ms
+         C tcc: 95ms
+
+   -w
+      Hide all warnings.
+
+   -W
+      Treat all warnings as errors, even in development builds.
+
+For C-specific build flags, use `v help build-c`.
+
+See also:
+   `v help run` for documentation regarding `v run`.

cmd/v/help/default.txt

@@ -0,0 +1,48 @@
+V is a tool for managing V source code.
+
+Usage:
+   v [options] [command] [arguments]
+
+Examples:
+   v hello.v                 Compile the file `hello.v` and output it as `hello` or `hello.exe`.
+   v run hello.v             Same as above but also run the produced executable immediately after compilation.
+   v -cg run hello.v         Same as above, but make debugging easier (in case your program crashes).
+   v -o h.c hello.v          Translate `hello.v` to `h.c`. Do not compile further.
+
+V supports the following commands:
+* New project scaffolding:
+   new               Setup the file structure for a V project (in a sub folder).
+   init              Setup the file structure for an already existing V project.
+* Ordinary development:
+   run               Compile and run a V program.
+   test              Run all test files in the provided directory.
+   fmt               Format the V code provided.
+   vet               Report suspicious code constructs.
+   doc               Generate the documentation for a V module.
+   vlib-docs         Generate and open the documentation of all the vlib modules.
+   repl              Run the REPL.
+* Installation/self updating:
+   symlink           Create a symbolic link for V.
+   up                Run the V self-updater.
+   self [-prod]      Run the V self-compiler, use -prod to optimize compilation.
+   version           Print the version text and exits.
+* Module/package management:
+   install           Install a module from VPM.
+   remove            Remove a module that was installed from VPM.
+   search            Search for a module from VPM.
+   update            Update an installed module from VPM.
+   upgrade           Upgrade all the outdated modules.
+   list              List all installed modules.
+   outdated          Show installed modules that need updates.
+* Others:
+   build             Build V code in the provided path (the default, so you can skip the word `build`).
+   translate         Translate C code to V (coming soon in 0.3).
+   tracev            Produce a tracing version of the v compiler.
+                     Use `tracev yourfile.v` when the compiler panics.
+                     NB: `tracev` is much slower and more verbose than ordinary `v`
+
+Use "v help <command>" for more information about a command, example: `v help build`, `v help build-c`
+Use "v help other" to see less frequently used commands.
+
+Note: Help is required to write more help topics.
+Only build, doc, fmt, run, test, search, install, remove, update, bin2v are properly documented currently.

cmd/v/help/doc.txt

@@ -0,0 +1,35 @@
+Usage:
+  v doc [flags] [module_name / folder / V file] [symbol name]
+
+Examples:
+  v doc os
+  v doc os File
+  v doc -o math.html math
+  v doc -m -f html vlib/
+
+Generates the documentation of a given directory, module, or V source file
+and prints or saves them to its desired format. It can generate HTML, JSON,
+or Markdown format.
+
+Options:
+  -all            Includes private and public functions/methods/structs/consts/enums.
+  -f              Specifies the output format to be used.
+  -h, -help       Prints this help text.
+  -m              Generate docs for modules listed in that folder.
+  -o              Specifies the output file/folder path where to store the generated docs.
+                  Set it to "stdout" to print the output instead of saving the contents
+                  to a file.
+  -readme         Include README.md to docs if present.
+  -v              Enables verbose logging. For debugging purposes.
+  -filename       Specifies the specific file to document.
+  -pos            Specifies the position. Used with `-filename`.
+  -no-timestamp   Omit timestamp in the output file.
+
+For HTML mode:
+  -inline-assets  Embeds the contents of the CSS and JS assets into the webpage directly.
+  -open           Launches the browser when the server docs has started.
+  -p              Specifies the port to be used for the docs server.
+  -s              Serve HTML-generated docs via HTTP.
+
+For plain text mode:
+  -l              Show the locations of the generated signatures.

cmd/v/help/fmt.txt

@@ -0,0 +1,31 @@
+Usage:
+  v fmt [options] path_to_source.v [path_to_other_source.v]
+
+Formats the given V source files, then prints their formatted source to stdout.
+
+Options:
+  -c      Check if file is already formatted.
+          If it is not, print filepath, and exit with code 2.
+
+  -diff   Display the differences between the formatted source(s) and the original source(s).
+          This will attempt to find a working `diff` command automatically unless you
+          specify one with the VDIFF_TOOL environment variable.
+
+  -l      List files whose formatting differs from vfmt.
+
+  -w      Write result to (source) file(s) instead of to stdout.
+
+  -debug  Print the kinds of encountered AST statements/expressions on stderr.
+
+  -verify Make sure the provided file is already formatted. Useful for checking code contributions
+          in CI for example.
+
+Environment Variables:
+  VDIFF_TOOL      A command-line tool that will be executed with the original file path
+                  and a temporary formatted file path as arguments. e.g.
+                  `VDIFF_TOOL=opendiff v fmt -diff path/to/file.v` will become:
+                  opendiff path/to/file.v /tmp/v/vfmt_file.v
+
+  VDIFF_OPTIONS   A set of command-line options to be sent immediately after the
+                  `diff` command. e.g.
+                  VDIFF_OPTIONS="-W 80 -y" v fmt -diff path/to/file.v /tmp/v/vfmt_file.v

cmd/v/help/help.v

@@ -0,0 +1,28 @@
+module help
+
+// TODO: move this file outside internal, and merge it with cmd/tools/modules/vhelp/vhelp.v .
+import os
+import v.pref
+
+const (
+	unknown_topic = 'V Error: Unknown help topic provided. Use `v help` for usage information.'
+)
+
+pub fn print_and_exit(topic string) {
+	vexe := pref.vexe_path()
+	vroot := os.dir(vexe)
+	for b in topic {
+		if (b >= `a` && b <= `z`) || b == `-` || (b >= `0` && b <= `9`) {
+			continue
+		}
+		eprintln(unknown_topic)
+		exit(1)
+	}
+	target_topic := os.join_path(vroot, 'cmd', 'v', 'help', '${topic}.txt')
+	content := os.read_file(target_topic) or {
+		eprintln(unknown_topic)
+		exit(1)
+	}
+	println(content)
+	exit(0)
+}

cmd/v/help/install.txt

@@ -0,0 +1,12 @@
+Usage:
+  v install module [module] [module] [...]
+  ^^^^^^^^^^^^^ will install the modules you specified
+
+You can also do `v install` directly if you have dependencies stored
+inside the `v.mod` file. This will automatically installs the modules
+specified inside of it.
+
+Options:
+  -help         - Show usage info.
+  -v            - Print more details about the performed operation.
+  -server-url   - When doing network operations, use this vpm server. Can be given multiple times.

cmd/v/help/other.txt

@@ -0,0 +1,14 @@
+These are utility commands that you can also launch through v,
+but which are used less frequently by users:
+
+   bin2v             Convert a binary file to a v source file,
+                     that can be later embedded in a module or program.
+
+   build-examples    Test if all examples can be built.
+   build-tools       Test if all tools can be built.
+   build-vbinaries   Test if V can be built with different configuration.
+   test-fmt          Test if all files in the current directory are formatted properly.
+   test-compiler     Test if V is working properly by running all tests, including the compiler ones.
+                     NB: this can take a minute or two to run
+
+   setup-freetype    Setup thirdparty freetype on Windows.

cmd/v/help/remove.txt

@@ -0,0 +1,9 @@
+Usage:
+ a) v remove module [module] [module] [...]
+    ^^^^^^^^^^^^ will remove the listed modules
+ b) v remove
+    ^^^^^^^^^^^^ will remove ALL installed modules
+Options:
+  -help        - Show usage info.
+  -v           - Print more details about the performed operation.
+  -server-url  - When doing network operations, use this vpm server. Can be given multiple times.

cmd/v/help/run.txt

@@ -0,0 +1,13 @@
+Usage: v [build flags] run <file.v|directory|-> [arguments...]
+
+This command is equivalent to running `v build` and running the compiled executable.
+The executable is passed the arguments as provided in [arguments...].
+
+If the target is '-', it means that the V source code to build comes from stdin.
+If the '-o' option is not specified, and the target is '-', a temporary base name for the executable will be used.
+
+The exit status of run will be:
+* `1` if the compilation failed.
+* The exit code of the compiled executable otherwise.
+
+For more about build flags, see `v help build`.

cmd/v/help/search.txt

@@ -0,0 +1,8 @@
+Usage:
+  v search keyword1 [keyword2] [...]
+  ^^^^^^^^^^^^^^^^^ will search https://vpm.vlang.io/ for matching modules,
+                    and will show details about them
+Options:
+  -help         - Show usage info.
+  -v            - Print more details about the performed operation.
+  -server-url   - When doing network operations, use this vpm server. Can be given multiple times.