vweb: set_content_type()

A nested list is much easier to browse than a table.
Move Imports section below Arrays and Maps for Types grouping.
Move Defer section to Statements group.
Move vfmt section next to Profiling for Tools group.

.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,3 @@
-*.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

.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,6 +1,6 @@
 ---
 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: ''

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,14 +2,13 @@
 name: Bug report
 about: Bug report
 title: ''
-labels: bug
+labels: 'Bug'
 assignees: ''
 
 ---
 
 **V version:** 
 **OS:** 
-**C compiler version:** 
 
 **What did you do?**
 

.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,40 @@
-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
+```
 
 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,17 @@
+#!/bin/sh -l
+
+set -e
+
+pwd
+
+uname -a
+
+du -s .
+
+ls -lat 
+
+./v test-compiler
+
+./v build-vbinaries
+
+echo "DONE"

.github/workflows/ci.yml

@@ -0,0 +1,381 @@
+name: CI
+on: [push, pull_request]
+jobs:
+
+#  v-fmt:
+#    runs-on: ubuntu-18.04
+#    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
+
+  ubuntu-tcc:
+    runs-on: ubuntu-18.04
+    env:
+      VFLAGS: -cc /var/tmp/tcc/bin/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 libglfw3 libglfw3-dev libfreetype6-dev libssl-dev sqlite3 libsqlite3-dev libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev valgrind
+    - name: Build v
+      run: |
+        echo $VFLAGS
+        make -j4
+        ./v -cg -o v cmd/v
+    - name: Test v->c
+      run: |
+        sudo ln -s /var/tmp/tcc/bin/tcc /usr/local/bin/tcc
+        tcc -version
+        ./v -cg -o v cmd/v # Make sure vtcc can build itself twice
+#        ./v -silent test-compiler
+    - name: Fixed tests
+      run: ./v test-fixed
+    - name: Test building v tools
+      run: ./v build-tools
+#    - name: Test v binaries
+#      run: ./v -silent build-vbinaries
+
+  alpine-docker-musl-gcc:
+    name: alpine-musl
+    runs-on: ubuntu-latest
+    env:
+      V_CI_MUSL: 1
+    steps:
+
+    - name: Checkout
+      uses: actions/checkout@v2
+
+#    - name: Build V
+#      uses: spytheman/docker_alpine_v@v7.0
+#      with:
+#        entrypoint: .github/workflows/alpine.build.sh
+
+#    - name: Test V
+#      uses: spytheman/docker_alpine_v@v7.0
+#      with:
+#        entrypoint: .github/workflows/alpine.test.sh
+
+  macos:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macOS-latest]
+    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 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 -o v cmd/v
+    - name: Build V using V
+      run:  ./v -o v2 cmd/v && ./v2 -o v3 cmd/v
+    - name: Test symlink
+      run:  sudo ./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: Test symlink
+      run:  ./v symlink && v -o v2 cmd/v
+    - name: Fixed tests
+      run: ./v test-fixed
+    - name: Build examples
+      run: ./v build-examples
+#    - name: Cross-compilation to Linux
+#      run: ./v -os linux cmd/v
+#    - name: Test vsh
+#      run:  ./v examples/v_script.vsh
+    - name: Test vid
+      run: |
+        git clone --depth 1 https://github.com/vlang/vid
+        cd vid && ../v -o vid .
+    - 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 examples/users.v
+        ../v examples/calculator.v
+
+  ubuntu:
+    runs-on: ubuntu-18.04
+    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 libglfw3 libglfw3-dev libfreetype6-dev libssl-dev sqlite3 libsqlite3-dev libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev valgrind
+    - name: Build V
+      run: make -j4 && ./v -cc gcc -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: Build V UI examples
+#      run: ./v install ui && git clone --depth 1 https://github.com/vlang/ui && cd ui && ../v examples/calculator.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: Fixed tests
+      run: |
+        ./v test-fixed
+    - name: Build examples
+      run: ./v build-examples
+    - 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: V self compilation with -autofree
+      run: ./v -o v2 -autofree cmd/v && ./v2 -o v3 -autofree cmd/v && ./v3 -o v4 -autofree cmd/v
+#    - 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-musl:
+    runs-on: ubuntu-18.04
+    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 libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev valgrind
+    - 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 test-fixed
+
+  ubuntu-llvm-mingw:
+    runs-on: ubuntu-18.04
+    steps:
+    - uses: actions/checkout@v2
+#    - name: Cross-compile V
+#      run: docker build . -f Dockerfile.cross
+
+  windows-gcc:
+    runs-on: windows-2019
+    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 -skip-path
+    - name: Test new v.c
+      run: .\v.exe -o v.c cmd/v && gcc -municode -w v.c
+    - name: Install dependencies
+      run: |
+        .\v.exe setup-freetype
+        .\.github\workflows\windows-install-sdl.bat
+        .\.github\workflows\windows-install-sqlite.bat
+    - name: Fixed tests
+      run: |
+        .\v.exe 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
+    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 -skip-path
+    - name: Install dependencies
+      run: |
+        .\v.exe setup-freetype
+        .\.github\workflows\windows-install-sdl.bat
+        .\.github\workflows\windows-install-sqlite.bat
+    - name: Fixed tests
+      run: |
+        ./v -cg cmd\tools\vtest-fixed.v
+        ./v 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
+
+  windows-tcc:
+    runs-on: windows-2019
+    # 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 doesn't find a C compiler
+      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 -skip-path
+    - name: Test new v.c
+      run: .\v.exe -o v.c cmd/v && .\thirdparty\tcc\tcc.exe -w -ladvapi32 -bt10 v.c
+    - name: Install dependencies
+      run: |
+        .\v.exe setup-freetype
+        .\.github\workflows\windows-install-sdl.bat
+        .\.github\workflows\windows-install-sqlite.bat
+    - name: Fixed tests
+      run: |
+        .\v.exe 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
+
+  docs-line-len-check:
+    runs-on: ubuntu-18.04
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build
+      run: make
+    - name: Check docs line length
+      run: ./v run cmd/tools/check-md.v doc/docs.md CHANGELOG.md
+
+
+
+  compilable-v-c-and-v-win-c:
+    runs-on: ubuntu-latest
+    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
+    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 libglfw3 libglfw3-dev libfreetype6-dev libssl-dev sqlite3 libsqlite3-dev libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev valgrind g++-9
+    - name: Build V
+      run: make -j4
+    - name: g++ version
+      run: g++-9 --version
+    - name: Running tests with g++
+      run: ./v -cc g++-9 test-fixed
+    - name: V self compilation with g++
+      run: ./v -cc g++-9 -o v2 cmd/v && ./v2 -cc g++-9 -o v3 cmd/v
+
+  install-modules:
+    runs-on: ubuntu-latest
+    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

.github/workflows/periodic.yml

@@ -0,0 +1,53 @@
+name: Periodic
+
+on:
+  schedule:
+    - cron:  '31 1,12 * * *'
+
+jobs:
+  network-tests-ubuntu:
+    runs-on: ubuntu-latest
+    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 test-fixed
+
+
+  network-tests-macos:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macOS-latest]
+    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 test-fixed
+
+
+  network-windows-msvc:
+    runs-on: windows-2019
+    env:
+        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 test-fixed

.github/workflows/prebuilt.yml

@@ -0,0 +1,51 @@
+name: Test prebuilt binaries
+on:
+  release:
+    types: [edited, published]
+jobs:
+  ubuntu:
+    runs-on: ubuntu-latest
+    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 libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev libsdl2-image-dev valgrind
+    - 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
+    steps:
+    - name: Install dependencies
+      run: |
+        brew install freetype glfw openssl 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
+    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,73 @@
+# 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
+
+# ignore debugger files
+cachegrind.out.*
+.gdb_history
 *.dSYM
-*_test
+*.def
+
+# ignore system files
+.DS_Store
+._*
+thumbs.db
+/.symlink/*
+/.bin/*
+
+_docs

.travis.yml

@@ -1,36 +0,0 @@
-language: c
-matrix:
-  include:
-    - os: linux
-      sudo: required
-      addons:
-        apt:
-          sources:
-          - ubuntu-toolchain-r-test
-          packages:
-          - gcc-5
-          - g++-5
-          - make
-          - libglfw3 
-          - libglfw3-dev
-          - libfreetype6-dev 
-          - libcurl3-dev
-    - 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
-  - export VROOT=$(pwd)
-  - cd ./compiler
-  - make
-  - make test
-

0.3_roadmap.txt

@@ -0,0 +1,13 @@
++ = done
+- = TODO
+
+- coroutines
+- bring back lock{}
+- thread safe arrays/maps
+- C2V translator
+- doom.v
+- rune type, replace ustring with []rune
+- maps with non-string keys
+
+
+

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,369 @@
+## V 0.1.27
+*5 May 2020*
 
-# 0.1.8 
+- 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 detailed information 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 and fixed size 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, allowing 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 V/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 (`[a..b]` slicing syntax should be used 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 code reloading now works with graphical applications: [bounce.v](https://github.com/vlang/v/blob/master/examples/hot_code_reloading/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.
+- `glad` and `cJSON` are now compiled only once, this makes compilation of programs using `gg` and `json` 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 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,158 @@
+## 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`, it will download the C
+version of the compiler and rebuild it from scratch.
+
+
+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.
+
+## 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`
+
+### 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

@@ -0,0 +1,129 @@
+CC ?= cc
+CFLAGS ?=
+LDFLAGS ?=
+TMPDIR ?= /tmp
+VC     ?= ./vc
+
+VCFILE := v.c
+TMPTCC := /var/tmp/tcc
+VCREPO := https://github.com/vlang/vc
+TCCREPO := https://github.com/vlang/tccbin
+GITCLEANPULL := git clean -xf && git pull --quiet
+GITFASTCLONE := git clone --depth 1 --quiet
+
+#### Platform detections and overrides:
+_SYS := $(shell uname 2>/dev/null || echo Unknown)
+_SYS := $(patsubst MSYS%,MSYS,$(_SYS))
+_SYS := $(patsubst MINGW%,MinGW,$(_SYS))
+
+ifneq ($(filter $(_SYS),MSYS MinGW),)
+WIN32 := 1
+endif
+
+ifeq ($(_SYS),Linux)
+LINUX := 1
+endif
+
+ifeq ($(_SYS),Darwin)
+MAC := 1
+endif
+
+ifeq ($(_SYS),FreeBSD)
+LDFLAGS += -lexecinfo
+endif
+
+ifdef ANDROID_ROOT
+ANDROID := 1
+undefine LINUX
+endif
+#####
+
+ifdef WIN32
+TCCREPO := https://github.com/vlang/tccbin_win
+VCFILE := v_win.c
+endif
+
+all: latest_vc latest_tcc
+ifdef WIN32
+	$(CC) $(CFLAGS) -g -std=c99 -municode -w -o v.exe $(VC)/$(VCFILE) $(LDFLAGS)
+ifdef prod
+	./v.exe -prod self
+else
+	./v.exe self
+endif
+else
+	$(CC) $(CFLAGS) -g -std=gnu11 -w -o v $(VC)/$(VCFILE) $(LDFLAGS) -lm -lpthread
+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 -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 MAC
+ifndef local
+	cd $(TMPTCC) && $(GITCLEANPULL)
+else
+	@echo "Using local tcc"
+endif    
+endif
+endif
+
+fresh_tcc:
+ifndef ANDROID
+ifndef MAC
+	rm -rf $(TMPTCC)
+	$(GITFASTCLONE) $(TCCREPO) $(TMPTCC)
+endif
+endif
+
+$(TMPTCC)/.git/config:
+ifndef MAC
+	$(MAKE) fresh_tcc
+endif
+
+$(VC)/.git/config:
+	$(MAKE) fresh_vc
+
+selfcompile:
+	./v -keepc -cg -o v cmd/v
+
+selfcompile-static:
+	./v -keepc -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,143 +1,219 @@
-# 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](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: ≈100k — 1.2 million loc/s
 - Easy to develop: V compiles itself in less than a second
-- Performance: within 5% of C
+- Performance: within 3% of 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
+- C and JavaScript backends
 
-V 1.0 release is planned for December 2019.
-
-## Notes
-
-GitHub marks V's code as written in Go. It's actually written in V, GitHub doesn't support the language yet.
-
-The compilation is temporarily slower for this release:
-
-- 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
+A stable 0.2 release is planned for June 2020. Right now V is in an alpha stage.
 
 ## 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/compiler
+cd v
 make
 ```
-Or build without make:
+
+That's it! Now you have a V executable at `[path to V repo]/v`. 
+`[path to V repo]` can be anywhere.
+
+(On Windows `make` means running `make.bat`, so make sure you use `cmd.exe`)
+
+Now you can try `./v run examples/hello_world.v` (`v.exe` on Windows).
+
+V is being constantly updated. To update V, simply run:
+
+```
+v up
+```
+
+### C compiler
+
+You'll need 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)
+
+### 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 everytime.
+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
-# Download the V compiler's source translated to C
-wget 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
+sudo ./v symlink
 ```
 
-That's it! Now you have a V executable at `v/compiler/v`.
-
-You can create a symlink so that it's globally available:
-
+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
 ```
-sudo ln -s [path to V repo]/compiler/v /usr/local/bin/v
+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
+git clone https://github.com/vlang/v
+cd v
+docker build -t vlang .
+docker run --rm -it vlang:latest
+v
 ```
 
-V is being constantly updated. To update V, simply run
+### Docker with Alpine/musl:
+```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
+```
+</details>
+
+
+### Testing and running the examples
+
+Make sure V can compile itself:
 
 ```
-git pull origin master
-cd compiler/
-make clean
-make
+v -o v2 cmd/v
 ```
 
-
-### 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 will need Visual Studio. Microsoft doesn't make it easy for developers.  Mingw-w64 could suffice, but if you plan to develop UI and graphical apps, VS is your only option.
-
-V temporarily can't be compiled with Visual Studio. This will be fixed asap.
-
-### Testing
-
-```
-$ cd examples
-$ v run hello_world.v
-hello world
-
+```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>
 
+In order to build Tetris and anything else using the graphics module on non-Windows systems, you will need to install freetype libraries.
 
-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 libcurl.
+If you plan to use the http package, you also need to install OpenSSL on non-Windows systems.
 
 ```
 macOS:
-brew install glfw freetype curl
+brew install freetype openssl
 
-Ubuntu:
-sudo apt install libglfw3 libglfw3-dev libfreetype6-dev libcurl3-dev
+Debian/Ubuntu:
+sudo apt install libfreetype6-dev libssl-dev
 
-Arch:
-sudo pacman -S glfw-x11 curl freetype2
+Arch/Manjaro:
+sudo pacman -S freetype2
+
+Fedora:
+sudo dnf install freetype-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
+```
+-->
+
+## 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.herokuapp.com%2Fvlang%2Fpledges&label=Patreon
+[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

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: |
-          cd compiler && make
-        displayName: 'Build V'
-      - script: |
-          cd compiler && 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: |
-          cd compiler && make && make test
-        displayName: 'Build V'
-trigger:
-  branches:
-    include:
-      - '*'
-pr:
-  autoCancel: false
-  branches:
-    include:
-      - '*'

base64/base64.v

@@ -1,112 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-module base64
-
-const (
-	Index = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	62, 63, 62, 62, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0,
-	0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-	17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 63, 0, 26, 27, 28, 29,
-	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
-	47, 48, 49, 50, 51]
-)
-
-pub fn decode(data string) string {
-	mut padding := 0
-	if data.ends_with('=') {
-		if data.ends_with('==') {
-			padding = 2
-		} else {
-			padding = 1
-		}
-	}
-	//input_length is the length of meaningful data
-	input_length := data.len - padding
-	output_length := input_length * 3 / 4
-
-	mut i := 0
-	mut j := 0
-	mut str := malloc(output_length)
-
-	for i < input_length {
-		mut char_a := 0
-		mut char_b := 0
-		mut char_c := 0
-		mut char_d := 0
-
-		if i < input_length {
-			char_a = Index[int(data[i])]
-			i++
-		}
-		if i < input_length {
-			char_b = Index[int(data[i])]
-			i++
-		}
-		if i < input_length {
-			char_c = Index[int(data[i])]
-			i++
-		}
-		if i < input_length {
-			char_d = Index[int(data[i])]
-			i++
-		}
-
-		decoded_bytes := (char_a << 18) | (char_b << 12) | (char_c << 6) | (char_d << 0)
-		str[j] = decoded_bytes >> 16
-		str[j+1] = (decoded_bytes >> 8) & 0xff
-		str[j+2] = (decoded_bytes >> 0) & 0xff
-
-		j += 3
-	}
-	return tos(str, output_length)
-}
-
-const (
-	EncodingTable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-)
-
-pub fn encode(data string) string {
-	input_length := data.len
-	output_length := 4 * ((input_length + 2) / 3)
-
-	mut i := 0
-	mut j := 0
-	mut str := malloc(output_length)
-
-	for i < input_length {
-		mut octet_a := 0
-		mut octet_b := 0
-		mut octet_c := 0
-
-		if i < input_length {
-			octet_a = int(data[i])
-			i++
-		}
-		if i < input_length {
-			octet_b = int(data[i])
-			i++
-		}
-		if i < input_length {
-			octet_c = int(data[i])
-			i++
-		}
-
-		triple := ((octet_a << 0x10) + (octet_b << 0x08) + octet_c)
-
-		str[j+0] = EncodingTable[(triple >> 3 * 6) & 63] // 63 is 0x3F
-		str[j+1] = EncodingTable[(triple >> 2 * 6) & 63]
-		str[j+2] = EncodingTable[(triple >> 1 * 6) & 63]
-		str[j+3] = EncodingTable[(triple >> 0 * 6) & 63]
-		j += 4
-	}
-
-	mod_table := [0, 2, 1]
-	for i = 0; i < mod_table[input_length % 3]; i++ {
-		str[output_length - 1 - i] = `=`
-	}
-
-	return tos(str, output_length)
-}

base64/base64_test.v

@@ -1,16 +0,0 @@
-import base64
-
-fn test_decode() {
-	assert base64.decode('TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=')
-	== 'Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.'
-
-	// Test for incorrect padding.
-	assert base64.decode('aGk') == 'hi'
-	assert base64.decode('aGk=') == 'hi'
-	assert base64.decode('aGk==') == 'hi'
-}
-
-fn test_encode() {
-	assert base64.encode('Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.')
-	== 'TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4='
-}

builtin/array.v

@@ -1,227 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-module builtin
-
-struct array {
-	// Using a void pointer allows to implement arrays without generics and without generating
-	// extra code for every type.
-pub:
-	data         voidptr
-	len          int
-	cap          int
-	element_size int
-}
-
-// Private function, used by V (`nums := []int`)
-fn new_array(mylen, cap, elm_size int) array {
-	arr := array {
-		len: mylen
-		cap: cap
-		element_size: elm_size
-		data: malloc(cap * elm_size)
-	}
-	return arr
-}
-
-// Private function, used by V (`nums := [1, 2, 3]`)
-fn new_array_from_c_array(len, cap, elm_size int, c_array voidptr) array {
-	arr := array {
-		len: len
-		cap: cap
-		element_size: elm_size
-		data: malloc(cap * elm_size)
-	}
-	// TODO Write all memory functions (like memcpy) in V
-	C.memcpy(arr.data, c_array, len * elm_size)
-	return arr
-}
-
-// Private function, used by V (`nums := [1, 2, 3] !`)
-fn new_array_from_c_array_no_alloc(len, cap, elm_size int, c_array voidptr) array {
-	arr := array {
-		len: len
-		cap: cap
-		element_size: elm_size
-		data: c_array
-	}
-	return arr
-}
-
-// Private function, used by V  (`[0; 100]`)
-fn array_repeat(val voidptr, nr_repeats, elm_size int) array {
-	arr := array {
-		len: nr_repeats
-		cap: nr_repeats
-		element_size: elm_size
-		data: malloc(nr_repeats * elm_size)
-	}
-	for i := 0; i < nr_repeats; i++ {
-		C.memcpy(arr.data + i * elm_size, val, elm_size)
-	}
-	return arr
-}
-
-pub fn (a mut array) append_array(b array) {
-	for i := 0; i < b.len; i++ {
-		val := b[i]
-		a._push(val)
-	}
-}
-
-pub fn (a mut array) sort_with_compare(compare voidptr) {
-	C.qsort(a.data, a.len, a.element_size, compare)
-}
-
-pub fn (a mut array) insert(i int, val voidptr) {
-	if i >= a.len {
-		panic('array.insert: index larger than length')
-		return
-	}
-	a._push(val)
-	size := a.element_size
-	C.memmove(a.data + (i + 1) * size, a.data + i * size, (a.len - i) * size)
-	a.set(i, val)
-}
-
-pub fn (a mut array) prepend(val voidptr) {
-	a.insert(0, val)
-}
-
-pub fn (a mut array) delete(idx int) {
-	size := a.element_size
-	C.memmove(a.data + idx * size, a.data + (idx + 1) * size, (a.len - idx) * size)
-	a.len--
-	a.cap--
-}
-
-fn (a array) _get(i int) voidptr {
-	if i < 0 || i >= a.len {
-		panic('array index out of range: $i/$a.len')
-	}
-	return a.data + i * a.element_size
-}
-
-pub fn (a array) first() voidptr {
-	if a.len == 0 {
-		panic('array.first: empty array')
-	}
-	return a.data + 0
-}
-
-pub fn (a array) last() voidptr {
-	if a.len == 0 {
-		panic('array.last: empty array')
-	}
-	return a.data + (a.len - 1) * a.element_size
-}
-
-pub fn (s array) left(n int) array {
-	if n >= s.len {
-		return s
-	}
-	return s.slice(0, n)
-}
-
-pub fn (s array) right(n int) array {
-	if n >= s.len {
-		return s
-	}
-	return s.slice(n, s.len)
-}
-
-pub fn (s array) slice(start, _end int) array {
-	mut end := _end
-	if start > end {
-		panic('invalid slice index: $start > $end')
-	}
-	if end >= s.len {
-		end = s.len
-	}
-	l := end - start
-	res := array {
-		element_size: s.element_size
-		data: s.data + start * s.element_size
-		len: l
-		cap: l
-	}
-	return res
-}
-
-pub fn (a mut array) set(idx int, val voidptr) {
-	if idx < 0 || idx >= a.len {
-		panic('array index out of range: $idx / $a.len')
-	}
-	C.memcpy(a.data + a.element_size * idx, val, a.element_size)
-}
-
-pub fn (arr mut array) _push(val voidptr) {
-	if arr.len >= arr.cap - 1 {
-		cap := (arr.len + 1) * 2
-		// println('_push: realloc, new cap=$cap')
-		if arr.cap == 0 {
-			arr.data = malloc(cap * arr.element_size)
-		}
-		else {
-			arr.data = C.realloc(arr.data, cap * arr.element_size)
-		}
-		arr.cap = cap
-	}
-	C.memcpy(arr.data + arr.element_size * arr.len, val, arr.element_size)
-	arr.len++
-}
-
-pub fn (arr mut array) _push_many(val voidptr, size int) {
-	if arr.len >= arr.cap - size {
-		cap := (arr.len + size) * 2
-		// println('_push: realloc, new cap=$cap')
-		if arr.cap == 0 {
-			arr.data = malloc(cap * arr.element_size)
-		}
-		else {
-			arr.data = C.realloc(arr.data, cap * arr.element_size)
-		}
-		arr.cap = cap
-	}
-	C.memcpy(arr.data + arr.element_size * arr.len, val, arr.element_size * size)
-	arr.len += size
-}
-
-pub fn (a[]int) str() string {
-	mut res := '['
-	for i := 0; i < a.len; i++ {
-		val := a[i]
-		res += '$val'
-		if i < a.len - 1 {
-			res += ', '
-		}
-	}
-	res += ']'
-	return res
-}
-
-pub fn (a[]int) free() {
-	// println('array free')
-	C.free(a.data)
-}
-
-// TODO generic
-// "[ 'a', 'b', 'c' ]"
-pub fn (a[]string) str() string {
-	mut res := '['
-	for i := 0; i < a.len; i++ {
-		val := a[i]
-		res += '"$val"'
-		if i < a.len - 1 {
-			res += ', '
-		}
-	}
-	res += ']'
-	return res
-}
-
-fn free(a voidptr) {
-	C.free(a)
-}
-

builtin/array_test.v

@@ -1,138 +0,0 @@
-import os
-
-const (
-	q = [1, 2, 3]
-	A = 8
-)
-
-fn test_ints() {
-	mut a := [1, 5, 2, 3]
-	assert a.len == 4
-	assert a[0] == 1
-	assert a[2] == 2
-	assert a.last() == 3
-	println(a)
-	a << 4
-	println(a)
-	assert a.len == 5
-	assert a[4] == 4
-	assert a.last() == 4
-	// assert a.contains(4) == true
-	// assert a.contains(777) == false
-	// assert a.str() == '51234'
-	mut s := a.str()
-	assert s == '[1, 5, 2, 3, 4]'
-	// Insert
-	// val := 5
-	// a.insert(1, val)// 1 5 2 3 4
-	s = a.str()
-	assert a[1] == 5
-	assert a.last() == 4
-	// a.sort()
-	s = a.str()
-	assert s == '[1, 5, 2, 3, 4]'
-	// Delete
-	a.delete(0)
-	assert a.str() == '[5, 2, 3, 4]'
-	a.delete(1)
-	assert a.str() == '[5, 3, 4]'
-}
-
-fn test_short() {
-	a := [1, 2, 3]
-	assert a.len == 3
-	assert a.cap == 3
-	assert a[0] == 1
-	assert a[1] == 2
-	assert a[2] == 3
-}
-
-fn test_large() {
-	mut a := [0; 0]
-	for i := 0; i < 10000; i++ {
-		a << i
-	}
-	assert a.len == 10000
-	assert a[234] == 234
-}
-
-struct Chunk {
-	val string
-}
-
-struct K {
-	q []Chunk
-}
-
-fn test_empty() {
-	mut chunks := []Chunk{}
-	a := Chunk{}
-	assert chunks.len == 0
-	chunks << a
-	assert chunks.len == 1
-	chunks = []Chunk{}
-	assert chunks.len == 0
-	chunks << a
-	assert chunks.len == 1
-}
-fn test_push() {
-	mut a := []int
-	a << 1
-	a << 3
-	assert a[1] == 3
-	assert a.str() == '[1, 3]'
-}
-
-fn test_strings() {
-	s := 'hi'
-	if s.contains('i') {
-		// println('$s')
-	}
-	a := ['a', 'b', 'c']
-	assert a.str() == '["a", "b", "c"]'
-	// println(a)
-}
-
-fn test_repeat() {
-	a := [0; 5]
-	// a := [0 x 5]
-	assert a.len == 5
-	assert a[0] == 0 && a[1] == 0 && a[2] == 0 && a[3] == 0 && a[4] == 0
-}
-
-fn test_right() {
-	a := [1, 2, 3, 4]
-	b := a.right(1)
-	assert b[0] == 2
-	assert b[1] == 3
-}
-
-fn test_left() {
-	a := [1, 2, 3]
-	b := a.left(2)
-	assert b[0] == 1
-	assert b[1] == 2
-}
-
-fn test_slice() {
-	a := [1, 2, 3, 4]
-	b := a.slice(2, 4)
-	for val in b {
-		println(val)
-	}
-	assert a.slice(1, 2).len == 1
-	println(a.slice(2, 4))
-}
-
-fn test_push_many() {
-	mut a := [1, 2, 3]
-	b := [4, 5, 6]
-	a._push_many(b.data, b.len)
-	assert a.len == 6
-	assert a[0] == 1
-	assert a[3] == 4
-	assert a[5] == 6
-	println(a)
-}
-
-

builtin/builtin.v

@@ -1,113 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-module builtin
-
-pub fn exit(code int) {
-	C.exit(code)
-}
-
-// isnil returns true if an object is nil (only for C objects).
-pub fn isnil(v voidptr) bool {
-	return v == 0
-}
-
-fn on_panic(f fn (int) int) {
-	// TODO
-}
-
-pub fn print_backtrace() {
-	return
-	$if mac {
-		buffer := [100]voidptr
-		nr_ptrs := C.backtrace(buffer, 100)
-		C.backtrace_symbols_fd(buffer, nr_ptrs, 1)
-	}
-}
-
-pub fn panic(s string) {
-	println('V panic: $s')
-	print_backtrace()
-	C.exit(1)
-}
-
-pub fn println(s string) {
-	// Should never happen
-	if isnil(s.str) {
-		panic('println(NIL)')
-	}
-	C.printf('%.*s\n', s.len, s.str)
-}
-
-pub fn eprintln(s string) {
-	if isnil(s.str) {
-		panic('eprintln(NIL)')
-	}
-	$if mac {
-		C.fprintf(stderr, '%.*s\n', s.len, s.str)
-	}
-	// TODO issues with stderr and cross compiling for Linux
-	$else {
-		println(s)
-	}
-}
-
-pub fn print(s string) {
-	C.printf('%.*s', s.len, s.str)
-}
-
-__global total_m i64 = 0
-pub fn malloc(n int) byteptr {
-	if n < 0 {
-		panic('malloc(<0)')
-	}
-#ifdef VPLAY
-	if n > 10000 {
-		panic('allocating more than 10 KB is not allowed in the playground')
-	}
-#endif
-#ifdef DEBUG_ALLOC
-	total_m += n
-	println('\n\n\nmalloc($n) total=$total_m')
-	print_backtrace()
-#endif
-	ptr := C.malloc(n)
-	if isnil(ptr) {
-		panic('malloc($n) failed')
-	}
-	return ptr
-}
-
-pub fn calloc(n int) byteptr {
-	if n < 0 {
-		panic('calloc(<0)')
-	}
-	return C.calloc(n, 1)
-}
-
-fn _strlen(s byteptr) int {
-	// TODO don't call a C function, implement it in V
-	return C.strlen(s)
-}
-
-// `fn foo() ?Foo { return foo }` => `fn foo() ?Foo { return opt_ok(foo); }`
-fn opt_ok(data voidptr) Option {
-	return Option {
-		data: data
-		ok: true
-	}
-}
-
-fn memdup(src voidptr, sz int) voidptr {
-	mem := malloc(sz)
-	return C.memcpy(mem, src, sz)
-}
-
-pub fn error(s string) Option {
-	return Option {
-		error: s
-	}
-}
-
-

builtin/int.v

@@ -1,161 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-module builtin
-
-pub fn (d double) str() string {
-	buf := malloc(sizeof(double) * 5 + 1)// TODO
-	C.sprintf(buf, '%f', d)
-	return tos(buf, _strlen(buf))
-}
-
-pub fn (d f64) str() string {
-	buf := malloc(sizeof(double) * 5 + 1)// TODO
-	C.sprintf(buf, '%f', d)
-	return tos(buf, _strlen(buf))
-}
-
-pub fn (d f32) str() string {
-	buf := malloc(sizeof(double) * 5 + 1)// TODO
-	C.sprintf(buf, '%f', d)
-	return tos(buf, _strlen(buf))
-}
-
-pub fn ptr_str(ptr voidptr) string {
-	buf := malloc(sizeof(double) * 5 + 1)// TODO
-	C.sprintf(buf, '%p', ptr)
-	return tos(buf, _strlen(buf))
-}
-
-// fn (nn i32) str() string {
-// return i
-// }
-pub fn (nn int) str() string {
-	mut n = nn
-	if n == 0 {
-		return '0'
-	}
-	max := 16
-	mut buf := malloc(max)
-	mut len := 0
-	mut is_neg = false
-	if n < 0 {
-		n = -n
-		is_neg = true
-	}
-	// Fill the string from the end
-	for n > 0 {
-		d := n % 10
-		buf[max - len - 1] = d + int(`0`)
-		len++
-		n = n / 10
-	}
-	// Prepend - if it's negative
-	if is_neg {
-		buf[max - len - 1] = `-`
-		len++
-	}
-	return tos(buf + max - len, len)
-}
-
-pub fn (nn u8) str() string {
-	 mut n = nn
-	if n == u8(0) {
-		return '0'
-	}
-	max := 5
-	mut buf := malloc(max)
-	mut len := 0
-	mut is_neg = false
-	if n < u8(0) {
-		n = -n
-		is_neg = true
-	}
-	// Fill the string from the end
-	for n > u8(0) {
-		d := n % u8(10)
-		buf[max - len - 1] = d + u8(`0`)
-		len++
-		n = n / u8(10)
-	}
-	// Prepend - if it's negative
-	if is_neg {
-		buf[max - len - 1] = `-`
-		len++
-	}
-	return tos(buf + max - len, len)
-}
-
-pub fn (nn i64) str() string {
-	mut n = nn
-	if n == i64(0) {
-		return '0'
-	}
-	max := 32
-	mut buf := malloc(max)
-	mut len := 0
-	mut is_neg = false
-	if n < i64(0) {
-		n = -n
-		is_neg = true
-	}
-	// Fill the string from the end
-	for n > i64(0) {
-		d := int(n % i64(10))
-		buf[max - len - 1] = d + int(`0`)
-		len++
-		n = n / i64(10)
-	}
-	// Prepend - if it's negative
-	if is_neg {
-		buf[max - len - 1] = `-`
-		len++
-	}
-	return tos(buf + max - len, len)
-}
-
-pub fn (b bool) str() string {
-	if b {
-		return 'true'
-	}
-	return 'false'
-}
-
-pub fn (n int) hex() string {
-	s := n.str()
-	hex := malloc(s.len + 2)
-	C.sprintf(hex, '0x%x', n)
-	return tos(hex, s.len + 2)
-}
-
-pub fn (n i64) hex() string {
-	s := n.str()
-	hex := malloc(s.len + 2)
-	C.sprintf(hex, '0x%x', n)
-	return tos(hex, s.len + 2)
-}
-
-pub fn (a[]byte) contains(val byte) bool {
-	for aa in a {
-		if aa == val {
-			return true
-		}
-	}
-	return false
-}
-
-/*  TODO 
-fn (c rune) str() string {
-}
-*/
-pub fn (c byte) str() string {
-	mut str := string {
-		len: 1
-		str: malloc(2)
-	}
-	str.str[0] = c
-	str.str[1] = `\0`
-	return str
-}
-

builtin/map.v

@@ -1,181 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-module builtin
-
-struct map {
-	// cap          int
-	// keys         []string
-	// table        byteptr
-	// keys_table   *string
-	// table *Entry
-	element_size int
-	// collisions   []Entry
-pub:
-	entries      []Entry
-	is_sorted    bool
-}
-
-struct Entry {
-pub:
-	key string
-	val voidptr
-	// linked list for collisions
-	// next *Entry
-}
-
-pub fn new_map(cap, elm_size int) map {
-	res := map {
-		// len: len,
-		element_size: elm_size
-		// entries:
-		// keys: []string
-	}
-	return res
-}
-
-fn (m &map) new_entry(key string, val voidptr) Entry {
-	new_e := Entry {
-		key: key
-		val: malloc(m.element_size)
-		// next: 0
-	}
-	C.memcpy(new_e.val, val, m.element_size)
-	return new_e
-}
-
-fn (m mut map) _set(key string, val voidptr) {
-	e := m.new_entry(key, val)
-	for i := 0; i < m.entries.len; i++ {
-		entry := m.entries[i]
-		if entry.key == key {
-			// e := Entry2{key: key, val: val}
-			m.entries[i] = e
-			return
-		}
-	}
-	m.entries << e// m.new_entry(key, val)
-	m.is_sorted = false
-}
-
-fn volt_abs(n int) int {
-	// println('volt_abs($n)')
-	if n < 0 {
-		// println('< 0: -($n)')
-		return -n
-	}
-	return n
-}
-
-fn (m map) bs(query string, start, end int, out voidptr) {
-	// println('bs "$query" $start -> $end')
-	mid := start + ((end - start) / 2)
-	if end - start == 0 {
-		last := m.entries[end]
-		C.memcpy(out, last.val, m.element_size)
-		return
-	}
-	if end - start == 1 {
-		first := m.entries[start]
-		C.memcpy(out, first.val, m.element_size)
-		return
-	}
-	if mid >= m.entries.len {
-		return
-	}
-	mid_msg := m.entries[mid]
-	// println('mid.key=$mid_msg.key')
-	if query < mid_msg.key {
-		m.bs(query, start, mid, out)
-		return
-	}
-	m.bs(query, mid, end, out)
-}
-
-fn compare_map(a, b *Entry) int {
-	if a.key < b.key {
-		return -1
-	}
-	if a.key > b.key {
-		return 1
-	}
-	return 0
-}
-
-pub fn (m mut map) sort() {
-	m.entries.sort_with_compare(compare_map)
-	m.is_sorted = true
-}
-
-pub fn (m map) keys() []string {
-	mut keys := []string{}
-	for i := 0; i < m.entries.len; i++ {
-		entry := m.entries[i]
-		keys << entry.key
-	}
-	return keys
-}
-
-fn (m map) get(key string, out voidptr) bool {
-	if m.is_sorted {
-		// println('\n\nget "$key" sorted')
-		m.bs(key, 0, m.entries.len, out)
-		return true
-	}
-	for i := 0; i < m.entries.len; i++ {
-		entry := m.entries[i]
-		if entry.key == key {
-			C.memcpy(out, entry.val, m.element_size)
-			return true
-		}
-	}
-	return false
-}
-
-pub fn (m map) exists(key string) bool {
-	for i := 0; i < m.entries.len; i++ {
-		entry := m.entries[i]
-		if entry.key == key {
-			return true
-		}
-	}
-	return false
-}
-
-pub fn (m map) print() {
-	println('<<<<<<<<')
-	for i := 0; i < m.entries.len; i++ {
-		// entry := m.entries[i]
-		// println('$entry.key => $entry.val')
-	}
-	/*
-	for i := 0; i < m.cap * m.element_size; i++ {
-		b := m.table[i]
-		print('$i: ')
-		C.printf('%02x', b)
-		println('')
-	}
-*/
-	println('>>>>>>>>>>')
-}
-
-pub fn (m map) free() {
-	// C.free(m.table)
-	// C.free(m.keys_table)
-}
-
-pub fn (m map_string) str() string {
-	// return 'not impl'
-	if m.entries.len == 0 {
-		return '{}'
-	}
-	// TODO use bytes buffer
-	mut s := '{\n'
-	for entry in m.entries {
-		val := m[entry.key]
-		s += '  "$entry.key" => "$val"\n'
-	}
-	s += '}'
-	return s
-}

builtin/option.v

@@ -1,12 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-module builtin
-
-struct Option {
-	data  voidptr
-	error string
-	ok    bool
-}
-

builtin/string.v

@@ -1,840 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-module builtin
-
-// V strings are not null-terminated.
-struct string {
-pub:
-	str byteptr
-	len int
-}
-
-struct ustring {
-pub:
-	s     string
-	runes []int
-	len   int
-}
-
-// For C strings only
-fn C.strlen(s byteptr) int
-
-fn todo() { } 
-
-// Converts a C string to a V string
-pub fn tos(s byteptr, len int) string {
-	// This should never happen.
-	if isnil(s) {
-		panic('tos(): nil string')
-	}
-	return string {
-		str: s
-		len: len
-	}
-}
-
-pub fn tos_clone(s byteptr) string {
-	if isnil(s) {
-		panic('tos: nil string')
-		return string{}
-	}
-	len := strlen(s)
-	res := tos(s, len)
-	return res.clone()
-}
-
-// Same as `tos`, but calculates the length. Called by `string(bytes)` casts. 
-fn tos2(s byteptr) string {
-	if isnil(s) {
-		panic('tos2: nil string')
-		return string{}
-	}
-	len := C.strlen(s)
-	res := tos(s, len)
-	return res
-}
-
-pub fn (a string) clone() string {
-	mut b := string {
-		len: a.len
-		str: malloc(a.len + 1)
-	}
-	for i := 0; i < a.len; i++ {
-		b[i] = a[i]
-	}
-	b[a.len] = `\0`
-	return b
-}
-
-pub fn (s string) cstr() byteptr {
-	clone := s.clone()
-	return clone.str
-}
-
-pub fn (s string) replace(rep, with string) string {
-	if s.len == 0 || rep.len == 0 {
-		return ''
-	}
-	if !s.contains(rep) {
-		return s
-	}
-	// println('"$s" replace  "$rep" with "$with" rep.len=$rep.len')
-	// TODO PERF Allocating ints is expensive. Should be a stack array
-	// Get locations of all reps within this string
-	mut idxs := []int{}
-	// idxs := []int {
-	// 2, 8, 14
-	// }
-	for i := 0; i < s.len; i++ {
-		// Do we have the string we are looking for (rep) starting at i?
-		// Go thru all chars in rep and compare.
-		mut rep_i := 0
-		mut j := i
-		for rep_i < rep.len && j < s.len && s[j] == rep[rep_i] {
-			rep_i++
-			j++
-		}
-		if rep_i == rep.len {
-			idxs << i
-		}
-	}
-	// Dont change the string if there's nothing to replace
-	if idxs.len == 0 {
-		return s
-	}
-	// Now we know the number of replacements we need to do and we can calc the len of the new string
-	new_len := s.len + idxs.len * (with.len - rep.len)
-	mut b := malloc(new_len + 1)// add a newline just in case
-	// Fill the new string
-	mut idx_pos := 0
-	mut cur_idx := idxs[idx_pos]
-	mut b_i = 0
-	for i := 0; i < s.len; i++ {
-		// Reached the location of rep, replace it with "with"
-		if i == cur_idx {
-			for j := 0; j < with.len; j++ {
-				b[b_i] = with[j]
-				b_i++
-			}
-			// Skip the length of rep, since we just replaced it with "with"
-			i += rep.len - 1
-			// Go to the next index
-			idx_pos++
-			if idx_pos < idxs.len {
-				cur_idx = idxs[idx_pos]
-			}
-		}
-		// Rep doesnt start here, just copy
-		else {
-			b[b_i] = s[i]
-			b_i++
-		}
-	}
-	b[new_len] = `\0`
-	return tos(b, new_len)
-}
-
-pub fn (s string) int() int {
-	return C.atoi(s.str)
-}
-
-pub fn (s string) f32() f32 {
-	return C.atof(s.str)
-}
-
-// ==
-fn (s string) eq(a string) bool {
-	if isnil(s.str) {
-		panic('string.eq(): nil string')
-	}
-	if s.len != a.len {
-		return false
-	}
-	for i := 0; i < s.len; i++ {
-		if s[i] != a[i] {
-			return false
-		}
-	}
-	return true
-}
-
-// !=
-fn (s string) ne(a string) bool {
-	return !s.eq(a)
-}
-
-// s < a
-fn (s string) lt(a string) bool {
-	for i := 0; i < s.len; i++ {
-		if i >= a.len || s[i] > a[i] {
-			return false
-		}
-		else if s[i] < a[i] {
-			return true
-		}
-	}
-	if s.len < a.len {
-		return true
-	}
-	return false
-}
-
-// s <= a
-fn (s string) le(a string) bool {
-	return s.lt(a) || s.eq(a)
-}
-
-// s > a
-fn (s string) gt(a string) bool {
-	return !s.le(a)
-}
-
-// s >= a
-fn (s string) ge(a string) bool {
-	return !s.lt(a)
-}
-
-// TODO `fn (s string) + (a string)` ? To be consistent with operator overloading syntax.
-pub fn (s string) add(a string) string {
-	new_len := a.len + s.len
-	mut res := string {
-		len: new_len
-		str: malloc(new_len + 1)
-	}
-	for j := 0; j < s.len; j++ {
-		res[j] = s[j]
-	}
-	for j := 0; j < a.len; j++ {
-		res[s.len + j] = a[j]
-	}
-	res[new_len] = `\0`// V strings are not null terminated, but just in case
-	return res
-}
-
-pub fn (s string) split(delim string) []string {
-	// println('string split delim="$delim" s="$s"')
-	mut res := []string
-	if delim.len == 0 {
-		res << s
-		return res
-	}
-	if delim.len == 1 {
-		return s.split_single(delim[0])
-		// println('split 1 only')
-		// os.exit()
-	}
-	mut i := 0
-	mut start := 0// - 1
-	for i < s.len {
-		// printiln(i)
-		mut a := s[i] == delim[0]
-		mut j := 1
-		for j < delim.len && a {
-			a = a && s[i + j] == delim[j]
-			j++
-		}
-		last := i == s.len - 1
-		if a || last {
-			if last {
-				i++
-			}
-			mut val := s.substr(start, i)
-			// println('got it "$val" start=$start i=$i delim="$delim"')
-			if val.len > 0 {
-				// todo perf
-				// val now is '___VAL'. remove '___' from the start
-				if val.starts_with(delim) {
-					// println('!!')
-					val = val.right(delim.len)
-				}
-				res << val.trim_space()
-			}
-			start = i
-		}
-		i++
-	}
-	return res
-}
-
-pub fn (s string) split_single(delim byte) []string {
-	mut res := []string
-	if int(delim) == 0 {
-		res << s
-		return res
-	}
-	mut i := 0
-	mut start := 0
-	for i < s.len {
-		a := s[i] == delim
-		b := i == s.len - 1
-		if a || b {
-			if i == s.len - 1 {
-				i++
-			}
-			val := s.substr(start, i)
-			if val.len > 0 {
-				res << val.trim_space()
-			}
-			start = i + 1
-		}
-		i++
-	}
-	return res
-}
-
-pub fn (s string) split_into_lines() []string {
-	mut res := []string
-	if s.len == 0 {
-		return res
-	}
-	mut start := 0
-	for i := 0; i < s.len; i++ {
-		last := i == s.len - 1
-		if int(s[i]) == 10 || last {
-			if last {
-				i++
-			}
-			line := s.substr(start, i)
-			res << line
-			start = i + 1
-		}
-	}
-	return res
-}
-
-// 'hello'.left(2) => 'he'
-pub fn (s string) left(n int) string {
-	if n >= s.len {
-		return s
-	}
-	return s.substr(0, n)
-}
-
-pub fn (s string) right(n int) string {
-	if n >= s.len {
-		return ''
-	}
-	return s.substr(n, s.len)
-}
-
-// Because the string is immutable, it is safe for multiple strings to share
-// the same storage, so slicing s results in a new 2-word structure with a
-// potentially different pointer and length that still refers to the same byte
-// sequence. This means that slicing can be done without allocation or copying,
-// making string slices as efficient as passing around explicit indexes.
-// substr without allocations. Reuses memory and works great. BUT. This substring does not have
-// a \0 at the end, and it's not possible to add it. So if we have s = 'privet'
-// and substr := s.substr_fast(1, 4) ('riv')
-// puts(substr.str) will print 'rivet'
-// Avoid using C functions with these substrs!
-pub fn (s string) substr(start, end int) string {
-	/*
-	if start > end || start >= s.len || end > s.len || start < 0 || end < 0 {
-		panic('substr($start, $end) out of bounds (len=$s.len)')
-		return ''
-	}
-*/
-	if start >= s.len {
-		return ''
-	}
-	len := end - start
-	res := string {
-		str: s.str + start
-		len: len
-	}
-	return res
-}
-
-// KMP search
-pub fn (s string) index(p string) int {
-	if p.len > s.len {
-		return -1
-	}
-	mut prefix := [0]
-	mut j := 0
-	for i := 1; i < p.len; i++ {
-		for p[j] != p[i] && j > 0 {
-			j = prefix[j - 1]
-		}
-		if p[j] == p[i] {
-			j++
-		}
-		prefix << j
-	}
-	j = 0
-	for i := 0; i < s.len; i++ {
-		for p[j] != s[i] && j > 0 {
-			j = prefix[j - 1]
-		}
-		if p[j] == s[i] {
-			j++
-		}
-		if j == p.len {
-			prefix.free()
-			return i - p.len + 1
-		}
-	}
-	prefix.free()
-	return -1
-}
-
-pub fn (s string) last_index(p string) int {
-	if p.len > s.len {
-		return -1
-	}
-	mut i := s.len - p.len
-	for i >= 0 {
-		mut j := 0
-		for j < p.len && s[i + j] == p[j] {
-			j++
-		}
-		if j == p.len {
-			return i
-		}
-		i--
-	}
-	return -1
-}
-
-pub fn (s string) index_after(p string, start int) int {
-	if p.len > s.len {
-		return -1
-	}
-	mut strt := start
-	if start < 0 {
-		strt = 0
-	}
-	if start >= s.len {
-		return -1
-	}
-	mut i := strt
-	for i < s.len {
-		mut j := 0
-		mut ii := i
-		for j < p.len && s[ii] == p[j] {
-			j++
-			ii++
-		}
-		if j == p.len {
-			return i
-		}
-		i++
-	}
-	return -1
-}
-
-pub fn (s string) contains(p string) bool {
-	res := s.index(p) > 0 - 1
-	return res
-}
-
-pub fn (s string) starts_with(p string) bool {
-	res := s.index(p) == 0
-	return res
-}
-
-pub fn (s string) ends_with(p string) bool {
-	if p.len > s.len {
-		return false
-	}
-	res := s.last_index(p) == s.len - p.len
-	return res
-}
-
-// TODO only works with ASCII
-pub fn (s string) to_lower() string {
-	mut b := malloc(s.len)// TODO + 1 ??
-	for i := 0; i < s.len; i++ {
-		b[i] = C.tolower(s.str[i])
-	}
-	return tos(b, s.len)
-}
-
-pub fn (s string) to_upper() string {
-	mut b := malloc(s.len)// TODO + 1 ??
-	for i := 0; i < s.len; i++ {
-		b[i] = C.toupper(s.str[i])
-	}
-	return tos(b, s.len)
-}
-
-// 'hey [man] how you doin'
-// find_between('[', ']') == 'man'
-pub fn (s string) find_between(start, end string) string {
-	start_pos := s.index(start)
-	if start_pos == -1 {
-		return ''
-	}
-	// First get everything to the right of 'start'
-	val := s.right(start_pos + start.len)
-	end_pos := val.index(end)
-	if end_pos == -1 {
-		return val
-	}
-	return val.left(end_pos)
-}
-
-// TODO generic
-pub fn (ar[]string) contains(val string) bool {
-	for s in ar {
-		if s == val {
-			return true
-		}
-	}
-	return false
-}
-
-// TODO generic
-pub fn (ar[]int) contains(val int) bool {
-	for i, s in ar {
-		if s == val {
-			return true
-		}
-	}
-	return false
-}
-
-/*
-pub fn (a[]string) to_c() voidptr {
-	char ** res = malloc(sizeof(char*) * a.len);
-	for i := 0; i < a.len; i++ {
-		val := a[i]
-		# res[i] = val.str;
-	}
-	return res;
-	return 0
-}
-*/
-
-fn is_space(c byte) bool {
-	return C.isspace(c)
-}
-
-pub fn (c byte) is_space() bool {
-	return is_space(c)
-}
-
-pub fn (s string) trim_space() string {
-	if s == '' {
-		return ''
-	}
-	// println('TRIM SPACE "$s"')
-	mut i := 0
-	for i < s.len && is_space(s[i]) {
-		i++
-	}
-	mut res := s.right(i)
-	mut end := res.len - 1
-	for end >= 0 && is_space(res[end]) {
-		// C.printf('end=%d c=%d %c\n', end, res.str[end])
-		end--
-	}
-	res = res.left(end + 1)
-	// println('after SPACE "$res"')
-	return res
-}
-
-pub fn (s string) trim(c byte) string {
-	if s == '' {
-		return ''
-	}
-	mut i := 0
-	for i < s.len && c == s[i] {
-		i++
-	}
-	mut res := s.right(i)
-	mut end := res.len - 1
-	for end >= 0 && c == res[end] {
-		end--
-	}
-	res = res.left(end + 1)
-	return res
-}
-
-pub fn (s string) trim_left(cutset string) string {
-	mut start := s.index(cutset)
-	if start != 0 {
-		return s
-	}
-	for start < s.len - 1 && s[start] == cutset[0] {
-		start++
-	}
-	return s.right(start)
-}
-
-pub fn (s string) trim_right(cutset string) string {
-	pos := s.last_index(cutset)
-	if pos == -1 {
-		return s
-	}
-	return s.left(pos)
-}
-
-// fn print_cur_thread() {
-// //C.printf("tid = %08x \n", pthread_self());
-// }
-fn compare_strings(a, b *string) int {
-	if a.lt(b) {
-		return -1
-	}
-	if a.gt(b) {
-		return 1
-	}
-	return 0
-}
-
-fn compare_strings_by_len(a, b *string) int {
-	if a.len < b.len {
-		return -1
-	}
-	if a.len > b.len {
-		return 1
-	}
-	return 0
-}
-
-fn compare_lower_strings(a, b *string) int {
-	aa := a.to_lower()
-	bb := b.to_lower()
-	return compare_strings(aa, bb)
-}
-
-pub fn (s mut []string) sort() {
-	s.sort_with_compare(compare_strings)
-}
-
-pub fn (s mut []string) sort_ignore_case() {
-	s.sort_with_compare(compare_lower_strings)
-}
-
-pub fn (s mut []string) sort_by_len() {
-	s.sort_with_compare(compare_strings_by_len)
-}
-
-pub fn (s string) ustring() ustring {
-	mut res := ustring {
-		s: s
-		// runes will have at least s.len elements, save reallocations
-		// TODO use VLA for small strings?
-		runes: new_array(0, s.len, sizeof(int))
-	}
-	for i := 0; i < s.len; i++ {
-		char_len := utf8_char_len(s.str[i])
-		//# char_len =UTF8_CHAR_LEN(s.str[i]);
-		// println('cl=$char_len')
-		res.runes << i
-		i += char_len - 1
-		res.len++
-	}
-	return res
-}
-
-// A hack that allows to create ustring without allocations.
-// It's called from functions like draw_text() where we know that the string is going to be freed
-// right away. Uses global buffer for storing runes []int array.
-__global g_ustring_runes []int
-pub fn (s string) ustring_tmp() ustring {
-	mut res := ustring {
-		s: s
-		runes: 0
-	}
-	res.runes = g_ustring_runes
-	res.runes.len = s.len
-	mut j := 0
-	for i := 0; i < s.len; i++ {
-		//char_len := 0
-		//# char_len =UTF8_CHAR_LEN(s.str[i]);
-		char_len := utf8_char_len(s.str[i])
-		res.runes[j] = i
-		j++
-		i += char_len - 1
-		res.len++
-	}
-	return res
-}
-
-fn (u ustring) substr(start, end int) string {
-	// println('substr($start, $end)')
-	// println('runes=')
-	// println(u.runes)
-	start = u.runes[start]
-	// handle last char
-	if end >= u.runes.len {
-		end = u.s.len
-	}
-	else {
-		end = u.runes[end]
-	}
-	// println('fast $start, $end')
-	return u.s.substr(start, end)
-}
-
-fn (u ustring) left(pos int) string {
-	return u.substr(0, pos)
-}
-
-fn (u ustring) right(pos int) string {
-	return u.substr(pos, u.len)
-}
-
-fn (s string) at(idx int) byte {
-	if idx < 0 || idx >= s.len {
-		panic('string index out of range: $idx / $s.len')
-	}
-	return s.str[idx]
-}
-
-pub fn (u ustring) at(idx int) string {
-	return u.substr(idx, idx + 1)
-}
-
-fn (u ustring) free() {
-	u.runes.free()
-}
-
-fn abs(a int) int {
-	if a >= 0 {
-		return a
-	}
-	return -a
-}
-
-pub fn (c byte) is_digit() bool {
-	return c >= `0` && c <= `9`
-}
-
-pub fn (c byte) is_letter() bool {
-	return (c >= `a` && c <= `z`) || (c >= `A` && c <= `Z`)
-}
-
-pub fn (s string) free() {
-	C.free(s.str)
-}
-
-fn (arr[]string) free() {
-	for s in arr {
-		s.free()
-	}
-	C.free(arr.data)
-}
-
-// all_before('23:34:45.234', '.') == '23:34:45'
-pub fn (s string) all_before(dot string) string {
-	pos := s.index(dot)
-	if pos == -1 {
-		return s
-	}
-	return s.left(pos)
-}
-
-pub fn (s string) all_before_last(dot string) string {
-	pos := s.last_index(dot)
-	if pos == -1 {
-		return s
-	}
-	return s.left(pos)
-}
-
-pub fn (s string) all_after(dot string) string {
-	pos := s.last_index(dot)
-	if pos == -1 {
-		return s
-	}
-	return s.right(pos + dot.len)
-}
-
-// fn (s []string) substr(a, b int) string {
-// return join_strings(s.slice_fast(a, b))
-// }
-pub fn (a[]string) join(del string) string {
-	if a.len == 0 {
-		return ''
-	}
-	mut len := 0
-	for i, val in a {
-		len += val.len + del.len
-	}
-	len -= del.len
-	// Allocate enough memory
-	mut res := ''
-	res.len = len
-	res.str = malloc(res.len + 1)
-	mut idx := 0
-	// Go thru every string and copy its every char one by one
-	for i, val in a {
-		for j := 0; j < val.len; j++ {
-			c := val[j]
-			res.str[idx] = val.str[j]
-			idx++
-		}
-		// Add del if it's not last
-		if i != a.len - 1 {
-			for k := 0; k < del.len; k++ {
-				res.str[idx] = del.str[k]
-				idx++
-			}
-		}
-	}
-	res.str[res.len] = `\0`
-	return res
-}
-
-pub fn (s[]string) join_lines() string {
-	return s.join('\n')
-}
-
-pub fn (s string) reverse() string {
-	mut res := string {
-		len: s.len
-		str: malloc(s.len + 1)
-	}
-
-	for i := s.len - 1; i >= 0; i-- {
-        res[s.len-i-1] = s[i]
-	}
-
-	return res
-}
-
-// 'hello'.limit(2) => 'he'
-// 'hi'.limit(10) => 'hi'
-pub fn (s string) limit(max int) string {
-	u := s.ustring()
-	if u.len <= max {
-		return s
-	}
-	return u.substr(0, max)
-}
-
-// TODO is_white_space()
-pub fn (c byte) is_white() bool {
-	i := int(c)
-	return i == 10 || i == 32 || i == 9 || i == 13 || c == `\r`
-}
-
-// TODO move this to strings.repeat()
-pub fn repeat_char(c byte, n int) string {
-	if n <= 0 {
-		return ''
-	}
-	mut arr := malloc(n + 1)
-	for i := 0; i < n; i++ {
-		arr[i] = c
-	}
-	arr[n] = `\0`
-	return tos(arr, n)
-}
-
-pub fn (s string) hash() int {
-	mut hash := int(0)
-	for i := 0; i < s.len; i++ {
-		// if key == 'Content-Type' {
-		// println('$i) $hash')
-		// }
-		hash = hash * int(31) + int(s.str[i])
-	}
-	return hash
-}
-

builtin/string_builder.v

@@ -1,39 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-module builtin
-
-struct StringBuilder {
-	buf []byte
-	len int
-}
-
-pub fn new_string_builder(initial_size int) StringBuilder {
-	return StringBuilder {
-		buf: new_array(0, initial_size, sizeof(byte))
-	}
-}
-
-pub fn (b mut StringBuilder) write(s string) {
-	b.buf._push_many(s.str, s.len)
-	b.len += s.len
-}
-
-pub fn (b mut StringBuilder) writeln(s string) {
-	b.buf._push_many(s.str, s.len)
-	b.buf << `\n`
-	b.len += s.len + 1
-}
-
-pub fn (b StringBuilder) str() string {
-	return tos(b.buf.data, b.len)
-}
-
-pub fn (b StringBuilder) cut(n int) {
-	b.len -= n
-}
-
-pub fn (b mut StringBuilder) free() {
-	C.free(b.buf.data)
-}

builtin/string_test.v

@@ -1,293 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-fn test_add() {
-	mut a := 'a'
-	a += 'b'
-	assert a==('ab')
-	a = 'a'
-	for i := 1; i < 1000; i++ {
-		a += 'b'
-	}
-	assert a.len == 1000
-	assert a.ends_with('bbbbb')
-	a += '123'
-	assert a.ends_with('3')
-}
-
-fn test_ends_with() {
-	a := 'browser.v'
-	assert a.ends_with('.v')
-}
-
-fn test_between() {
-	 s := 'hello [man] how you doing'
-	assert s.find_between('[', ']') == 'man'
-}
-
-fn test_compare() {
-	a := 'Music'
-	b := 'src'
-	assert b>=(a)
-}
-
-fn test_lt() {
-	a := ''
-	b := 'a'
-	c := 'a'
-	d := 'b'
-	e := 'aa'
-	f := 'ab'
-	assert a<(b)
-	assert !(b<c)
-	assert c<(d)
-	assert !(d<e)
-	assert c<(e)
-	assert e<(f)
-}
-
-fn test_ge() {
-	a := 'aa'
-	b := 'aa'
-	c := 'ab'
-	d := 'abc'
-	e := 'aaa'
-	assert b>=(a)
-	assert c>=(b)
-	assert d>=(c)
-	assert !(c>=d) 
-	assert e>=(a)
-}
-
-fn test_compare_strings() {
-	a := 'aa'
-	b := 'aa'
-	c := 'ab'
-	d := 'abc'
-	e := 'aaa'
-	assert compare_strings(a, b) == 0
-	assert compare_strings(b, c) == -1
-	assert compare_strings(c, d) == -1
-	assert compare_strings(d, e) == 1
-	assert compare_strings(a, e) == -1
-	assert compare_strings(e, a) == 1
-}
-
-fn test_sort() {
-	mut vals := [
-		'arr', 'an', 'a', 'any'
-	]
-	len := vals.len
-	vals.sort()
-	assert len == vals.len
-	assert vals[0] == 'a'
-	assert vals[1] == 'an'
-	assert vals[2] == 'any'
-	assert vals[3] == 'arr'
-}
-
-fn test_split() {
-	mut s := 'volt/twitch.v:34'
-	mut vals := s.split(':')
-	assert vals.len == 2
-	assert vals[0]== 'volt/twitch.v'
-	assert vals[1]== '34'
-	// /////////
-	s = '2018-01-01z13:01:02'
-	vals = s.split('z')
-	assert vals.len == 2
-	assert vals[0]=='2018-01-01'
-	assert vals[1]== '13:01:02'
-	// /////////////
-	s = '4627a862c3dec29fb3182a06b8965e0025759e18___1530207969___blue'
-	vals = s.split('___')
-	assert vals.len == 3
-	assert vals[0]== '4627a862c3dec29fb3182a06b8965e0025759e18'
-	assert vals[1]=='1530207969'
-	assert vals[2]== 'blue'
-}
-
-fn test_trim_space() {
-	a := ' a '
-	assert a.trim_space() == 'a'
-	code := '
-
-fn main() {
-        println(2)
-}
-
-'
-	code_clean := 'fn main() {
-        println(2)
-}'
-	assert code.trim_space() == code_clean
-}
-
-fn test_join() {
-	mut strings := [ 'a', 'b', 'c' ]
-	mut s := strings.join(' ')
-	assert s == 'a b c'
-	strings = ['one
-two ',
-	'three! 
-four!']
-	s = strings.join(' ')
-	assert s.contains('one') && s.contains('two ') && s.contains('four')
-}
-
-fn test_clone() {
-	mut a := 'a'
-	a += 'a'
-	a += 'a'
-	mut b := a
-	mut c := a.clone()
-	assert c == a
-	assert c == 'aaa'
-	assert b == 'aaa'
-}
-
-fn test_replace() {
-	a := 'hello man!'
-	mut b := a.replace('man', 'world')
-	assert b==('hello world!')
-	b = b.replace('!', '')
-	assert b==('hello world')
-	b = b.replace('h', 'H')
-	assert b==('Hello world')
-	b = b.replace('kek', 'lul')
-	assert b==('Hello world')
-	s := 'hey man how are you'
-	assert s.replace('man ', '') == 'hey how are you'
-	lol := 'lol lol lol'
-	assert lol.replace('lol', 'kek') == 'kek kek kek'
-	b = 'oneBtwoBBthree'
-	assert b.replace('B', '') == 'onetwothree'
-	b = '**char'
-	assert b.replace('*char', 'byteptr') == '*byteptr'
-}
-
-fn test_itoa() {
-	num := 777
-	assert num.str() == '777'
-	big := 7779998
-	assert big.str() == '7779998'
-	a := 3
-	assert a.str() == '3'
-	b := 5555
-	assert b.str() == '5555'
-	zero := 0
-	assert zero.str() == '0'
-	neg := -7
-	assert neg.str() == '-7'
-}
-
-fn test_reassign() {
-	a := 'hi'
-	mut b := a
-	b += '!'
-	assert a == 'hi'
-	assert b == 'hi!'
-}
-
-fn test_runes() {
-	s := 'привет'
-	assert s.len == 12
-	s2 := 'privet'
-	assert s2.len == 6
-	u := s.ustring()
-	assert u.len == 6
-	assert s2.substr(1, 4).len == 3
-	assert s2.substr(1, 4) == 'riv'
-	assert u.substr(1, 4).len == 6
-	assert u.substr(1, 4) == 'рив'
-	assert s2.substr(1, 2) == 'r'
-	assert u.substr(1, 2) == 'р'
-	assert s2.ustring().at(1) == 'r'
-	assert u.at(1) == 'р'
-	// ///////
-	first := u.at(0)
-	last := u.at(u.len - 1)
-	assert first.len == 2
-	assert last.len == 2
-}
-
-fn test_lower() {
-	mut s := 'A'
-	assert s.to_lower() == 'a'
-	assert s.to_lower().len == 1
-	s = 'HELLO'
-	assert s.to_lower() == 'hello'
-	assert s.to_lower().len == 5
-	s = 'Aloha'
-	assert s.to_lower() == 'aloha'
-	s = 'Have A nice Day!'
-	assert s.to_lower() == 'have a nice day!'
-	s = 'hi'
-	assert s.to_lower() == 'hi'
-}
-
-fn test_left_right() {
-	s := 'ALOHA'
-	assert s.left(3) == 'ALO'
-	assert s.right(3) == 'HA'
-	u := s.ustring()
-	assert u.left(3) == 'ALO'
-	assert u.right(3) == 'HA'
-}
-
-fn test_contains() {
-	s := 'view.v'
-	assert s.contains('vi')
-	assert !s.contains('random')
-}
-
-fn test_arr_contains() {
-	a := ['a', 'b', 'c']
-	assert a.contains('b')
-	ints := [1, 2, 3]
-	assert ints.contains(2)
-}
-
-fn test_to_num() {
-	s := '7'
-	assert s.int() == 7
-	f := '71.5 hasdf'
-	assert f.f32() == 71.5
-	b := 1.52345
-	mut a := '${b:.03f}'
-	assert a == '1.523'
-	num := 7
-	a = '${num:03d}'
-	vals := ['9']
-	assert vals[0].int() == 9
-}
-
-fn test_hash() {
-	s := '10000'
-	assert s.hash() == 46730161
-	s2 := '24640'
-	assert s2.hash() == 47778736
-	s3 := 'Content-Type'
-	assert s3.hash() == 949037134
-	s4 := 'bad_key'
-	assert s4.hash() == -346636507
-	s5 := '24640'
-	// From a map collision test
-	assert s5.hash() % ((1 << 20) -1) == s.hash() % ((1 << 20) -1)
-	assert s5.hash() % ((1 << 20) -1) == 592861
-}
-
-fn test_trim_left() {
-	mut s := 'module main'
-	assert s.trim_left(' ') == 'module main'
-	s = ' module main'
-	assert s.trim_left(' ') == 'module main'
-}
-
-fn test_all_after() {
-	s := 'fn hello'
-	q := s.all_after('fn ')
-	assert q == 'hello'
-}
-

builtin/utf8.v

@@ -1,93 +0,0 @@
-// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-
-module builtin
-
-pub fn utf8_char_len(b byte) int { 
-	return (( 0xe5000000 >> (( b >> 3 ) & 0x1e )) & 3 ) + 1 
-}
-
-// Convert utf32 to utf8
-// utf32 == Codepoint
-pub fn utf32_to_str(code u32) string {
-	icode := int(code) 	//Prevents doing casts everywhere
-  mut buffer := malloc(5)
-	if icode <= 127 /* 0x7F */ {
-		buffer[0] = icode
-		return tos(buffer, 1)
-	}
-	if (icode <= 2047 /* 0x7FF */) {
-		buffer[0] = 192 /*0xC0*/ | (icode >> 6)                   /* 110xxxxx */
-		buffer[1] = 128 /*0x80*/ | (icode & 63 /*0x3F*/)          /* 10xxxxxx */
-		return tos(buffer, 2)
-	}
-	if (icode <= 65535 /* 0xFFFF */) {
-		buffer[0] = 224 /*0xE0*/ | (icode >> 12)                  /* 1110xxxx */
-		buffer[1] = 128 /*0x80*/ | ((icode >> 6) & 63 /*0x3F*/)   /* 10xxxxxx */
-		buffer[2] = 128 /*0x80*/ | (icode & 63 /*0x3F*/)          /* 10xxxxxx */
-		return tos(buffer, 3)
-	}
-	if (icode <= 1114111 /* 0x10FFFF */) {
-		buffer[0] = 240 /*0xF0*/ | (icode >> 18)                  /* 11110xxx */
-		buffer[1] = 128 /*0x80*/ | ((icode >> 12) & 63 /*0x3F*/)  /* 10xxxxxx */
-		buffer[2] = 128 /*0x80*/ | ((icode >> 6) & 63 /*0x3F*/)   /* 10xxxxxx */
-		buffer[3] = 128 /*0x80*/ | (icode & 63 /*0x3F*/)          /* 10xxxxxx */
-		return tos(buffer, 4)
-	}
-	return ''
-}
-
-// TODO copypasta
-pub fn utf32_to_str_no_malloc(code u32, buf voidptr) string {
-	icode := int(code) 	//Prevents doing casts everywhere
-  mut buffer := byteptr(buf)
-	if icode <= 127 /* 0x7F */ {
-		buffer[0] = icode
-		return tos(buffer, 1)
-	}
-	if (icode <= 2047 /* 0x7FF */) {
-		buffer[0] = 192 /*0xC0*/ | (icode >> 6)                   /* 110xxxxx */
-		buffer[1] = 128 /*0x80*/ | (icode & 63 /*0x3F*/)          /* 10xxxxxx */
-		return tos(buffer, 2)
-	}
-	if (icode <= 65535 /* 0xFFFF */) {
-		buffer[0] = 224 /*0xE0*/ | (icode >> 12)                  /* 1110xxxx */
-		buffer[1] = 128 /*0x80*/ | ((icode >> 6) & 63 /*0x3F*/)   /* 10xxxxxx */
-		buffer[2] = 128 /*0x80*/ | (icode & 63 /*0x3F*/)          /* 10xxxxxx */
-		return tos(buffer, 3)
-	}
-	if (icode <= 1114111 /* 0x10FFFF */) {
-		buffer[0] = 240 /*0xF0*/ | (icode >> 18)                  /* 11110xxx */
-		buffer[1] = 128 /*0x80*/ | ((icode >> 12) & 63 /*0x3F*/)  /* 10xxxxxx */
-		buffer[2] = 128 /*0x80*/ | ((icode >> 6) & 63 /*0x3F*/)   /* 10xxxxxx */
-		buffer[3] = 128 /*0x80*/ | (icode & 63 /*0x3F*/)          /* 10xxxxxx */
-		return tos(buffer, 4)
-	}
-	return ''
-}
-
-// Convert utf8 to utf32
-pub fn (_rune string) utf32_code() int {
-	if _rune.len == 0 {
-		return 0
-	}
-	// save ASC symbol as is
-	if _rune.len == 1 {
-		return int(_rune[0])
-	}
-	mut b := byte(int(_rune[0]))
-	// TODO should be
-	// res := int( rune[0] << rune.len)
-	b = b << _rune.len
-	mut res := int(b)
-	mut shift := 6 - _rune.len
-	for i := 1; i < _rune.len; i++ {
-		c := int(_rune[i])
-		res = res << shift
-		res |= c & 63 /* 0x3f */
-		shift = 6
-	}
-	return res
-}
-

cmd/tools/bench/wyhash.v

@@ -0,0 +1,53 @@
+module main
+
+import hash.fnv1a
+import hash.wyhash
+import rand
+import time
+
+fn main() {
+	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 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)
+	}
+	println('Hashing each of the generated strings...')
+	t0 := time.ticks()
+	mut start_pos := 0
+	for len in str_lens {
+		end_pos := start_pos + len
+		str := string(bytepile[start_pos..end_pos],len)
+		wyhash.wyhash_c(&str.str, u64(str.len), 1)
+		start_pos = end_pos
+	}
+	t1 := time.ticks()
+	d1 := t1 - t0
+	println(' * wyhash4 C: ${d1}ms')
+	start_pos = 0
+	for len in str_lens {
+		end_pos := start_pos + len
+		str := string(bytepile[start_pos..end_pos],len)
+		wyhash.sum64_string(str, 1)
+		start_pos = end_pos
+	}
+	t2 := time.ticks()
+	d2 := t2 - t1
+	println(' * wyhash4: ${d2}ms')
+	start_pos = 0
+	for len in str_lens {
+		end_pos := start_pos + len
+		str := string(bytepile[start_pos..end_pos],len)
+		fnv1a.sum64_string(str)
+		start_pos = end_pos
+	}
+	t3 := time.ticks()
+	d3 := t3 - t2
+	println(' * fnv1a64: ${d3}ms')
+}

cmd/tools/check-md.v

@@ -0,0 +1,31 @@
+module main
+
+import os
+
+const (
+	too_long_line_length = 100
+)
+
+fn main() {
+	files_paths := os.args[1..]
+	mut errors := 0
+	for file_path in files_paths {
+		real_path := os.real_path(file_path)
+		lines := os.read_lines(real_path) or {
+			continue
+		}
+		for i, line in lines {
+			if line.len > too_long_line_length {
+				eprintln('$real_path:${i+1}:${line.len+1}: line too long')
+				errors++
+			}
+		}
+	}
+	// TODO: uncomment this AFTER doc/docs.md line lengths are fixed
+	/*
+	if errors > 0 {
+		exit(1)
+	}
+	*/
+
+}

cmd/tools/check_os_api_parity.v

@@ -0,0 +1,126 @@
+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.wyhash', '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, 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 {
+				fnd := s as ast.FnDecl
+				if fnd.is_pub {
+					fn_signature := fnd.str(b.table)
+					fn_mod := fnd.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, api_os, mod_name, os_base, 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,86 @@
+// 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('git pull --rebase')
+	if ret != 0 {
+		println('failed to git pull')
+		return
+	}
+	mut commit_hash := exec('git rev-parse HEAD')
+	commit_hash = commit_hash[..7]
+	if !os.exists('table.html') {
+		os.create('table.html') or { panic(err) }
+	}
+	mut table := os.read_file('table.html') or { panic(err) }
+	// Do nothing if it's already been processed.
+	if table.contains(commit_hash) {
+		println('Commit $commit_hash has already been processed')
+		return
+	}
+	// Build an optimized V
+	println('Building vprod...')
+	exec('v -o $vdir/vprod -prod $vdir/cmd/v')
+	println('Measuring...')
+	diff1 := measure('$vdir/vprod -cc clang -o v.c $vdir/cmd/v')
+	diff2 := measure('$vdir/vprod -cc clang -o v2 $vdir/cmd/v')
+	diff3 := measure('$vdir/vprod -x64 $vdir/cmd/tools/1mil.v')
+	diff4 := measure('$vdir/vprod -cc clang $vdir/examples/hello_world.v')
+	//println('Building V took ${diff}ms')
+	commit_date := exec('git log -n1 --pretty="format:%at"')
+	message := exec('git log -n1 --pretty="format:%s"')
+	date := time.unix(commit_date.int())
+	mut out := os.create('table.html') or { panic(err) }
+	// Place the new row on top
+	table =
+'<tr>
+	<td>${date.format()}</td>
+	<td><a target=_blank href="https://github.com/vlang/v/commit/$commit_hash">$commit_hash</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') or { panic(err) }
+	footer := os.read_file('footer.html') or { panic(err) }
+	mut res := os.create('index.html') or { panic(err) }
+	res.writeln(header)
+	res.writeln(table)
+	res.writeln(footer)
+	res.close()
+}
+
+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) int {
+	println('Warming up...')
+	for _ in 0..3 {
+		exec(cmd)
+	}
+	println('Building...')
+	sw := time.new_stopwatch({})
+	exec(cmd)
+	return int(sw.elapsed().milliseconds())
+}

cmd/tools/fast/fast_main.js

@@ -0,0 +1,65 @@
+(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) > 50)
+                tr.children[vc].appendChild(createElement(result.vc));
+            if (Math.abs(result.vv) > 50)
+                tr.children[vv].appendChild(createElement(result.vv));
+            if (Math.abs(result.vf) > 50)
+                tr.children[vf].appendChild(createElement(result.vf));
+            if (Math.abs(result.vh) > 50)
+                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,52 @@
+<!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>
+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,19 @@
+fn main() {
+	println('fn println(a int) {}')
+	println('fn print(a string) {}')
+	for i in 0..100000 {
+		println('
+fn foo${i}() {
+	x := $i
+	mut a := x
+	a += 2
+	println(a)
+	a = 0
+	a = 1
+}
+')
+	}
+	//println('fn main() {foo1()} ')
+	println('fn main() { print("1m DONE") } ')
+
+}

cmd/tools/gen_vc.v

@@ -0,0 +1,395 @@
+// 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
+
+module main
+
+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)
+	}
+	// cmd mode
+	else {
+		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()
+}
+
+// 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,100 @@
+module scripting
+
+import os
+
+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 verbose_trace(label string, message string) {
+	if os.getenv('VERBOSE').len > 0 {
+		slabel := 'scripting.${label}'
+		println('# ${slabel:-25s} : $message')
+	}
+}
+
+pub fn verbose_trace_exec_result(x os.Result) {
+	if os.getenv('VERBOSE').len > 0 {
+		println('#   cmd.exit_code : ${x.exit_code.str():-4s}  cmd.output:')
+		println('# ----------------------------------- #')
+		mut lnum := 1
+		lines := x.output.split_into_lines()
+		for line in lines {
+			println('# ${lnum:3d}: $line')
+			lnum++
+		}
+		println('# ----------------------------------- #')
+	}
+}
+
+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 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,304 @@
+module testing
+
+import os
+import term
+import benchmark
+import sync
+import v.pref
+
+pub struct TestMessageHandler {
+mut:
+	messages []string
+pub mut:
+	message_idx int
+	mtx &sync.Mutex
+}
+
+pub struct TestSession {
+pub mut:
+	files         []string
+	skip_files    []string
+	vexe          string
+	vroot         string
+	vargs         string
+	failed        bool
+	benchmark     benchmark.Benchmark
+	show_ok_tests bool
+	message_handler &TestMessageHandler
+}
+
+pub fn (mut mh TestMessageHandler) append_message(msg string) {
+	mh.mtx.lock()
+	mh.messages << msg
+	mh.mtx.unlock()
+}
+
+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('-silent', '')
+	vexe := pref.vexe_path()
+	return TestSession{
+		vexe: vexe
+		vroot: os.dir(vexe)
+		skip_files: skip_files
+		vargs: vargs
+		show_ok_tests: !_vargs.contains('-silent')
+		message_handler: &TestMessageHandler(0)
+	}
+}
+
+pub fn (mut ts TestSession) init() {
+	ts.benchmark = benchmark.new_benchmark_no_cstep()
+}
+
+pub fn (mut ts TestSession) test() {
+	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
+	}
+	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.message_handler = &TestMessageHandler{
+		mtx: sync.new_mutex()
+	}
+	pool_of_test_runners.set_shared_context(ts)
+	pool_of_test_runners.work_on_pointers(remaining_files.pointers())
+	ts.benchmark.stop()
+	eprintln(term.h_divider('-'))
+}
+
+pub fn (mut m TestMessageHandler) display_message() {
+	m.mtx.lock()
+	defer {
+		m.messages.clear()
+		m.mtx.unlock()
+	}
+	for msg in m.messages {
+		m.message_idx++
+		eprintln(msg.
+			replace("TMP1", "${m.message_idx:1d}").
+			replace("TMP2", "${m.message_idx:2d}").
+			replace("TMP3", "${m.message_idx:3d}")
+		)
+	}
+}
+
+fn worker_trunner(mut p sync.PoolProcessor, idx int, thread_id int) voidptr {
+	mut ts := &TestSession(p.get_shared_context())
+	defer { ts.message_handler.display_message() }
+	tmpd := os.temp_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)
+	relative_file := dot_relative_file.replace(ts.vroot + os.path_separator, '').replace('./', '')
+	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) {
+		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}"'
+	// eprintln('>>> v cmd: $cmd')
+	ts.benchmark.step()
+	tls_bench.step()
+	if relative_file.replace('\\', '/') in ts.skip_files {
+	   ts.benchmark.skip()
+	   tls_bench.skip()
+	   ts.message_handler.append_message(tls_bench.step_message_skip(relative_file))
+	   return sync.no_result
+	}
+	if show_stats {
+		ts.message_handler.append_message(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.message_handler.append_message(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.message_handler.append_message(tls_bench.step_message_fail('${relative_file}\n$r.output\n'))
+		}
+		else {
+			ts.benchmark.ok()
+			tls_bench.ok()
+			if ts.show_ok_tests {
+				ts.message_handler.append_message(tls_bench.step_message_ok(relative_file))
+			}
+		}
+	}
+	if os.exists(generated_binary_fpath) {
+		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 v_build_failing_skipped(zargs string, folder string, skipped []string) bool {
+	main_label := 'Building $folder ...'
+	finish_label := 'building $folder'
+	vexe := pref.vexe_path()
+	parent_dir := os.dir(vexe)
+	vlib_should_be_present(parent_dir)
+	vargs := zargs.replace(vexe, '')
+	eheader(main_label)
+	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{}
+	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
+				}
+			}
+			mains << f
+		}
+	}
+	session.files << mains
+	session.skip_files << skipped
+	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)
+	testing.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, '-'))
+}

cmd/tools/modules/vgit/vgit.v

@@ -0,0 +1,184 @@
+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 := vgit.line_to_timestamp_and_commit(vline)
+	vgit.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 := vgit.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 := vgit.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, vgit.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, vgit.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 {
+		vgit.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','internal','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,112 @@
+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'
+)
+
+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')
+	}
+	println('#################  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)
+	println('#     v commit hash: $context.commit_v_hash')
+	println('#   checkout folder: $context.path_v')
+	if context.cmd_to_run.len > 0 {
+		cmdres := os.exec(context.cmd_to_run) or {
+			panic(err)
+		}
+		println('#           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,209 @@
+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.
+  '
+)
+
+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,5 @@
+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

cmd/tools/preludes/live_main.v

@@ -0,0 +1,5 @@
+module main
+
+// This prelude is loaded in every v program compiled with -live,
+// but only for the main executable.
+import live.executable

cmd/tools/preludes/live_shared.v

@@ -0,0 +1,5 @@
+module main
+
+// This prelude is loaded in every v program compiled with -live,
+// but only for the shared library.
+import live.shared

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,41 @@
+module main
+
+import os
+// //////////////////////////////////////////////////////////////////
+// / 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) {
+	// color_on := 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('__', '.')
+	eprintln('')
+	eprintln('$final_filename:${i.line_nr+1}: failed assert in ${final_funcname}')
+	eprintln('Source  : ${i.src}')
+	if i.op.len > 0 && i.op != 'call' {
+		eprintln('   left value: ${i.llabel} = ${i.lvalue}')
+		if i.rlabel == i.rvalue {
+			eprintln('  right value: $i.rlabel')
+		}
+		else {
+			eprintln('  right value: ${i.rlabel} = ${i.rvalue}')
+		}
+	}
+}
+
+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,89 @@
+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/vbin2v.v

@@ -0,0 +1,122 @@
+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 += '\n'
+	header_s += 'const (\n'
+
+	return header_s
+}
+
+fn (context Context) footer() string {
+	return ')\n'
+}
+
+fn (context Context) file2v(file string) string {
+	mut sb := strings.new_builder(1000)
+	fname := os.file_name(file)
+	fname_no_dots := fname.replace('.', '_')
+	byte_name := '${context.prefix}${fname_no_dots}'
+	fbytes := os.read_bytes(file) or {
+		eprintln('Error: $err')
+		return ''
+	}
+	fbyte := fbytes[0]
+	sb.write('  ${byte_name}_len = ${fbytes.len}\n')
+	sb.write('  ${byte_name} = [ byte(${fbyte}), \n  ')
+	for i := 1; i < fbytes.len; i++ {
+		b := int(fbytes[i]).str()
+		sb.write('${b:4s}, ')
+		if 0 == i % 16 {
+			sb.write('\n  ')
+		}
+	}
+	sb.write('\n]!!\n')
+	sb.write('\n')
+
+	return sb.str()
+}
+
+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.ends_with('.v') {
+		context.write_file += '.v'
+	}
+	if context.write_file.len > 0 {
+		mut out_file := os.create(context.write_file) or { panic(err) }
+		out_file.write(context.header())
+		for file in real_files {
+			out_file.write(context.file2v(file))
+		}
+		out_file.write(context.footer())
+	}
+	else {
+		println(context.header())
+		for file in real_files {
+			println(context.file2v(file))
+		}
+		println(context.footer())
+	}
+}

cmd/tools/vbuild-examples.v

@@ -0,0 +1,19 @@
+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,18 @@
+module main
+
+import os
+import testing
+import v.util
+
+fn main() {
+	args := os.args
+	args_string := args[1..].join(' ')
+	// TODO: fix cmd/tools/gen_vc.v / vweb too
+	skips := [
+		'cmd/tools/gen_vc.v'
+	]
+	util.ensure_modules_for_all_tools_are_installed('-v' in args)
+	if testing.v_build_failing_skipped(args_string.all_before('build-tools'), 'cmd/tools', skips) {
+		exit(1)
+	}
+}

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/vcreate.v

@@ -0,0 +1,159 @@
+// 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.
+module main
+
+import os
+
+struct Create {
+mut:
+	name        string
+	description string
+}
+
+fn cerror(e string){
+	eprintln('\nerror: $e')
+}
+
+fn vmod_content(name, desc string) string {
+	return  [
+		'Module {',
+		'	name: \'${name}\',',
+		'	description: \'${desc}\',',
+		'	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 [
+		'main',
+		'$name',
+		'*.so',
+		'*.dylib',
+		'*.dll'
+	].join('\n')
+}
+
+fn (c &Create)create_vmod() {
+	mut vmod := os.create('${c.name}/v.mod') or {
+		cerror(err)
+		exit(1)
+	}
+	vmod.write(vmod_content(c.name, c.description))
+	vmod.close()
+}
+
+fn (c &Create)create_main() {
+	mut main := os.create('${c.name}/${c.name}.v') or {
+		cerror(err)
+		exit(2)
+	}
+	main.write(main_content())
+	main.close()
+}
+
+fn (c &Create)init_vmod() {
+	mut vmod := os.create('v.mod') or {
+		cerror(err)
+		exit(1)
+	}
+	vmod.write(vmod_content(c.name, c.description))
+	vmod.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(gen_gitignore(c.name))
+			fl.close()
+		}
+	}
+}
+
+fn (c &Create)init_main() {
+	// The file already exists, don't over-write anything.
+	// Searching in the 'src' directory allows flexibility user module structure
+	if os.exists('${c.name}.v') || os.exists('src/${c.name}.v') {
+		return
+	}
+	mut main := os.create('${c.name}.v') or {
+		cerror(err)
+		exit(2)
+	}
+	main.write(main_content())
+	main.close()
+}
+
+fn create() {
+	mut c := Create{}
+
+	print('Input your project name: ')
+	c.name = os.get_line()
+
+	if os.is_dir(c.name) {
+		cerror('${c.name} folder already exists')
+		exit(3)
+	}
+
+	print('Input your project description: ')
+	c.description = os.get_line()
+
+	println('Initialising ...')
+
+	os.mkdir(c.name) or {
+		panic(err)
+	}
+	c.create_vmod()
+	c.create_main()
+	c.create_git_repo(c.name)
+}
+
+fn init() {
+	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.init_vmod()
+	c.init_main()
+	c.create_git_repo('')
+	println("Change your module's description in `v.mod`")
+}
+
+fn main() {
+	if 'new' == os.args[1] {
+		create()
+	} else if 'init' == os.args[1] {
+		init()
+	} 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,576 @@
+: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: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.9rem;
+  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: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/vdoc.v

@@ -0,0 +1,895 @@
+module main
+
+import markdown
+import net
+import net.urllib
+import os
+import os.cmdline
+import time
+import strings
+import v.doc
+import v.scanner
+import v.table
+import v.token
+import v.vmod
+
+enum HighlightTokenTyp {
+	unone
+	boolean
+	builtin
+	char
+	comment
+	function
+	keyword
+	name
+	number
+	operator
+	punctuation
+	string
+	symbol
+}
+
+const (
+	css_js_assets   = ['doc.css', 'normalize.css' 'doc.js']
+	allowed_formats = ['md', 'markdown', 'json', 'text', 'stdout', 'html', 'htm']
+	exe_path        = os.executable()
+	exe_dir         = os.dir(exe_path)
+	res_path        = os.join_path(exe_dir, 'vdoc-resources')
+	vexe_path       = os.base_dir(@VEXE)
+	html_content    = '
+	<!DOCTYPE html>
+	<html lang="en">
+	<head>
+		<meta charset="UTF-8">
+		<meta http-equiv="x-ua-compatible" content="IE=edge" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0">
+		<title>{{ title }} | vdoc</title>	
+		<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;500;700&display=swap" rel="stylesheet">
+		{{ head_assets }}
+	</head>
+	<body>
+		<div id="page">
+			<header class="doc-nav hidden">
+				<div class="heading-container">
+					<div class="heading">
+						<input type="text" id="search" placeholder="Search...">
+						<div class="module">{{ head_name }}</div>
+						<div class="toggle-version-container">
+							<span>{{ version }}</span>
+							<div id="dark-mode-toggle" role="switch" aria-checked="false" aria-label="Toggle dark mode">{{ light_icon }}{{ dark_icon }}</div>
+						</div>
+						{{ menu_icon }}
+					</div>
+				</div>
+				<nav class="content hidden">
+					<ul>
+						{{ toc_links }}
+					</ul>
+				</nav>
+			</header>
+			<div class="doc-container">
+				<div class="doc-content">
+					{{ contents }}
+					<div class="footer">
+						{{ footer_content }}
+					</div>
+				</div>
+				{{ right_content }}
+			</div>
+		</div>
+		{{ footer_assets }}
+	</body>
+	</html>
+	'
+)
+
+enum OutputType {
+	unset
+	html
+	markdown
+	json
+	plaintext
+	stdout
+}
+
+struct DocConfig {
+mut:
+	pub_only       bool = true
+	show_loc       bool = false // for plaintext
+	serve_http     bool = false // for html
+	is_multi       bool = false
+	is_verbose     bool = false
+	include_readme bool = false
+	open_docs      bool = false
+	server_port    int  = 8046
+	inline_assets  bool = false
+	output_path    string
+	input_path     string
+	output_type    OutputType = .unset
+	docs           []doc.Doc
+	manifest       vmod.Manifest
+}
+
+fn slug(title string) string {
+	return title.replace(' ', '-')
+}
+
+fn open_url(url string) {
+	$if windows {
+		os.system('start $url')
+	}
+	$if macos {
+		os.system('open $url')
+	}
+	$if linux {
+		os.system('xdg-open $url')
+	}
+}
+
+fn (mut cfg DocConfig) serve_html() {
+	docs := cfg.render()
+	dkeys := docs.keys()            
+	if dkeys.len < 1 {
+		eprintln('no documentation created, the module has no `pub` functions')
+		exit(1)
+	}
+	def_name := docs.keys()[0]
+	//
+	server_url := 'http://localhost:' + cfg.server_port.str()
+	server := net.listen(cfg.server_port) or {
+		panic(err)
+	}
+	println('Serving docs on: $server_url')
+	if cfg.open_docs {
+		open_url(server_url)
+	}
+	content_type := match cfg.output_type {
+		.html { 'text/html' }
+		.markdown { 'text/markdown' }
+		.json { 'application/json' }
+		else { 'text/plain' }
+	}
+	server_context := VdocHttpServerContext {
+		docs: docs
+		content_type: content_type
+		default_filename: def_name
+	}
+	for {
+		con := server.accept() or {
+			server.close() or { }
+			panic(err)
+		}
+		handle_http_connection(mut con, server_context)
+		con.close() or {
+			eprintln('error closing the connection: $err')
+		}
+	}
+}
+
+struct VdocHttpServerContext {
+	docs map[string]string
+	content_type string
+	default_filename string
+}
+
+fn handle_http_connection(mut con net.Socket, ctx &VdocHttpServerContext) {
+	s := con.read_line()
+	first_line := s.all_before('\r\n')
+	if first_line.len == 0 {
+		send_http_response(mut con, 501, ctx.content_type, 'bad request')
+		return
+	}
+	request_parts := first_line.split(' ')
+	if request_parts.len != 3 {
+		send_http_response(mut con, 501, ctx.content_type, 'bad request')
+		return
+	}
+	urlpath := request_parts[1]
+	filename := if urlpath == '/' { ctx.default_filename.trim_left('/') } else { urlpath.trim_left('/') }
+	if ctx.docs[filename].len == 0 {
+		send_http_response(mut con, 404, ctx.content_type, 'file not found')
+		return
+	}
+	send_http_response(mut con, 200, ctx.content_type, ctx.docs[filename])
+}
+
+fn send_http_response(mut con net.Socket, http_code int, content_type string, html string) {
+	content_length := html.len.str()
+	shttp_code := http_code.str()
+	mut http_response := strings.new_builder(20000)
+	http_response.write('HTTP/1.1 ')
+	http_response.write(shttp_code)
+	http_response.write(' OK\r\n')
+	http_response.write('Server: VDoc\r\n')
+	http_response.write('Content-Type: ')
+	http_response.write(content_type)
+	http_response.write('\r\n')
+	http_response.write('Content-Length: ')
+	http_response.write(content_length)
+	http_response.write('\r\n')
+	http_response.write('Connection: close\r\n')
+	http_response.write('\r\n')
+	http_response.write(html)
+	sresponse := http_response.str()
+	con.send_string(sresponse) or {
+		eprintln('error sending http response: $err')
+	}
+}
+
+fn get_src_link(repo_url string, file_name string, line_nr int) string {
+	mut url := urllib.parse(repo_url) or {
+		return ''
+	}
+	if url.path.len <= 1 || file_name.len == 0 {
+		return ''
+	}
+	url.path = url.path.trim_right('/') + match url.host {
+		'github.com' { '/blob/master/$file_name' }
+		'gitlab.com' { '/-/blob/master/$file_name' }
+		'git.sir.ht' { '/tree/master/$file_name' }
+		else { '' }
+	}
+	if url.path == '/' { return '' }
+	url.fragment = 'L$line_nr'
+	return url.str()
+}
+
+fn js_compress(str string) string {
+	mut js := strings.new_builder(200)
+	lines := str.split_into_lines()
+	rules := [') {', ' = ', ', ', '{ ', ' }', ' (', '; ', ' + ', ' < ', ' - ', ' || ', ' var', ': ', ' >= ', ' && ', ' else if', ' === ', ' !== ', ' else ']
+	clean := ['){', '=', ',', '{', '}', '(', ';', '+', '<', '-', '||', 'var', ':', '>=', '&&', 'else if', '===', '!==', 'else']
+	for line in lines {
+		mut trimmed := line.trim_space()
+		if trimmed.starts_with('//') || (trimmed.starts_with('/*') && trimmed.ends_with('*/')) { continue }
+		for i in 0..rules.len-1 {
+			trimmed = trimmed.replace(rules[i], clean[i])
+		}
+		js.write(trimmed)
+	}
+	return js.str()
+}
+
+fn escape(str string) string {
+	return str.replace_each(['"', '\\"', '\r\n', '\\n', '\n', '\\n'])
+}
+
+fn (cfg DocConfig) gen_json(idx int) string {
+	dcs := cfg.docs[idx]
+	mut jw := strings.new_builder(200)
+	jw.writeln('{\n\t"module_name": "$dcs.head.name",\n\t"description": "${escape(dcs.head.comment)}",\n\t"contents": [')
+	for i, cn in dcs.contents {
+		name := cn.name.all_after(dcs.head.name)
+		jw.writeln('\t\t{')
+		jw.writeln('\t\t\t"name": "$name",')
+		jw.writeln('\t\t\t"signature": "${escape(cn.content)}",')
+		jw.writeln('\t\t\t"description": "${escape(cn.comment)}"')
+		jw.write('\t\t}')
+		if i < dcs.contents.len-1 { jw.writeln(',') }
+	}
+	jw.writeln('\n\t],')
+	jw.write('\t"generator": "vdoc",\n\t"time_generated": "${dcs.time_generated.str()}"\n}')
+	return jw.str()
+}
+
+fn html_highlight(code string, tb &table.Table) string {
+	builtin := ['bool', 'string', 'i8', 'i16', 'int', 'i64', 'i128', 'byte', 'u16', 'u32', 'u64', 'u128', 'rune', 'f32', 'f64', 'any_int', 'any_float', 'byteptr', 'voidptr', 'any']
+	highlight_code := fn (tok token.Token, typ HighlightTokenTyp) string {
+		lit := if typ in [.unone, .operator, .punctuation] { 
+			tok.kind.str() 
+		} else if typ == .string { 
+			"'$tok.lit'"
+		} else if typ == .char {
+			'`$tok.lit`'
+		} else { tok.lit }
+		return if typ in [.unone, .name] { lit } else { '<span class="token $typ">$lit</span>' } 
+	}
+	s := scanner.new_scanner(code, .parse_comments, false)
+	mut tok := s.scan()
+	mut next_tok := s.scan()
+	mut buf := strings.new_builder(200)
+	mut i := 0
+	for i < code.len {
+		if i == tok.pos {
+			mut tok_typ := HighlightTokenTyp.unone
+			match tok.kind {
+				.name {
+					if tok.lit in builtin || tb.known_type(tok.lit) {
+						tok_typ = .builtin
+					} else if next_tok.kind == .lcbr {
+						tok_typ = .symbol
+					} else if next_tok.kind == .lpar {
+						tok_typ = .function
+					} else {
+						tok_typ = .name
+					}
+				}
+				.comment {
+					tok_typ = .comment
+				}
+				.chartoken {
+					tok_typ = .char
+				}
+				.string {
+					tok_typ = .string
+				}
+				.number {
+					tok_typ = .number
+				}
+				.key_true, .key_false {
+					tok_typ = .boolean
+				}
+				.lpar, .lcbr, .rpar, .rcbr, .lsbr, 
+				.rsbr, .semicolon, .colon, .comma, .dot {
+					tok_typ = .punctuation
+				}
+				else {
+					if token.is_key(tok.lit) || token.is_decl(tok.kind) {
+						tok_typ = .keyword
+					} else if tok.kind == .decl_assign || tok.kind.is_assign() || tok.is_unary() || tok.kind.is_relational() || tok.kind.is_infix() {
+						tok_typ = .operator
+					}
+				}
+			}
+			buf.write(highlight_code(tok, tok_typ))
+			if next_tok.kind != .eof {
+				i = tok.pos + tok.len
+				tok = next_tok
+				next_tok = s.scan()
+			} else {
+				break
+			}
+		} else {
+			buf.write_b(code[i])
+			i++
+		}
+	}
+	return buf.str()
+}
+
+fn doc_node_html(dd doc.DocNode, link string, head bool, tb &table.Table) string {
+	mut dnw := strings.new_builder(200)
+	link_svg := '<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>'
+	head_tag := if head { 'h1' } else { 'h2' }
+	md_content := markdown.to_html(dd.comment)
+	hlighted_code := html_highlight(dd.content, tb)
+	is_const_class := if dd.name == 'Constants' { ' const' } else { '' }
+	mut sym_name := dd.name
+	if dd.attrs.exists('parent') && dd.attrs['parent'] !in ['void', '', 'Constants'] { 
+		sym_name = dd.attrs['parent'] + '.' + sym_name
+	}
+	node_id := slug(sym_name)
+	hash_link := if !head { ' <a href="#$node_id">#</a>' } else { '' }
+	dnw.writeln('<section id="$node_id" class="doc-node$is_const_class">')
+	if dd.name != 'README' && dd.attrs['parent'] != 'Constants' {
+		dnw.write('<div class="title"><$head_tag>$sym_name$hash_link</$head_tag>')
+		if link.len != 0 {
+			dnw.write('<a class="link" rel="noreferrer" target="_blank" href="$link">$link_svg</a>')
+		}
+		dnw.write('</div>')
+	}
+	if head {
+		dnw.write(md_content)
+	} else {
+		dnw.writeln('<pre class="signature"><code>$hlighted_code</code></pre>')
+		dnw.writeln(md_content)
+	}
+	dnw.writeln('</section>')
+	return dnw.str()
+}
+
+fn (cfg DocConfig) readme_idx() int {
+	for i, dc in cfg.docs {
+		if dc.head.name != 'README' { continue }
+		return i
+	}
+	return -1
+}
+
+fn write_toc(cn doc.DocNode, nodes []doc.DocNode, toc &strings.Builder) {
+	toc_slug := if cn.content.len == 0 { '' } else { slug(cn.name) }
+	toc.write('<li class="open"><a href="#$toc_slug">${cn.name}</a>')
+	children := nodes.find_children_of(cn.name)
+	if cn.name != 'Constants' {
+		toc.writeln('        <ul>')
+		for child in children {
+			cname := cn.name + '.' + child.name
+			toc.writeln('<li><a href="#${slug(cname)}">${child.name}</a></li>')
+		}
+		toc.writeln('</ul>')
+	}
+	toc.writeln('</li>')
+}
+
+fn (cfg DocConfig) write_content(cn &doc.DocNode, dcs &doc.Doc, hw &strings.Builder) {
+	base_dir := os.base_dir(os.real_path(cfg.input_path))
+	file_path_name := if cfg.is_multi { cn.file_path.replace('$base_dir/', '') } else { os.file_name(cn.file_path) }
+	src_link := get_src_link(cfg.manifest.repo_url, file_path_name, cn.pos.line)
+	children := dcs.contents.find_children_of(cn.name)
+	if cn.content.len != 0 {
+		hw.write(doc_node_html(cn, src_link, false, dcs.table))
+	}
+	for child in children {
+		child_file_path_name := child.file_path.replace('$base_dir/', '')
+		child_src_link := get_src_link(cfg.manifest.repo_url, child_file_path_name, child.pos.line)
+		hw.write(doc_node_html(child, child_src_link, false, dcs.table))
+	}
+}
+
+fn (cfg DocConfig) gen_html(idx int) string {
+	dcs := cfg.docs[idx]
+	time_gen := '$dcs.time_generated.day $dcs.time_generated.smonth() $dcs.time_generated.year $dcs.time_generated.hhmmss()'
+	mut toc := strings.new_builder(200)
+	mut toc2 := strings.new_builder(200)
+	mut contents := strings.new_builder(200)
+	// generate toc first
+	contents.writeln(doc_node_html(dcs.head, '', true, dcs.table))
+	for cn in dcs.contents {
+		cfg.write_content(&cn, &dcs, &contents)
+		if cn.attrs['parent'] == 'Constants' || cn.attrs['category'] == 'Methods' { continue }
+		write_toc(cn, dcs.contents, &toc)
+	}	// write head
+	// get resources
+	doc_css := cfg.get_resource(css_js_assets[0], true)
+	normalize_css := cfg.get_resource(css_js_assets[1], true)
+	doc_js := cfg.get_resource(css_js_assets[2], !cfg.serve_http)
+	light_icon := cfg.get_resource('light.svg', true)
+	dark_icon := cfg.get_resource('dark.svg', true)
+	menu_icon := cfg.get_resource('menu.svg', true)
+	arrow_icon := cfg.get_resource('arrow.svg', true)
+	// write css
+	version := if cfg.manifest.version.len != 0 { cfg.manifest.version } else { '' }
+	header_name := if cfg.is_multi && cfg.docs.len > 1 { 
+		os.file_name(os.real_path(cfg.input_path)) 
+	} else if cfg.docs.len == 2 && idx+1 < cfg.docs.len && cfg.readme_idx() != -1 {
+		cfg.docs[cfg.readme_idx()+1].head.name
+	} else {
+		dcs.head.name
+	}
+	// write nav1
+	if cfg.is_multi || cfg.docs.len > 1 {
+		mut submod_prefix := ''
+		mut docs := cfg.docs.filter(it.head.name == 'builtin')
+		docs << cfg.docs.filter(it.head.name != 'builtin')
+		for i, doc in docs {
+			if i-1 >= 0 && doc.head.name.starts_with(submod_prefix + '.') {
+				continue
+			}
+			names := doc.head.name.split('.')
+			submod_prefix = if names.len > 1 { names[0] } else { doc.head.name }
+			href_name := if doc.head.name == 'README' {
+				'./index.html'
+			} else if submod_prefix !in cfg.docs.map(it.head.name) {
+				'#'
+			} else if cfg.docs.len == 2 && cfg.readme_idx() == -1 {
+				'./docs.html'
+			} else {
+				'./' + doc.head.name + '.html'
+			}
+			submodules := cfg.docs.filter(it.head.name.starts_with(submod_prefix + '.'))
+			dropdown := if submodules.len > 0 { arrow_icon } else { '' }
+			mut is_submodule_open := false
+			for _, cdoc in submodules {
+				if cdoc.head.name == dcs.head.name {
+					is_submodule_open = true
+				}
+			}
+			active_class := if doc.head.name == dcs.head.name { ' active' } else { '' }
+			toc2.write('<li class="open$active_class"><div class="menu-row">$dropdown<a href="$href_name">${submod_prefix}</a></div>')
+			for j, cdoc in submodules {
+				if j == 0 {
+					toc2.write('<ul>')
+				}
+				submod_name := cdoc.head.name.all_after(submod_prefix + '.')
+				sub_selected_classes := if cdoc.head.name == dcs.head.name { ' class="active"' } else { '' }
+				toc2.write('<li$sub_selected_classes><a href="./${cdoc.head.name}.html">${submod_name}</a></li>')
+				if j == submodules.len - 1 {
+					toc2.write('</ul>')
+				}
+			}
+			toc2.write('</li>')
+		}
+	}
+	return html_content
+		.replace('{{ title }}', dcs.head.name)
+		.replace('{{ head_name }}', header_name)
+		.replace('{{ version }}', version)
+		.replace('{{ light_icon }}', light_icon)
+		.replace('{{ dark_icon }}', dark_icon)
+		.replace('{{ menu_icon }}', menu_icon)
+		.replace('{{ head_assets }}', 	if cfg.inline_assets {
+			'\n	<style>$doc_css</style>\n    <style>$normalize_css</style>'
+		} else {
+			'\n	<link rel="stylesheet" href="$doc_css" />\n	<link rel="stylesheet" href="$normalize_css" />'
+		})
+		.replace('{{ toc_links }}', if cfg.is_multi || cfg.docs.len > 1 { toc2.str() } else { toc.str() })
+		.replace('{{ contents }}', contents.str())
+		.replace('{{ right_content }}', if cfg.is_multi && cfg.docs.len > 1 && dcs.head.name != 'README' {
+			'<div class="doc-toc"><ul>' + toc.str() + '</ul></div>'
+		} else { '' })
+		.replace('{{ footer_content }}', 'Powered by vdoc. Generated on: $time_gen')
+		.replace('{{ footer_assets }}', if cfg.inline_assets {
+			'<script>$doc_js</script>'
+		} else {
+			'<script src="$doc_js"></script>'
+		})
+}
+
+fn (cfg DocConfig) gen_plaintext(idx int) string {
+	dcs := cfg.docs[idx]
+	mut pw := strings.new_builder(200)
+	pw.writeln('${dcs.head.content}\n')
+	if dcs.head.comment.trim_space().len > 0 {
+		pw.writeln('// ' + dcs.head.comment.replace('\n', '\n// ') + '\n')
+	}
+	for cn in dcs.contents {
+		pw.writeln(cn.content)
+		if cn.comment.len > 0 {
+			pw.writeln('\/\/ ' + cn.comment.trim_space() + '\n')
+		}
+		if cfg.show_loc {
+			pw.writeln('Location: ${cn.file_path}:${cn.pos.line}:${cn.pos.col}\n\n')
+		}
+	}
+	return pw.str()
+}
+
+fn (cfg DocConfig) gen_markdown(idx int, with_toc bool) string {
+	dcs := cfg.docs[idx]
+	mut hw := strings.new_builder(200)
+	mut cw := strings.new_builder(200)
+	hw.writeln('# ${dcs.head.content}\n${dcs.head.comment}\n')
+	if with_toc {
+		hw.writeln('## Contents')
+	}
+	for cn in dcs.contents {
+		name := cn.name.all_after(dcs.head.name + '.')
+
+		if with_toc {
+			hw.writeln('- [#$name](${slug(name)})')
+		}
+		cw.writeln('## $name')
+		cw.writeln('```v\n${cn.content}\n```${cn.comment}\n')
+		cw.writeln('[\[Return to contents\]](#Contents)\n')
+	}
+	cw.writeln('#### Generated by vdoc. Last generated: ${dcs.time_generated.str()}')
+	return hw.str() + '\n' + cw.str()
+}
+
+fn (cfg DocConfig) render() map[string]string {
+	mut docs := map[string]string
+	for i, doc in cfg.docs {
+		// since builtin is generated first, ignore it
+		mut name := if doc.head.name == 'README' || cfg.docs.len == 1 {
+			'index'
+		} else if !cfg.is_multi && !os.is_dir(cfg.output_path) {
+			os.file_name(cfg.output_path)
+		} else if i-1 >= 0 && cfg.readme_idx() != -1 && cfg.docs.len == 2 {
+			'docs'
+		} else {
+			doc.head.name
+		}
+		name = name + match cfg.output_type {
+			.html { '.html' }
+			.markdown { '.md' }
+			.json { '.json' }
+			else { '.txt' }
+		}
+		output := match cfg.output_type {
+			.html { cfg.gen_html(i) }
+			.markdown { cfg.gen_markdown(i, true) }
+			.json { cfg.gen_json(i) }
+			else { cfg.gen_plaintext(i) }
+		}
+		docs[name] = output.trim_space()
+	}
+	cfg.vprintln('Rendered: ' + docs.keys().str())
+	return docs
+}
+
+fn (cfg DocConfig) get_readme(path string) string {
+	mut fname := ''
+	for name in ['readme', 'README'] {
+		if os.exists(os.join_path(path, '${name}.md')) {
+			fname = name
+			break
+		} 
+	}
+	if fname == '' {
+		return ''
+	}
+	readme_path := os.join_path(path, '${fname}.md')
+	cfg.vprintln('Reading README file from $readme_path')
+	readme_contents := os.read_file(readme_path) or { '' }
+	return readme_contents
+}
+
+fn (mut cfg DocConfig) generate_docs_from_file() {
+	if cfg.output_path.len == 0 {
+		if cfg.output_type == .unset {
+			cfg.output_type = .stdout
+		} else {
+			cfg.vprintln('No output path has detected. Using input path instead.')
+			cfg.output_path = cfg.input_path
+		}
+	} else if cfg.output_type == .unset {
+		cfg.vprintln('Output path detected. Identifying output type..')
+		ext := os.file_ext(cfg.output_path)
+		cfg.set_output_type_from_str(ext.all_after('.'))
+	}
+	if cfg.include_readme && cfg.output_type !in [.html, .stdout] {
+		eprintln('vdoc: Including README.md for doc generation is supported on HTML output, or when running directly in the terminal.')
+		exit(1)
+	}
+	is_vlib := 'vlib' in cfg.input_path
+	dir_path := if is_vlib {
+		vexe_path
+	} else if os.is_dir(cfg.input_path) { 
+		cfg.input_path
+	} else { 
+		os.base_dir(cfg.input_path) 
+	}
+	manifest_path := os.join_path(dir_path, 'v.mod')
+	if os.exists(manifest_path) {
+		cfg.vprintln('Reading v.mod info from $manifest_path')
+		if manifest := vmod.from_file(manifest_path) {
+			cfg.manifest = manifest
+		}
+	}
+	if cfg.include_readme {
+		readme_contents := cfg.get_readme(dir_path)
+        if cfg.output_type == .stdout {
+			println(markdown.to_plain(readme_contents))
+        }
+        if cfg.output_type == .html {
+			cfg.docs << doc.Doc{
+				head: doc.DocNode{
+					name: 'README',
+					comment: readme_contents
+				}
+				time_generated: time.now()
+			}
+        }
+	}
+	dirs := if cfg.is_multi { get_modules_list(cfg.input_path) } else { [cfg.input_path] } 
+	for dirpath in dirs {
+		cfg.vprintln('Generating docs for ${dirpath}...')
+		mut dcs := doc.generate(dirpath, cfg.pub_only, true) or {
+			mut err_msg := err
+			if errcode == 1 {
+				mod_list := get_modules_list(cfg.input_path)
+				println('Available modules:\n==================')
+				for mod in mod_list {
+					println(mod.all_after('vlib/').all_after('modules/').replace('/', '.'))
+				}
+				err_msg += ' Use the `-m` flag if you are generating docs of a directory containing multiple modules.'
+			}
+			eprintln(err_msg)
+			exit(1)
+		}
+		if dcs.contents.len == 0 { continue }
+		if cfg.is_multi {
+			readme_contents := cfg.get_readme(dirpath)
+			dcs.head.comment = readme_contents
+		}
+		if cfg.pub_only {
+			for i, c in dcs.contents {
+				dcs.contents[i].content = c.content.all_after('pub ')	
+			}
+		}
+		cfg.docs << dcs
+	}
+	if cfg.serve_http {
+		cfg.serve_html()
+		return
+	}
+	cfg.vprintln('Rendering docs...')
+	if cfg.output_path.len == 0 {
+		outputs := cfg.render()
+		if outputs.len == 0 {
+			println('No documentation for $dirs')
+		} else {
+			first := outputs.keys()[0]
+			println(outputs[first])
+		}
+	} else {
+		if !os.is_dir(cfg.output_path) {
+			cfg.output_path = os.real_path('.')
+		}
+		if !os.exists(cfg.output_path) {
+			os.mkdir(cfg.output_path) or {
+				panic(err)
+			}
+		}
+		if cfg.is_multi {
+			cfg.output_path = os.join_path(cfg.output_path, '_docs')
+			if !os.exists(cfg.output_path) {
+				os.mkdir(cfg.output_path) or {
+					panic(err)
+				}
+			} else {
+				for fname in css_js_assets {
+					os.rm(os.join_path(cfg.output_path, fname))
+				}
+			}
+		}
+		outputs := cfg.render()
+		for file_name, content in outputs {
+			output_path := os.join_path(cfg.output_path, file_name)
+			println('Generating ${output_path}...')
+			os.write_file(output_path, content)
+		}
+	}
+}
+
+fn (mut cfg DocConfig) set_output_type_from_str(format string) {
+	match format {
+		'htm', 'html' { 
+			cfg.output_type = .html 
+		}
+		'md', 'markdown' { 
+			cfg.output_type = .markdown 
+		}
+		'json' { 
+			cfg.output_type = .json 
+		}
+		'stdout' {
+			cfg.output_type = .stdout
+		}
+		else { 
+			cfg.output_type = .plaintext 
+		}
+	}
+	cfg.vprintln('Setting output type to "$cfg.output_type"')
+}
+
+fn (cfg DocConfig) vprintln(str string) {
+	if cfg.is_verbose {
+		println('vdoc: $str')
+	}
+}
+
+fn lookup_module(mod string) ?string {
+	mod_path := mod.replace('.', os.path_separator)
+	compile_dir := os.real_path(os.base_dir('.'))
+	modules_dir := os.join_path(compile_dir, 'modules', mod_path)
+	vlib_path := os.join_path(vexe_path, 'vlib', mod_path)
+	vmodules_path := os.join_path(os.home_dir(), '.vmodules', mod_path)
+	paths := [modules_dir, vlib_path, vmodules_path]
+	for path in paths {
+		if os.is_dir_empty(path) { continue }
+		return path
+	}
+	return error('vdoc: Module "${mod}" not found.')
+}
+
+fn get_modules_list(path string) []string {
+	files := os.walk_ext(path, 'v')
+	mut dirs := []string{}
+	for file in files {
+		if 'vlib' in path && ('examples' in file || 'test' in file || 'js' in file || 'x64' in file || 'bare' in file || 'uiold' in file || 'vweb' in file) { continue }
+		dirname := os.base_dir(file)
+		if dirname in dirs { continue }
+		dirs << dirname
+	}
+	dirs.sort()
+	return dirs
+}
+
+fn (cfg DocConfig) get_resource(name string, minify bool) string {
+	path := os.join_path(res_path, name)
+	mut res := os.read_file(path) or { panic('could not read $path') }
+	if minify {
+		res = if name.ends_with('.js') { js_compress(res) } else { res.replace('\n', ' ') }
+	}
+	// TODO: Make SVG inline for now
+	if cfg.inline_assets || path.ends_with('.svg') {
+		return res
+	} else {
+		output_path := os.join_path(cfg.output_path, name)
+		if !os.exists(output_path) {
+			println('Generating ${output_path}...')
+			os.write_file(output_path, res)
+		}
+		return name
+	}
+}
+
+fn main() {
+	args := os.args[2..].clone()
+	if args.len == 0 || args[0] in ['help', '-h', '--help'] {
+		os.system('${@VEXE} help doc')
+		exit(0)
+	}
+	mut cfg := DocConfig{
+		manifest: vmod.Manifest{ repo_url: '' }
+	}
+	for i := 0; i < args.len; i++ {
+		arg := args[i]
+		current_args := args[i..]
+		match arg {
+			'-all' {
+				cfg.pub_only = false
+			}
+			'-f' {
+				format := cmdline.option(current_args, '-f', '')
+				allowed_str := allowed_formats.join(', ')
+				if format !in allowed_formats {
+					eprintln('vdoc: "$format" is not a valid format. Only $allowed_str are allowed.')
+					exit(1)
+				}
+				cfg.set_output_type_from_str(format)
+				i++
+			}
+			'-inline-assets' {
+				cfg.inline_assets = true
+			}
+			'-l' {
+				cfg.show_loc = true
+			}
+			'-m' {
+				cfg.is_multi = true
+			}
+			'-o' {
+				opath := cmdline.option(current_args, '-o', '')
+				cfg.output_path = os.real_path(opath)
+				i++
+			}
+			'-open' {
+				cfg.open_docs = true
+			}
+			'-p' {
+				s_port := cmdline.option(current_args, '-o', '')
+				s_port_int := s_port.int()
+				if s_port.len == 0 {
+					eprintln('vdoc: No port number specified on "-p".')
+					exit(1)
+				}
+				if s_port != s_port_int.str() {
+					eprintln('vdoc: Invalid port number.')
+					exit(1)
+				}
+				cfg.server_port = s_port_int
+			}
+			'-s' {
+				cfg.inline_assets = true
+				cfg.serve_http = true
+				if cfg.output_type == .unset {
+					cfg.output_type = .html
+				}
+			}
+			'-readme' {
+				cfg.include_readme = true
+			}
+			'-v' {
+				cfg.is_verbose = true
+			}
+			else {
+				cfg.input_path = arg
+				break
+			}
+		}
+	}
+	if cfg.input_path.len == 0 {
+		eprintln('vdoc: No input path found.')
+		exit(1)
+	}
+	$if windows {
+		cfg.input_path = cfg.input_path.replace('/', os.path_separator)
+	} $else {
+		cfg.input_path = cfg.input_path.replace('\\', os.path_separator)
+	}
+	is_path := cfg.input_path.ends_with('.v') || cfg.input_path.split(os.path_separator).len > 1 || cfg.input_path == '.'
+	if cfg.input_path == 'vlib' {
+		cfg.is_multi = true
+		cfg.input_path = os.join_path(vexe_path, 'vlib')
+	} else if !is_path {
+		cfg.vprintln('Input "$cfg.input_path" is not a valid path. Looking for modules named "$cfg.input_path"...')
+		mod_path := lookup_module(cfg.input_path) or {
+			eprintln(err)
+			exit(1)
+		}
+		cfg.input_path = mod_path
+	}
+	cfg.generate_docs_from_file()
+}

cmd/tools/vfmt.v

@@ -0,0 +1,313 @@
+// 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 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
+}
+
+const (
+	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']]
+	formatted_file_token         = '\@\@\@' + 'FORMATTED_FILE: '
+)
+
+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
+	}
+	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 !file.ends_with('.v') && !file.ends_with('.vv') {
+			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_with_spaces(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)
+	vfmt_output_path := os.join_path(os.temp_dir(), 'vfmt_' + 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, formatted_file_path string) {
+	if formatted_file_path.len == 0 {
+		return
+	}
+	if foptions.is_diff {
+		diff_cmd := util.find_working_diff_command() or {
+			eprintln('No working "diff" CLI command found.')
+			return
+		}
+		println(util.color_compare_files(diff_cmd, file, formatted_file_path))
+		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' + ' }'
+}
+
+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/vnames.v

@@ -0,0 +1,87 @@
+module main
+
+/*
+QTODO
+import os
+import flag
+import strings
+import compiler
+import v.pref
+
+const (
+	tool_version = '0.0.1'
+	tool_description = '  Extracts the function names declared in a v file.'
+)
+
+fn f_to_string(fmod string, f compiler.Fn) ?string {
+	svisibility := if f.is_public {
+		'public'
+	}else{
+		'private'
+	}
+	if fmod != f.v_fn_module() { return none }
+	if fmod == 'builtin' {
+		return '$svisibility\t' + f.v_fn_name()
+	}
+	return '$svisibility\t' + f.v_fn_module() + '.' + f.v_fn_name()
+}
+
+fn analyze_v_file(file string) {
+	println('')
+	hash := strings.repeat(`#`, (76 - file.len) / 2)
+	println('$hash  $file  $hash')
+
+	// main work:
+	mut pref := &pref.Preferences{
+		path: file
+	}
+	pref.fill_with_defaults()
+	mut v := compiler.new_v(pref)
+	v.add_v_files_to_compile()
+	for f in v.files { v.parse(f, .decl) }
+	fi := v.get_file_parser_index( file ) or { panic(err) }
+	fmod :=  v.parsers[fi].mod
+
+	// output:
+	mut fns :=[]string
+	for _, f in v.table.fns {
+		fname := f_to_string(fmod, f) or { continue }
+		fns << fname
+	}
+	fns.sort()
+	for f in fns { println(f) }
+
+}
+
+fn main(){
+	toolexe := os.executable()
+	compiler.set_vroot_folder(os.dir(os.dir(os.dir(toolexe))))
+
+	mut fp := flag.new_flag_parser(os.args)
+	fp.application(os.file_name(toolexe))
+	fp.version( tool_version )
+	fp.description( tool_description )
+	fp.arguments_description('FILE.v/FOLDER [FILE.v/FOLDER]...')
+	fp.limit_free_args_to_at_least(1)
+	fp.skip_executable()
+	show_help:=fp.bool('help', `h`, false, 'Show this help screen\n')
+	if( show_help ){
+		println( fp.usage() )
+		exit(0)
+	}
+
+	mut files := []string{}
+	locations := fp.finalize() or { eprintln('Error: ' + err) exit(1) }
+	for xloc in locations {
+		loc := os.real_path(xloc)
+		xfiles := if os.is_dir(loc){ os.walk_ext(loc,'.v') } else { [loc] }
+		filtered_files := xfiles.filter(!it.ends_with('_js.v'))
+		files << filtered_files
+	}
+
+	for file in files {
+		analyze_v_file(file)
+	}
+}
+*/
+fn main()  {}

cmd/tools/vpm.v

@@ -0,0 +1,492 @@
+module main
+
+import os
+import os.cmdline
+import net.http
+import json
+import vhelp
+import v.vmod
+
+const (
+	default_vpm_server_urls = ['https://vpm.best', 'https://vpm.vlang.io']
+	valid_vpm_commands = ['help', 'search', 'install', 'update', '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'
+	}
+)
+
+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)
+		}
+		'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) {
+	if settings.is_help {
+		vhelp.show_topic('search')
+		exit(0)
+	}
+	if keywords.len == 0 {
+		println('  v search requires *at least one* keyword')
+		exit(2)
+	}
+	modules := get_all_modules()
+	joined := keywords.join(', ')
+	mut index := 0
+	for mod in modules {
+		// TODO for some reason .filter results in substr error, so do it manually
+		for k in keywords {
+			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] = ''
+			}
+			println('${index}. ${parts[1]} by ${parts[0]} [$mod]')
+			break
+		}
+	}
+	println('\nUse "v install author.module_name" to install the module')
+	if index == 0 {
+		println('No module(s) found for "$joined"')
+	}
+}
+
+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()
+		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
+		}
+		final_module_path := os.real_path(os.join_path(settings.vmodules_path,mod.name.replace('.', os.path_separator)))
+		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
+		}
+		resolve_dependencies(name, final_module_path, module_names)
+	}
+	if errors > 0 {
+		exit(1)
+	}
+}
+
+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 {
+	name_of_vmodules_folder := os.join_path(settings.vmodules_path,name.replace('.', os.path_separator))
+	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, 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.home_dir() + '.vmodules'
+}
+
+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,302 @@
+// 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
+	//
+	imports        []string // all the import 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
+}
+
+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 {
+		if line.starts_with(function) {
+			return true
+		}
+	}
+	return false
+}
+
+fn (r &Repl) current_source_code(should_add_temp_lines bool) string {
+	mut all_lines := []string{}
+	all_lines << r.imports
+	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(true))
+	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.
+')
+}
+
+fn run_repl(workdir string, vrepl_prefix string) {
+	println(util.full_v_version(true))
+	println('Use Ctrl-C or `exit` to exit')
+
+	file := os.join_path(workdir, '.${vrepl_prefix}vrepl.v')
+	temp_file := os.join_path(workdir, '.${vrepl_prefix}vrepl_temp.v')
+	mut prompt := '>>> '
+	defer {
+		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 := Repl{}
+	mut readline := readline.Readline{}
+	vexe := os.getenv('VEXE')
+	for {
+		if r.indent == 0 {
+			prompt = '>>> '
+		} else {
+			prompt = '... '
+		}
+		oline := readline.read_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 = 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 '
+			]
+			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 ') || 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 ') || r.line.starts_with('#include ') {
+					mut imports := r.imports
+					r.imports = [r.line]
+					r.imports << imports
+				} 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()
+}

cmd/tools/vself.v

@@ -0,0 +1,41 @@
+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('self')
+	args := os.args[1..self_idx]
+	args_str := args.join(' ')
+	options := if args.len > 0 { '($args_str)' } else { '' }
+	println('V self compiling ${options}...')
+
+	cmd := '$vexe -o v2 $args_str cmd/v'
+	result := os.exec(cmd) or { panic(err) }
+	if result.exit_code != 0 {
+		mut err := 'Permission denied'
+		if !result.output.contains('Permission denied') {
+			err = '\n$result.output'
+		}
+		eprintln('cannot compile to `$vroot`: $err')
+		exit(1)
+	}
+	if result.output.len > 0 {
+		println(result.output)
+	}
+
+	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,26 @@
+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,186 @@
+import os
+import v.pref
+
+const (
+	hkey_current_user = voidptr(0x80000001)
+	hwnd_broadcast = voidptr(0xffff)
+)
+
+$if windows {
+	$if tinyc {
+		#flag -lAdvapi32
+		#flag -lUser32
+	}
+}
+
+fn main(){
+	$if windows {
+		setup_symlink_on_windows()
+	} $else {
+		setup_symlink_on_unix()
+	}
+}
+
+fn setup_symlink_on_unix(){
+	vexe := pref.vexe_path()
+	mut link_path := '/usr/local/bin/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 {
+			println('Failed to create symlink "$link_path". Try again with sudo.')
+		}
+	} else {
+		println('Failed to create symlink "$link_path". Try again with sudo.')
+	}
+}
+
+fn setup_symlink_on_windows(){
+	$if windows {
+		vexe := pref.vexe_path()
+		// NB: Putting $vdir directly into PATH will also result in
+		// make.bat being global, which is NOT what we want.
+		//
+		// Instead, we create a small launcher v.bat, in a new local
+		// folder .bin/ . That .bin/ folder can then be put in PATH
+		// without poluting it with anything else - just a `v`
+		// command will be available, similar to unix.
+		//
+		// Creating a real NTFS symlink to the real executable was also
+		// tried, but then os.real_path( os.executable() ) returns the
+		// path to the symlink, unfortunately, unlike on posix systems
+		// ¯\_(ツ)_/¯
+		vdir := os.real_path(os.dir(vexe))
+		vsymlinkdir := os.join_path(vdir, '.bin')
+		vsymlinkbat := os.join_path(vsymlinkdir, 'v.bat')
+		if os.exists(vsymlinkbat) {
+			print('Batch script $vsymlinkbat already exists, checking system %PATH%...')
+		}
+		else {
+			os.rmdir_all(vsymlinkdir)
+			os.mkdir_all(vsymlinkdir)
+			os.write_file(vsymlinkbat, '@echo off\n${vexe} %*')
+			if !os.exists(vsymlinkbat) {
+				eprintln('Could not create $vsymlinkbat')
+				exit(1)
+			}
+			else {
+				print('Created $vsymlinkbat, checking system %PATH%...')
+			}
+		}
+
+		reg_sys_env_handle  := get_reg_sys_env_handle() or {
+			warn_and_exit(err)
+			return
+		}
+		defer {
+			C.RegCloseKey(reg_sys_env_handle)
+		}
+
+		sys_env_path := get_reg_value(reg_sys_env_handle, 'Path') or {
+			warn_and_exit(err)
+			return
+		}
+
+		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 !in new_paths {
+				new_paths << p
+			}
+		}
+
+		new_sys_env_path := new_paths.join(';')
+
+		if new_sys_env_path == sys_env_path {
+			println('configured.')
+		}
+		else {
+			print('not configured.\nSetting system %PATH%...')
+			set_reg_value(reg_sys_env_handle, 'Path', new_sys_env_path) or {
+				warn_and_exit(err)
+				return
+			}
+			println('done.')
+		}
+
+		print('Letting running process know to update their Environment...')
+		send_setting_change_msg('Environment') or {
+			eprintln('\n' + err)
+			warn_and_exit('You might need to run this again to have `v` in your %PATH%')
+			return
+		}
+
+		println('finished.\n\nNote: restart your shell/IDE to load the new %PATH%.')
+		println('\nAfter 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 {
+		// open the registry key
+		reg_key_path   := 'Environment'
+		reg_env_key    := voidptr(0) // or HKEY (HANDLE)
+		if C.RegOpenKeyEx(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(hwnd_broadcast, 0x001A, 0, message_data.to_wide(), 2, 5000, 0) == 0 {
+			return error('Could not broadcast WM_SETTINGCHANGE')
+		}
+		return true
+	}
+	return error('not on windows')
+}

cmd/tools/vtest-compiler.v

@@ -0,0 +1,68 @@
+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('')
+	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,74 @@
+module main
+
+import os
+import testing
+import v.pref
+
+const (
+	skip_test_files     = [
+		'vlib/net/http/http_httpbin_test.v',
+	]
+	skip_on_musl        = [
+		'vlib/net/http/http_test.v',
+		'vlib/net/http/cookie_test.v',
+		'vlib/net/websocket/ws_test.v'
+		'vlib/sqlite/sqlite_test.v',
+		'vlib/orm/orm_test.v',
+		'vlib/clipboard/clipboard_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',
+	]
+	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 !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 {
+		panic('\nWARNING: failed ${tsession.benchmark.nfail} times.\n')
+	}
+}

cmd/tools/vtest-fmt.v

@@ -0,0 +1,69 @@
+module main
+
+import os
+import testing
+
+const (
+	known_failing_exceptions = ['./examples/vweb/vweb_example.v',
+	'./cmd/tools/gen_vc.v',
+	'./cmd/tools/modules/vgit/vgit.v', // generics
+	'./cmd/tools/preludes/live_main.v',
+	'./cmd/tools/preludes/live_shared.v',
+	'./cmd/tools/preludes/tests_assertions.v',
+	'./cmd/tools/preludes/tests_with_stats.v',
+	'./cmd/tools/performance_compare.v', // generics
+	'./cmd/tools/oldv.v', // generics
+	'./tutorials/code/blog/article.v',
+	'./tutorials/code/blog/blog.v',
+	'./vlib/arrays/arrays.v',
+	'./vlib/arrays/arrays_test.v',
+	'./vlib/builtin/js/hashmap.v',
+	'./vlib/v/tests/fn_variadic_test.v',
+	'./vlib/v/tests/generic_test.v',
+	'./vlib/crypto/aes/aes.v',
+	'./vlib/crypto/aes/aes_cbc.v',
+	'./vlib/crypto/aes/block_generic.v',
+	'./vlib/crypto/aes/const.v',
+	'./vlib/crypto/aes/cypher_generic.v',
+	'./vlib/crypto/rc4/rc4.v',
+	'./vlib/eventbus/eventbus_test.v',
+	'./vlib/os/bare/bare_example_linux.v',
+	'./vlib/szip/szip.v',
+	'./vlib/uiold/examples/users_gui/users.v',
+	'./vlib/vweb/assets/assets.v',
+	'./vlib/vweb/vweb.v',
+	]
+)
+
+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()
+	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.test()
+	eprintln(vfmt_test_session.benchmark.total_message('running vfmt over V files'))
+	if vfmt_test_session.benchmark.nfail > 0 {
+		panic('\nWARNING: v fmt failed ${vfmt_test_session.benchmark.nfail} times.\n')
+	}
+}
+
+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 in known_failing_exceptions {
+			continue
+		}
+		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,53 @@
+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/vup.v

@@ -0,0 +1,101 @@
+module main
+
+import os
+import v.pref
+import v.util
+
+struct App {
+	is_verbose bool
+	vexe       string
+	vroot      string
+}
+
+fn new_app() App {
+	vexe := 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...')
+	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 origin 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('v.exe')
+		make_result := os.exec('make.bat') or {
+			panic(err)
+		}
+		println(make_result.output)
+		app.backup('cmd/tools/vup.exe')
+	} $else {
+		self_result := os.exec('./v self') or {
+			panic(err)
+		}
+		println(self_result.output)
+		if self_result.exit_code != 0 {
+			// v self failed, have to use make
+			println('v self failed, running make...')
+			make_result := os.exec('make') or {
+				panic(err)
+			}
+			println(make_result.output)
+		}
+	}
+	os.exec('v cmd/tools/vup.v') or {
+		panic(err)
+	}
+	app.show_current_v_version()
+}
+
+fn (app App) show_current_v_version() {
+	println('Current V version:')
+	os.system('$app.vexe version')
+}
+
+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('have no access `$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,38 @@
+// 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.ast
+import v.pref
+import v.parser
+import v.util
+import v.table
+import os
+
+fn main() {
+	mut prefs := pref.new_preferences()
+	prefs.is_vet = true
+	table := table.new_table()
+	args := util.join_env_vflags_and_os_args()
+	if args.len < 3 {
+		return
+	}
+	path := args[2]
+	if path.ends_with('.v') {
+		vet_file(path, table, prefs)
+	} else if os.is_dir(path) {
+		println("vet'ing directory '$path'...")
+		files := os.walk_ext(path, '.v')
+		for file in files {
+			vet_file(file, table, prefs)
+		}
+	}
+}
+
+fn vet_file(path string, table &table.Table, prefs &pref.Preferences) {
+	file_ast := parser.parse_file(path, table, .parse_comments, prefs, &ast.Scope{
+		parent: 0
+	})
+	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,72 @@
+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`:
+
+   -arch <architecture>
+      Change the architecture that V will tell the C compiler to build.
+      List of supported architectures: `x86` and `x64` (default).
+
+   -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.
+
+   -keepc
+      Specify that you want V to not delete the intermediate generated C source code.
+      Use with -cg for best debugging experience.
+
+   -freestanding
+      Build the executable without dependency on libc.
+      Supported only on `linux` targets currently.
+
+   -live
+      Build the executable with live capabilities (`[live]`).
+
+   -manual-free
+      Enable manually freeing on all V code. This will cause memory leaks in vlib.
+      Currently enabled until a stable auto-free system is in place.
+
+   -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`, `mac`, `freebsd`, `openbsd`, `netbsd`,
+                                 `dragonfly`, `solaris`, `android` and `haiku`.
+
+   -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>.

cmd/v/help/build.txt

@@ -0,0 +1,116 @@
+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!).
+      * `v2`/`experimental` - Invokes the experimental AST-powered V compiler that will replace the
+                              current backends when finished
+
+   -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).
+           @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.
+
+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,41 @@
+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 -keepc -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.
+   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.
+* Others:
+   build             Build a 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).
+
+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,25 @@
+Usage: 
+  v doc [flags] [module_name / folder / V file]
+
+Examples:
+  v doc os
+  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.
+  -inline-assets  Embeds the contents of the CSS and JS assets into the webpage directly.
+  -l              Show the locations of the generated signatures. (For plaintext only)
+  -m              Generate docs for modules listed in that folder.
+  -o              Specifies the output file/folder path where to store the generated docs.
+  -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.
+  -readme         Include README.md to docs if present.
+  -v              Enables verbose logging. For debugging purposes.
+  -h, -help       Prints this help text.

cmd/v/help/fmt.txt

@@ -0,0 +1,17 @@
+Usage:
+  v [flags] fmt 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 only diffs between the formatted source and the original source.
+  -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.
+
+NB: vfmt after 2020/04/01 is based on the new AST compiler code, and
+thus is much faster, and more flexible than before.
+It may also EAT some of your code for now, so please be careful, and
+make frequent BACKUPS.

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
+		}
+		println(unknown_topic)
+		exit(1)
+	}
+	target_topic := os.join_path(vroot, 'cmd', 'v', 'help', '${topic}.txt')
+	content := os.read_file(target_topic) or {
+		println(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.