Merge branch 'master' into develop

Signed-off-by: ValKmjolnir <lhk101lhk101@qq.com>

.gitattributes

@@ -0,0 +1 @@
+*.nas linguist-language=Nasal

.github/workflows/c-cpp.yml

@@ -0,0 +1,128 @@
+name: Nightly Build
+
+on:
+  schedule:
+   - cron: "0 16 * * *"
+  workflow_dispatch:
+
+jobs:
+  mac-aarch64-build:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Update Tag
+      run: |
+        git fetch --tags origin
+        git tag -f next_macOS
+        git push -f origin next_macOS
+    - name: Build
+      run: |
+        mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release
+        make -j6
+    - name: Test
+      run: make test
+    - name: Package
+      run: python3 tools/pack.py
+    - name: Release
+      uses: softprops/action-gh-release@v2.0.5
+      with:
+        name: macOS nightly build
+        tag_name: next_macOS
+        prerelease: true
+        draft: false
+        files: |
+          nasal-macOS-aarch64.tar
+    
+  linux-x86_64-build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Update Tag
+      run: |
+        git fetch --tags origin
+        git tag -f next_linux_x86_64
+        git push -f origin next_linux_x86_64
+    - name: Build
+      run: |
+        mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release
+        make -j6
+    - name: Test
+      run: make test
+    - name: Package
+      run: python3 tools/pack.py
+    - name: Release
+      uses: softprops/action-gh-release@v2.0.5
+      with:
+        name: linux nightly build
+        tag_name: next_linux_x86_64
+        prerelease: true
+        draft: false
+        files: |
+          nasal-linux-x86_64.tar
+    
+  windows-x86_64-build-msvc:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Fetch Deps
+      run: |
+          choco install -y cmake
+    - name: Update Tag
+      run: |
+        git fetch --tags origin
+        git tag -f next_windows_x86_64_msvc
+        git push -f origin next_windows_x86_64_msvc
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@v2
+    - name: Build
+      run: |
+        mkdir build
+        cd build
+        cmake .. -DCMAKE_BUILD_TYPE=Release -G "Visual Studio 17 2022"
+        MSBuild.exe nasal.sln /p:Configuration=Release /p:Platform=x64
+    - name: Package
+      run: |
+        python3 tools/msvc_move_file.py
+        python3 tools/pack.py msvc
+    - name: Release
+      uses: softprops/action-gh-release@v2.0.5
+      with:
+        name: windows MSVC nightly build
+        tag_name: next_windows_x86_64_msvc
+        prerelease: true
+        draft: false
+        files: |
+          nasal-windows-x86_64-msvc.tar
+  
+  windows-x86_64-build-mingw:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Fetch Deps
+      run: |
+          choco install -y cmake
+          choco install -y mingw
+    - name: Update Tag
+      run: |
+        git fetch --tags origin
+        git tag -f next_windows_x86_64_mingw
+        git push -f origin next_windows_x86_64_mingw
+    - name: Build
+      run: |
+        mkdir build
+        cd build
+        cmake .. -DCMAKE_BUILD_TYPE=Release -G "MinGW Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
+        mingw32-make.exe -j4
+    - name: Package
+      run: |
+        python3 tools/mingw_move_file.py
+        python3 tools/pack.py mingw
+    - name: Release
+      uses: softprops/action-gh-release@v2.0.5
+      with:
+        name: windows MINGW nightly build
+        tag_name: next_windows_x86_64_mingw
+        prerelease: true
+        draft: false
+        files: |
+          nasal-windows-x86_64-mingw.tar

.github/workflows/test.yml

@@ -0,0 +1,31 @@
+name: Nasal Interpreter Test
+
+on:
+  push:
+    branches: [ master, develop ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+jobs:
+  mac-aarch64:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Build
+      run: |
+        mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release
+        make -j6
+    - name: Test
+      run: make test
+    
+  linux-x86_64:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Build
+      run: |
+        mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release
+        make -j6
+    - name: Test
+      run: make test

.gitignore

@@ -1,3 +1,22 @@
+# Build directories
+build/
+out/
+dist/
+cmake-build-*
+cmake-windows-*
+
+# IDE and editor files
+.vscode/
+.idea/
+.vs/
+*.swp
+*.swo
+*~
+.DS_Store
+.env
+.env.local
+
+# C++ specific
 # Prerequisites
 *.d
 
@@ -30,3 +49,60 @@
 *.exe
 *.out
 *.app
+nasal
+nasal-format
+nasal.exe
+nasal-format.exe
+
+# Visual Studio specific
+*.sln
+*.vcxproj
+*.vcxproj.filters
+*.vcxproj.user
+x64/
+CMakePresents.json
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# CMake
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+install_manifest.txt
+CTestTestfile.cmake
+_deps/
+
+# Node.js specific (for the web app)
+node_modules/
+npm-debug.log
+yarn-debug.log
+yarn-error.log
+package-lock.json
+
+# Project specific
+dump/
+fgfs.log
+.temp.*
+*.ppm
+
+# Logs and databases
+*.log
+*.sqlite
+*.sqlite3
+*.db
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db

CMakeLists.txt

@@ -0,0 +1,139 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(nasal VERSION 11.3)
+
+message("CMAKE_HOST_SYSTEM_NAME: ${CMAKE_HOST_SYSTEM_NAME}")
+
+# -std=c++17 -Wshadow -Wall
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(CMAKE_CXX_FLAGS_RELEASE_INIT "-Wshadow -Wall")
+
+# MSVC does not need -fPIC
+if (NOT MSVC)
+    add_compile_options(-fPIC)
+endif()
+
+# MSVC needs this command option to really enable utf-8 output
+if (MSVC)
+    add_compile_options(/utf-8)
+endif()
+
+if (APPLE)
+    add_compile_options(-mmacosx-version-min=10.15)
+endif()
+
+# build nasal used object
+set(NASAL_OBJECT_SOURCE_FILE
+    ${CMAKE_SOURCE_DIR}/src/cli/cli.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/builtin.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/coroutine.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/fg_props.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/bits_lib.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/io_lib.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/json_lib.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/math_lib.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/dylib_lib.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/regex_lib.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/subprocess.cpp
+    ${CMAKE_SOURCE_DIR}/src/natives/unix_lib.cpp
+    ${CMAKE_SOURCE_DIR}/src/repl/repl.cpp
+    ${CMAKE_SOURCE_DIR}/src/util/fs.cpp
+    ${CMAKE_SOURCE_DIR}/src/util/gc_stat.cpp
+    ${CMAKE_SOURCE_DIR}/src/util/util.cpp
+    ${CMAKE_SOURCE_DIR}/src/ast/ast_dumper.cpp
+    ${CMAKE_SOURCE_DIR}/src/ast/ast_format.cpp
+    ${CMAKE_SOURCE_DIR}/src/ast/ast_visitor.cpp
+    ${CMAKE_SOURCE_DIR}/src/ast/ast.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_codegen.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_dbg.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_err.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_gc.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_import.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_lexer.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_opcode.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_parse.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_type.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_vm.cpp
+    ${CMAKE_SOURCE_DIR}/src/optimizer.cpp
+    ${CMAKE_SOURCE_DIR}/src/symbol_finder.cpp)
+add_library(nasal-object STATIC ${NASAL_OBJECT_SOURCE_FILE})
+target_include_directories(nasal-object PRIVATE ${CMAKE_SOURCE_DIR}/src)
+
+# build nasal
+add_executable(nasal ${CMAKE_SOURCE_DIR}/src/main.cpp)
+target_link_libraries(nasal nasal-object)
+
+# build nasal-format
+add_executable(nasal-format ${CMAKE_SOURCE_DIR}/src/format.cpp)
+target_link_libraries(nasal-format nasal-object)
+
+# link ldl and lpthread
+if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
+    target_link_libraries(nasal dl)
+    target_link_libraries(nasal pthread)
+    target_link_libraries(nasal-format pthread)
+endif()
+target_include_directories(nasal PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_include_directories(nasal-format PRIVATE ${CMAKE_SOURCE_DIR}/src)
+
+# copy nasal from build dir to the outside dir
+if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
+    add_custom_command(
+        TARGET nasal POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_SOURCE_DIR}/build/nasal
+                ${CMAKE_SOURCE_DIR}/nasal
+    )
+    add_custom_command(
+        TARGET nasal-format POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy
+                ${CMAKE_SOURCE_DIR}/build/nasal-format
+                ${CMAKE_SOURCE_DIR}/nasal-format
+    )
+endif()
+
+# build module
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/module)
+
+set(MODULE_USED_OBJECT_SOURCE_FILE
+    ${CMAKE_SOURCE_DIR}/src/util/util.cpp
+    ${CMAKE_SOURCE_DIR}/src/util/gc_stat.cpp
+    ${CMAKE_SOURCE_DIR}/src/util/fs.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_type.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_gc.cpp)
+add_library(module-used-object STATIC ${MODULE_USED_OBJECT_SOURCE_FILE})
+target_include_directories(module-used-object PRIVATE ${CMAKE_SOURCE_DIR}/src)
+
+add_library(fib SHARED ${CMAKE_SOURCE_DIR}/module/fib.cpp)
+target_include_directories(fib PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(fib module-used-object)
+
+add_library(key SHARED ${CMAKE_SOURCE_DIR}/module/keyboard.cpp)
+target_include_directories(key PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(key module-used-object)
+
+add_library(mat SHARED ${CMAKE_SOURCE_DIR}/module/matrix.cpp)
+target_include_directories(mat PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(mat module-used-object)
+
+add_library(nasock SHARED ${CMAKE_SOURCE_DIR}/module/nasocket.cpp)
+target_include_directories(nasock PRIVATE ${CMAKE_SOURCE_DIR}/src)
+if (WIN32)
+    target_link_libraries(nasock ws2_32)
+endif()
+target_link_libraries(nasock module-used-object)
+
+# Add web library, not for MSVC now
+if (NOT MSVC)
+    add_library(nasal-web SHARED
+        src/nasal_web.cpp
+    )
+    target_include_directories(nasal-web PRIVATE ${CMAKE_SOURCE_DIR}/src)
+    target_link_libraries(nasal-web nasal-object)
+    set_target_properties(nasal-web PROPERTIES
+        C_VISIBILITY_PRESET hidden
+        CXX_VISIBILITY_PRESET hidden
+        VISIBILITY_INLINES_HIDDEN ON
+    )
+endif()

LICENSE

@@ -1,21 +1,339 @@
-MIT License
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
 
-Copyright (c) 2021 ValKmjolnir
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+                            Preamble
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

doc/README_zh.md

@@ -0,0 +1,486 @@
+# <img src="./svg/nasal_transparent.svg" height="40px"/> __Nasal - Modern Interpreter__
+
+<img src="../doc/pic/header.png" style="width:600px"></img>
+
+![GitHub release(latest by date)](https://img.shields.io/github/v/release/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
+[![license](https://img.shields.io/badge/license-GPLv2-green?style=flat-square&logo=github)](../LICENSE)
+![downloads](https://img.shields.io/github/downloads/ValKmjolnir/Nasal-Interpreter/total.svg?style=flat-square&logo=github)
+[![C/C++ CI](https://github.com/ValKmjolnir/Nasal-Interpreter/actions/workflows/c-cpp.yml/badge.svg)](https://github.com/ValKmjolnir/Nasal-Interpreter/actions/workflows/c-cpp.yml)
+[![Test CI](https://github.com/ValKmjolnir/Nasal-Interpreter/actions/workflows/test.yml/badge.svg)](https://github.com/ValKmjolnir/Nasal-Interpreter/actions/workflows/test.yml)
+
+> 这篇文档包含多语言版本: [__中文__](../doc/README_zh.md) | [__English__](../README.md)
+
+## __目录__
+
+* [__简介__](#简介)
+* [__下载__](#下载)
+* [__编译__](#编译)
+* [__使用方法__](#使用方法)
+* [__教程__](../doc/tutorial_zh.md)
+* [__发行日志__](../doc/dev_zh.md#发行日志)
+* [__开发历史__](../doc/dev_zh.md)
+* [__测试数据__](../doc/benchmark.md)
+* [__特殊之处__](#与andy解释器的不同之处)
+* [__堆栈追踪信息__](#堆栈追踪信息)
+* [__调试器__](#调试器)
+* [__交互解释器__](#交互解释器)
+
+__如果有好的意见或建议，欢迎联系我们!__
+
+- __lhk101lhk101@qq.com__ (ValKmjolnir)
+- __sidi.liang@gmail.com__ (Sidi)
+
+## __简介__
+
+![star](https://img.shields.io/github/stars/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
+![fork](https://img.shields.io/github/forks/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
+![issue](https://img.shields.io/github/issues/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
+![pr](https://img.shields.io/github/issues-pr/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
+
+[Nasal](http://wiki.flightgear.org/Nasal_scripting_language)
+是一款语法与 ECMAscript 相似的编程语言，并作为脚本语言被著名开源飞行模拟器 [FlightGear](https://www.flightgear.org/) 所使用。
+该语言的设计者为 [Andy Ross](https://github.com/andyross)。
+该解释器由 [ValKmjolnir](https://github.com/ValKmjolnir) 使用 `C++`(`-std=c++17`)重新实现。非常感谢 Andy 为我们设计了这个神奇且简洁的编程语言: [Andy Ross 的 nasal 解释器](https://github.com/andyross/nasal)。
+
+该项目旧版本使用 __MIT__ 协议开源 (2019/7 ~ 2021/5/4 ~ 2023/5)，从 2023/6 开始新版本使用 __GPL v2__ 协议。
+
+### __为什么重新写 Nasal 解释器?__
+
+2019 年夏天，[FGPRC](https://www.fgprc.org.cn/) 的成员吐槽，在 Flightgear 中提供的 nasal 控制台中进行调试很不方便，仅仅是想检查语法错误，也要花时间打开软件等待加载进去后调试。所以我就写了一个新的解释器来帮助检查语法错误和运行时错误。
+
+我编写了 nasal 的词法分析器和语法分析器，以及一个全新的字节码虚拟机，并用这个运行时来进行 nasal 程序的调试。我们发现使用这个解释器来检测语法和运行时错误极大的提高了效率。
+
+你也可以使用这个语言来写一些与 Flightgear 运行环境无关的有趣的程序，并用这个解释器来执行。你也可以让解释器来调用你自己编写的模块，使它成为项目中一个非常有用的工具。
+
+## __下载__
+
+现在支持下载预览版(Nightly Build)。
+Windows 平台的预览版解释器现在还没配置相关流水线，
+请耐心等候或者直接在本地编译。
+我们提供了一份 Cmake 文件，可以很方便地在 Visual Studio 中编译:
+
+* [MacOS-nightly-build](https://github.com/ValKmjolnir/Nasal-Interpreter/releases/tag/next_macOS)
+* [Linux-nightly-build](https://github.com/ValKmjolnir/Nasal-Interpreter/releases/tag/next_linux_x86_64)
+* [Windows-nightly-build](#下载) [施工中]
+
+## __编译__
+
+![g++](https://img.shields.io/badge/GNU-g++-A42E2B?style=flat-square&logo=GNU)
+![clang++](https://img.shields.io/badge/LLVM-clang++-262D3A?style=flat-square&logo=LLVM)
+![vs](https://img.shields.io/badge/Visual_Studio-MSVC-5C2D91?style=flat-square&logo=visualstudio)
+
+下载最新代码包编译，项目非常小巧, 没有使用任何第三方库，只需要这两样即可编译: C++ 编译器以及 make 程序。
+
+### __Windows 平台 (MinGW-w64)__
+
+确保 thread model 是 `posix thread model`, 否则没有 thread 库。
+
+> mkdir build;
+> mingw32-make nasal.exe -j4
+
+### __Windows 平台 (Vistual Studio)__
+
+项目提供了 [__CMakeLists.txt__](../CMakeLists.txt) 用于在`Visual Studio`中创建项目。
+最近我们总结了命令行编译的方法 [__如何在 Windows 平台编译 Nasal-Interpreter__](./windows-build.md)。
+
+### __Linux / macOS / Unix 平台__
+
+![linux](https://img.shields.io/badge/GNU-Linux-green?style=flat-square&logo=GNU)
+![macOS](https://img.shields.io/badge/Apple%20Inc.-MacOS-green?style=flat-square&logo=apple)
+
+> make -j
+
+你也可以通过如下的其中一行命令来指定你想要使用的编译器：
+
+> make nasal CXX=... -j
+
+## __使用方法__
+
+![usage](../doc/gif/help.gif)
+
+如果你是 `Windows` 用户且想正常输出 unicode，可以这样开启 unicode 代码页:
+
+```javascript
+if (os.platform()=="windows") {
+    system("chcp 65001");
+}
+```
+
+或者使用 `std.runtime.windows.set_utf8_output()`:
+
+```javascript
+use std.runtime;
+
+runtime.windows.set_utf8_output();
+```
+
+## __与andy解释器的不同之处__
+
+![error](../doc/gif/error.gif)
+
+<details><summary>必须用 var 定义变量</summary>
+
+这个解释器使用了更加严格的语法检查来保证你可以更轻松地debug。这是非常有必要的严格，否则debug会非常痛苦。
+同样的，flightgear 内置的 nasal 解释器也采取了类似的措施，所以使用变量前务必用 `var` 先进行声明。
+
+在Andy的解释器中:
+
+```javascript
+foreach(i; [0, 1, 2, 3])
+    print(i)
+```
+
+这个程序可以正常运行。然而这个`i`标识符实际上在这里是被第一次定义，而且没有使用`var`。我认为这样的设计很容易让使用者迷惑。他们可能都没有发现这里实际上是第一次定义`i`的地方。没有使用`var`的定义会让程序员认为这个`i`也许是在别的地方定义的。
+
+所以在这个解释器中，我直接使用严格的语法检查方法来强行要求用户必须要使用`var`来定义新的变量或者迭代器。如果你忘了加这个关键字，那么你就会得到这个:
+
+```javascript
+code: undefined symbol "i"
+ --> test.nas:1:9
+  | 
+1 | foreach(i; [0, 1, 2, 3])
+  |         ^ undefined symbol "i"
+
+code: undefined symbol "i"
+ --> test.nas:2:11
+  | 
+2 |     print(i)
+  |           ^ undefined symbol "i"
+```
+</details>
+
+## __堆栈追踪信息__
+
+![stackoverflow](../doc/gif/stackoverflow.gif)
+
+当解释器崩溃时,它会反馈错误产生过程的堆栈追踪信息:
+
+<details><summary>内置函数 die</summary>
+
+`die`函数用于直接抛出错误并终止执行。
+
+```javascript
+func() {
+    println("hello");
+    die("error occurred this line");
+    return;
+}();
+```
+
+```javascript
+hello
+[vm] error: error occurred this line
+[vm] error: error occurred in native function
+
+call trace (main)
+  call func@0x557513935710() {entry: 0x850}
+
+trace back (main)
+  0x000547     4c 00 00 16     callb   0x16 <__die@0x557512441780>(std/lib.nas:150)
+  0x000856     4a 00 00 01     callfv  0x1(a.nas:3)
+  0x00085a     4a 00 00 00     callfv  0x0(a.nas:5)
+
+stack (0x5575138e8c40, limit 10, total 14)
+  0x00000d    | null |
+  0x00000c    | pc   | 0x856
+  0x00000b    | addr | 0x5575138e8c50
+  0x00000a    | nil  |
+  0x000009    | nil  |
+  0x000008    | str  | <0x5575138d9190> error occurred t...
+  0x000007    | nil  |
+  0x000006    | func | <0x5575139356f0> entry:0x850
+  0x000005    | pc   | 0x85a
+  0x000004    | addr | 0x0
+```
+
+</details>
+
+<details><summary>栈溢出</summary>
+
+这是一个会导致栈溢出的例子:
+
+```javascript
+func(f) {
+    return f(f);
+}(
+    func(f) {
+        f(f);
+    }
+)();
+```
+
+```javascript
+[vm] error: stack overflow
+
+call trace (main)
+  call func@0x564106058620(f) {entry: 0x859}
+   --> 583 same call(s)
+  call func@0x5641060586c0(f) {entry: 0x851}
+
+trace back (main)
+  0x000859     45 00 00 01     calll   0x1(a.nas:5)
+  0x00085b     4a 00 00 01     callfv  0x1(a.nas:5)
+  0x00085b     582 same call(s)
+  0x000853     4a 00 00 01     callfv  0x1(a.nas:2)
+  0x00085f     4a 00 00 01     callfv  0x1(a.nas:3)
+
+stack (0x56410600be00, limit 10, total 4096)
+  0x000fff    | func | <0x564106058600> entry:0x859
+  0x000ffe    | pc   | 0x85b
+  0x000ffd    | addr | 0x56410601bd20
+  0x000ffc    | nil  |
+  0x000ffb    | nil  |
+  0x000ffa    | func | <0x564106058600> entry:0x859
+  0x000ff9    | nil  |
+  0x000ff8    | func | <0x564106058600> entry:0x859
+  0x000ff7    | pc   | 0x85b
+  0x000ff6    | addr | 0x56410601bcb0
+```
+
+</details>
+
+<details><summary>运行时错误</summary>
+
+如果在执行的时候出现错误，程序会直接终止执行:
+
+```javascript
+func() {
+    return 0;
+}()[1];
+```
+
+```javascript
+[vm] error: must call a vector/hash/string but get number
+
+trace back (main)
+  0x000854     47 00 00 00     callv   0x0(a.nas:3)
+
+stack (0x564993f462b0, limit 10, total 1)
+  0x000000    | num  | 0
+```
+
+</details>
+
+<details><summary>详细的崩溃信息</summary>
+
+使用命令 __`-d`__ 或 __`--detail`__ 后，trace back信息会包含更多的细节内容:
+
+```javascript
+hello
+[vm] error: error occurred this line
+[vm] error: error occurred in native function
+
+call trace (main)
+  call func@0x55dcb5b8fbf0() {entry: 0x850}
+
+trace back (main)
+  0x000547     4c 00 00 16     callb   0x16 <__die@0x55dcb3c41780>(std/lib.nas:150)
+  0x000856     4a 00 00 01     callfv  0x1(a.nas:3)
+  0x00085a     4a 00 00 00     callfv  0x0(a.nas:5)
+
+stack (0x55dcb5b43120, limit 10, total 14)
+  0x00000d    | null |
+  0x00000c    | pc   | 0x856
+  0x00000b    | addr | 0x55dcb5b43130
+  0x00000a    | nil  |
+  0x000009    | nil  |
+  0x000008    | str  | <0x55dcb5b33670> error occurred t...
+  0x000007    | nil  |
+  0x000006    | func | <0x55dcb5b8fbd0> entry:0x850
+  0x000005    | pc   | 0x85a
+  0x000004    | addr | 0x0
+
+registers (main)
+  [pc    ]    | pc   | 0x547
+  [global]    | addr | 0x55dcb5b53130
+  [local ]    | addr | 0x55dcb5b43190
+  [memr  ]    | addr | 0x0
+  [canary]    | addr | 0x55dcb5b53110
+  [top   ]    | addr | 0x55dcb5b431f0
+  [funcr ]    | func | <0x55dcb5b65620> entry:0x547
+  [upval ]    | nil  |
+
+global (0x55dcb5b53130)
+  0x000000    | nmspc| <0x55dcb5b33780> namespace [95 val]
+  0x000001    | vec  | <0x55dcb5b64c20> [0 val]
+  ...
+  0x00005e    | func | <0x55dcb5b8fc70> entry:0x846
+
+local (0x55dcb5b43190 <+7>)
+  0x000000    | nil  |
+  0x000001    | str  | <0x55dcb5b33670> error occurred t...
+  0x000002    | nil  |
+```
+
+</details>
+
+## __调试器__
+
+![dbg](../doc/gif/dbg.gif)
+
+在`v8.0`版本中我们添加了调试器。
+使用这个命令`./nasal -dbg xxx.nas`来启用调试器，接下来调试器会打开文件并输出以下内容:
+
+<details><summary>展开</summary>
+
+```javascript
+source code:
+--> var fib = func(x) {
+        if (x<2) return x;
+        return fib(x-1)+fib(x-2);
+    }
+    for (var i=0;i<31;i+=1)
+        print(fib(i),'\n');
+
+
+next bytecode:
+    0x0003a8    07:00 00 00 00 00 00 00 00     pnil    0x0 (std/lib.nas:413)
+    0x0003a9    56:00 00 00 00 00 00 00 00     ret     0x0 (std/lib.nas:413)
+    0x0003aa    03:00 00 00 00 00 00 00 56     loadg   0x56 (std/lib.nas:413)
+--> 0x0003ab    0b:00 00 00 00 00 00 03 af     newf    0x3af (test/fib.nas:1)
+    0x0003ac    02:00 00 00 00 00 00 00 03     intl    0x3 (test/fib.nas:1)
+    0x0003ad    0d:00 00 00 00 00 00 00 22     para    0x22 (x) (test/fib.nas:1)
+    0x0003ae    3e:00 00 00 00 00 00 03 be     jmp     0x3be (test/fib.nas:1)
+    0x0003af    45:00 00 00 00 00 00 00 01     calll   0x1 (test/fib.nas:2)
+
+vm stack (0x7fca7e9f1010, limit 16, total 0)
+>>
+```
+
+</details>
+
+如果需要查看命令的使用方法，可以输入`h`获取帮助信息。
+
+当运行调试器的时候，你可以看到现在的操作数栈上到底有些什么数据。
+这些信息可以帮助你调试，同时也可以帮助你理解这个虚拟机是如何工作的:
+
+<details><summary>展开</summary>
+
+```javascript
+source code:
+    var fib = func(x) {
+-->     if (x<2) return x;
+        return fib(x-1)+fib(x-2);
+    }
+    for (var i=0;i<31;i+=1)
+        print(fib(i),'\n');
+
+
+next bytecode:
+    0x0003a8    07:00 00 00 00 00 00 00 00     pnil    0x0 (std/lib.nas:413)
+    0x0003a9    56:00 00 00 00 00 00 00 00     ret     0x0 (std/lib.nas:413)
+    0x0003aa    03:00 00 00 00 00 00 00 56     loadg   0x56 (std/lib.nas:413)
+    0x0003ab    0b:00 00 00 00 00 00 03 af     newf    0x3af (test/fib.nas:1)
+    0x0003ac    02:00 00 00 00 00 00 00 03     intl    0x3 (test/fib.nas:1)
+    0x0003ad    0d:00 00 00 00 00 00 00 22     para    0x22 (x) (test/fib.nas:1)
+    0x0003ae    3e:00 00 00 00 00 00 03 be     jmp     0x3be (test/fib.nas:1)
+--> 0x0003af    45:00 00 00 00 00 00 00 01     calll   0x1 (test/fib.nas:2)
+
+vm stack (0x7fca7e9f1010, limit 16, total 8)
+  0x000007    | pc   | 0x3c7
+  0x000006    | addr | 0x0
+  0x000005    | nil  |
+  0x000004    | nil  |
+  0x000003    | num  | 0
+  0x000002    | nil  |
+  0x000001    | nil  |
+  0x000000    | func | <0x5573f66ef5f0> func(elems...) {..}
+>>
+```
+
+</details>
+
+## 交互解释器
+
+v11.0 版本新增了交互式解释器 (REPL)，使用如下命令开启：
+
+> nasal -r
+
+接下来就可以随便玩了~
+
+```bash
+[nasal-repl] Initializating enviroment...
+[nasal-repl] Initialization complete.
+
+Nasal REPL interpreter version 11.0 (Oct  7 2023 17:28:31)
+.h, .help   | show help
+.e, .exit   | quit the REPL
+.q, .quit   | quit the REPL
+.c, .clear  | clear the screen
+.s, .source | show source code
+
+>>>
+```
+
+试试引入 `std/json.nas` 模块 ~
+
+```bash
+[nasal-repl] Initializating enviroment...
+[nasal-repl] Initialization complete.
+
+Nasal REPL interpreter version 11.1 (Nov  1 2023 23:37:30)
+.h, .help   | show help
+.e, .exit   | quit the REPL
+.q, .quit   | quit the REPL
+.c, .clear  | clear the screen
+.s, .source | show source code
+
+>>> use std.json;
+{stringify:func(..) {..},parse:func(..) {..}}
+
+>>> 
+```
+## __Web 界面__
+
+现已提供基于 Web 的库以及示例界面，您可以直接在浏览器中编写和运行 Nasal 代码。该界面包括代码编辑器和交互式 REPL（未完成）。
+
+### __Web 代码编辑器__
+
+- **语法高亮:** 使用 CodeMirror 提供增强的编码体验。
+- **错误高亮和格式化:** 清晰显示语法和运行时错误。
+- **示例程序:** 预加载的示例，帮助您快速上手。
+- **执行时间显示选项:** 可选择查看代码执行所需时间。
+- **可配置的执行时间限制:** 设置时间限制以防止代码长时间运行。
+- **提示：** 在线解释器的安全性尚未得到广泛测试，建议配合沙盒机制等安全措施使用。
+
+### __Web REPL__
+
+- **重要提示:** REPL 中的代码执行时间限制尚未正确实现。此 REPL 库目前不稳定，请勿在生产环境中使用。
+- **交互式命令行界面:** 在浏览器中体验熟悉的 REPL 环境。
+- **多行输入支持:** 使用 `>>>` 和 `...` 提示符无缝输入多行代码。
+- **命令历史导航:** 使用箭头键轻松浏览命令历史。
+- **格式化的错误处理:** 接收清晰且格式化的错误消息，助力调试。
+- **快速测试的示例代码片段:** 访问并运行示例代码片段，快速测试功能。
+
+### __运行 Web 界面__
+
+1. **构建 Nasal 共享库:**
+
+    ```bash
+    cmake -DBUILD_SHARED_LIBS=ON .
+    make nasal-web
+    ```
+
+2. **设置并运行 Web 应用:**
+
+    **代码编辑器:**
+
+    ```bash
+    cd nasal-web-app
+    npm install
+    node server.js
+    ```
+
+    在浏览器中访问 `http://127.0.0.1:3000/` 以使用代码编辑器。
+
+    **REPL:**
+
+    ```bash
+    cd nasal-web-app
+    npm install
+    node server_repl.js
+    ```
+
+    在浏览器中访问 `http://127.0.0.1:3001/repl.html` 以使用 REPL 界面。
+
+---

doc/benchmark.md

@@ -0,0 +1,122 @@
+# __Benchmark__
+
+![benchmark](../doc/pic/benchmark.png)
+
+## version 6.5 (i5-8250U windows10 2021/6/19)
+
+running time and gc time:
+
+|file|call gc|total time|gc time|
+|:----|:----|:----|:----|
+|pi.nas|12000049|0.593s|0.222s|
+|fib.nas|10573747|2.838s|0.187s|
+|bp.nas|4419829|1.99s|0.18s|
+|bigloop.nas|4000000|0.419s|0.039s|
+|mandelbrot.nas|1044630|0.433s|0.041s|
+|life.nas|817112|8.557s|0.199s|
+|ascii-art.nas|45612|0.48s|0.027s|
+|calc.nas|8089|0.068s|0.006s|
+|quick_sort.nas|2768|0.107s|0s|
+|bfs.nas|2471|1.763s|0.003s|
+
+operands calling frequency:
+
+|file|1st|2nd|3rd|4th|5th|
+|:----|:----|:----|:----|:----|:----|
+|pi.nas|callg|pop|mcallg|pnum|pone|
+|fib.nas|calll|pnum|callg|less|jf|
+|bp.nas|calll|callg|pop|callv|addeq|
+|bigloop.nas|pnum|less|jf|callg|pone|
+|mandelbrot.nas|callg|mult|loadg|pnum|pop|
+|life.nas|calll|callv|pnum|jf|callg|
+|ascii-art.nas|calll|pop|mcalll|callg|callb|
+|calc.nas|calll|pop|pstr|mcalll|jmp|
+|quick_sort.nas|calll|pop|jt|jf|less|
+|bfs.nas|calll|pop|callv|mcalll|jf|
+
+operands calling total times:
+
+|file|1st|2nd|3rd|4th|5th|
+|:----|:----|:----|:----|:----|:----|
+|pi.nas|6000004|6000003|6000000|4000005|4000002|
+|fib.nas|17622792|10573704|7049218|7049155|7049155|
+|bp.nas|7081480|4227268|2764676|2617112|2065441|
+|bigloop.nas|4000001|4000001|4000001|4000001|4000000|
+|mandelbrot.nas|1519632|563856|290641|286795|284844|
+|life.nas|2114371|974244|536413|534794|489743|
+|ascii-art.nas|37906|22736|22402|18315|18292|
+|calc.nas|191|124|109|99|87|
+|quick_sort.nas|16226|5561|4144|3524|2833|
+|bfs.nas|24707|16297|14606|14269|8672|
+
+## version 7.0 (i5-8250U ubuntu-WSL on windows10 2021/6/29)
+
+running time:
+
+|file|total time|info|
+|:----|:----|:----|
+|pi.nas|0.15625s|great improvement|
+|fib.nas|0.75s|great improvement|
+|bp.nas|0.4218s(7162 epoch)|good improvement|
+|bigloop.nas|0.09375s|great improvement|
+|mandelbrot.nas|0.0312s|great improvement|
+|life.nas|8.80s(windows) 1.25(ubuntu WSL)|little improvement|
+|ascii-art.nas|0.015s|little improvement|
+|calc.nas|0.0468s|little improvement|
+|quick_sort.nas|0s|great improvement|
+|bfs.nas|0.0156s|great improvement|
+
+## version 8.0 (R9-5900HX ubuntu-WSL 2022/1/23)
+
+running time:
+
+|file|total time|info|
+|:----|:----|:----|
+|bf.nas|1100.19s||
+|mandel.nas|28.98s||
+|life.nas|0.56s|0.857s(windows)|
+|ycombinator.nas|0.64s||
+|fib.nas|0.28s||
+|bfs.nas|0.156s|random result|
+|pi.nas|0.0625s||
+|bigloop.nas|0.047s||
+|calc.nas|0.03125s|changed test file|
+|mandelbrot.nas|0.0156s||
+|ascii-art.nas|0s||
+|quick_sort.nas|0s||
+
+## version 9.0 (R9-5900HX ubuntu-WSL 2022/2/13)
+
+running time:
+
+|file|total time|info|
+|:----|:----|:----|
+|bf.nas|276.55s|great improvement|
+|mandel.nas|28.16s||
+|ycombinator.nas|0.59s||
+|life.nas|0.2s|0.649s(windows)|
+|fib.nas|0.234s|little improvement|
+|bfs.nas|0.14s|random result|
+|pi.nas|0.0625s||
+|bigloop.nas|0.047s||
+|calc.nas|0.0469s|changed test file|
+|quick_sort.nas|0.016s|changed test file:100->1e4|
+|mandelbrot.nas|0.0156s||
+|ascii-art.nas|0s||
+
+`bf.nas` is a very interesting test file that there is a brainfuck interpreter written in nasal.
+And we use this bf interpreter to draw a mandelbrot set.
+
+In 2022/2/17 update we added `\e` into the lexer. And the `bfcolored.nas` uses this special ASCII code. Here is the result:
+
+![mandelbrot](../doc/pic/mandelbrot.png)
+
+## More Nasal Generated Pictures
+
+|Mandelbrot Set|Mandelbrot Set|Julia Set|
+|:----:|:----:|:----:|
+|[mandelbrotset.nas](../test/mandelbrotset.nas)|[mandelbrotset.nas](../test/mandelbrotset.nas)|[juliaset.nas](../test/juliaset.nas)|
+|![mandelbrotset](../doc/pic/mandelbrotset.png)|![mandelbrotset_reverse](../doc/pic/mandelbrotset_reverse.png)|![juliaset](../doc/pic/juliaset.png)|
+|__Burning Ship__|__Burning Ship__|__Feigenbaum__|
+|[burningship.nas](../test/burningship.nas)|[burningship.nas](../test/burningship.nas)|[feigenbaum.nas](../test/feigenbaum.nas)|
+|![burningship](../doc/pic/burningship.png)|![burningship_reverse](../doc/pic/burningship_reverse.png)|![feigenbaum](../doc/pic/feigenbaum.png)|

doc/dev.md

@@ -0,0 +1,710 @@
+# __Development History__
+
+![buringship](./pic/burningship.png)
+
+## __Contents__
+
+* [__Parser__](#parser)
+  * [v1.0](#version-10-parser-last-update-20191014)
+* [__Abstract Syntax Tree__](#abstract-syntax-tree)
+  * [v1.2](#version-12-ast-last-update-20191031)
+  * [v2.0](#version-20-ast-last-update-2020831)
+  * [v3.0](#version-30-ast-last-update-20201023)
+  * [v5.0](#version-50-ast-last-update-202137)
+  * [v11.0](#version-110-ast-latest)
+* [__Bytecode VM__](#bytecode-virtual-machine)
+  * [v4.0](#version-40-vm-last-update-20201217)
+  * [v5.0](#version-50-vm-last-update-202137)
+  * [v6.0](#version-60-vm-last-update-202161)
+  * [v6.5](#version-65-vm-last-update-2021624)
+  * [v7.0](#version-70-vm-last-update-2021108)
+  * [v8.0](#version-80-vm-last-update-2022212)
+  * [v9.0](#version-90-vm-last-update-2022518)
+  * [v10.0](#version-100-vm-last-update-2022816)
+* [__Release Notes__](#release-notes)
+  * [v8.0](#version-80-release)
+  * [v11.0](#version-110-release)
+  * [v11.1](#version-111-release)
+
+## __Parser__
+
+`LL(1)` parser with special check.
+
+```javascript
+(var a,b,c)=[{b:nil},[1,2],func return 0;];
+(a.b,b[0],c)=(1,2,3);
+```
+
+These two expressions have the same first set,so `LL(1)` is useless for this language. We add some special checks in it.
+
+Problems mentioned above have been solved for a long time, but recently i found a new problem here:
+
+```javascript
+var f = func(x, y, z) { return x + y + z }
+(a, b, c) = (0, 1, 2);
+```
+
+This will be recognized as this:
+
+```javascript
+var f = func(x, y, z) { return x + y + z }(a, b, c)
+= (0, 1, 2);
+```
+
+and causes fatal syntax error.
+And i tried this program in flightgear nasal console.
+It also found this is a syntax error.
+I think this is a serious design fault.
+To avoid this syntax error, change program like this, just add a semicolon:
+
+```javascript
+var f = func(x, y, z) { return x + y + z };
+                                          ^ here
+(a, b, c) = (0, 1, 2);
+```
+
+### version 1.0 parser (last update 2019/10/14)
+
+First fully functional version of parser.
+
+Before version 1.0,i tried many times to create a correct parser.
+
+Finally i learned `LL(1)` and `LL(k)` and wrote a parser for math formulas in version 0.16(last update 2019/9/14).
+
+In version 0.17(2019/9/15) 0.18(2019/9/18) 0.19(2019/10/1)i was playing the parser happily and after that i wrote version 1.0.
+
+__This project began at 2019/7/25__.
+
+## __Abstract Syntax Tree__
+
+### version 1.2 ast (last update 2019/10/31)
+
+The ast has been completed in this version.
+
+### version 2.0 ast (last update 2020/8/31)
+
+A completed ast-interpreter with unfinished lib functions.
+
+### version 3.0 ast (last update 2020/10/23)
+
+The ast is refactored and is now easier to read and maintain.
+
+Ast-interpreter uses new techniques so it can run codes more efficiently.
+
+Now you can add your own functions as builtin-functions in this interpreter!
+
+I decide to save the ast interpreter after releasing v4.0. Because it took me a long time to think and write...
+
+### version 5.0 ast (last update 2021/3/7)
+
+I change my mind.
+AST interpreter leaves me too much things to do.
+
+If i continue saving this interpreter,
+it will be harder for me to make the bytecode vm become more efficient.
+
+### version 11.0 ast (latest)
+
+Change ast framework. Now we use visitor pattern.
+
+## __Bytecode Virtual Machine__
+
+![op](../doc/gif/opcode.gif)
+
+### version 4.0 vm (last update 2020/12/17)
+
+I have just finished the first version of bytecode-interpreter.
+
+This interpreter is still in test.
+After this test, i will release version 4.0!
+
+Now i am trying to search hidden bugs in this interpreter.
+Hope you could help me! :)
+
+There's an example of byte code below:
+
+```javascript
+for (var i=0;i<4000000;i+=1);
+```
+
+```x86asm
+.number 0
+.number 4e+006
+.number 1
+.symbol i
+0x00000000: pzero  0x00000000
+0x00000001: loadg  0x00000000 (i)
+0x00000002: callg  0x00000000 (i)
+0x00000003: pnum   0x00000001 (4e+006)
+0x00000004: less   0x00000000
+0x00000005: jf     0x0000000b
+0x00000006: pone   0x00000000
+0x00000007: mcallg 0x00000000 (i)
+0x00000008: addeq  0x00000000
+0x00000009: pop    0x00000000
+0x0000000a: jmp    0x00000002
+0x0000000b: nop    0x00000000
+```
+
+### version 5.0 vm (last update 2021/3/7)
+
+I decide to optimize bytecode vm in this version.
+
+Because it takes more than 1.5s to count i from `0` to `4000000-1`.This is not efficient at all!
+
+2021/1/23 update: Now it can count from `0` to `4000000-1` in 1.5s.
+
+### version 6.0 vm (last update 2021/6/1)
+
+Use `loadg`/`loadl`/`callg`/`calll`/`mcallg`/`mcalll` to avoid branches.
+
+Delete type `vm_scop`.
+
+Use const `vm_num` to avoid frequently new & delete.
+
+Change garbage collector from reference-counting to mark-sweep.
+
+`vapp` and `newf` operand use .num to reduce the size of `exec_code`.
+
+2021/4/3 update: Now it can count from `0` to `4e6-1` in 0.8s.
+
+2021/4/19 update: Now it can count from `0` to `4e6-1` in 0.4s.
+
+In this update i changed global and local scope from `unordered_map` to `vector`.
+
+So the bytecode generator changed a lot.
+
+```javascript
+for (var i=0;i<4000000;i+=1);
+```
+
+```x86asm
+.number 4e+006
+0x00000000: intg   0x00000001
+0x00000001: pzero  0x00000000
+0x00000002: loadg  0x00000000
+0x00000003: callg  0x00000000
+0x00000004: pnum   0x00000000 (4e+006)
+0x00000005: less   0x00000000
+0x00000006: jf     0x0000000c
+0x00000007: pone   0x00000000
+0x00000008: mcallg 0x00000000
+0x00000009: addeq  0x00000000
+0x0000000a: pop    0x00000000
+0x0000000b: jmp    0x00000003
+0x0000000c: nop    0x00000000
+```
+
+### version 6.5 vm (last update 2021/6/24)
+
+2021/5/31 update:
+
+Now gc can collect garbage correctly without re-collecting,
+which will cause fatal error.
+
+Add `builtin_alloc` to avoid mark-sweep when running a built-in function,
+which will mark useful items as useless garbage to collect.
+
+Better use setsize and assignment to get a big array,
+`append` is very slow in this situation.
+
+2021/6/3 update:
+
+Fixed a bug that gc still re-collects garbage,
+this time i use three mark states to make sure garbage is ready to be collected.
+
+Change `callf` to `callfv` and `callfh`.
+And `callfv` fetches arguments from `val_stack` directly instead of using `vm_vec`,
+a not very efficient way.
+
+Better use `callfv` instead of `callfh`,
+`callfh` will fetch a `vm_hash` from stack and parse it,
+making this process slow.
+
+```javascript
+var f = func(x, y) { return x + y; }
+f(1024, 2048);
+```
+
+```x86asm
+.number 1024
+.number 2048
+.symbol x   
+.symbol y
+0x00000000: intg   0x00000001
+0x00000001: newf   0x00000007
+0x00000002: intl   0x00000003
+0x00000003: offset 0x00000001
+0x00000004: para   0x00000000 (x)
+0x00000005: para   0x00000001 (y)
+0x00000006: jmp    0x0000000b
+0x00000007: calll  0x00000001
+0x00000008: calll  0x00000002
+0x00000009: add    0x00000000
+0x0000000a: ret    0x00000000
+0x0000000b: loadg  0x00000000
+0x0000000c: callg  0x00000000
+0x0000000d: pnum   0x00000000 (1024)
+0x0000000e: pnum   0x00000001 (2048)
+0x0000000f: callfv 0x00000002
+0x00000010: pop    0x00000000
+0x00000011: nop    0x00000000
+```
+
+2021/6/21 update: Now gc will not collect nullptr.
+And the function of assignment is complete,
+now these kinds of assignment is allowed:
+
+```javascript
+var f=func()
+{
+    var _=[{_:0},{_:1}];
+    return func(x)
+    {
+        return _[x];
+    }
+}
+var m=f();
+m(0)._=m(1)._=10;
+
+[0,1,2][1:2][0]=0;
+```
+
+In the old version,
+parser will check this left-value and tells that these kinds of left-value are not allowed(bad lvalue).
+
+But now it can work.
+And you could see its use by reading the code above.
+To make sure this assignment works correctly,
+codegen will generate byte code by `codegen::call_gen()` instead of `codegen::mcall_gen()`,
+and the last child of the ast will be generated by `codegen::mcall_gen()`.
+So the bytecode is totally different now:
+
+```x86asm
+.number 10
+.number 2
+.symbol _
+.symbol x
+0x00000000: intg   0x00000002
+0x00000001: newf   0x00000005
+0x00000002: intl   0x00000002
+0x00000003: offset 0x00000001
+0x00000004: jmp    0x00000017
+0x00000005: newh   0x00000000
+0x00000006: pzero  0x00000000
+0x00000007: happ   0x00000000 (_)
+0x00000008: newh   0x00000000
+0x00000009: pone   0x00000000
+0x0000000a: happ   0x00000000 (_)
+0x0000000b: newv   0x00000002
+0x0000000c: loadl  0x00000001
+0x0000000d: newf   0x00000012
+0x0000000e: intl   0x00000003
+0x0000000f: offset 0x00000002
+0x00000010: para   0x00000001 (x)
+0x00000011: jmp    0x00000016
+0x00000012: calll  0x00000001
+0x00000013: calll  0x00000002
+0x00000014: callv  0x00000000
+0x00000015: ret    0x00000000
+0x00000016: ret    0x00000000
+0x00000017: loadg  0x00000000
+0x00000018: callg  0x00000000
+0x00000019: callfv 0x00000000
+0x0000001a: loadg  0x00000001
+0x0000001b: pnum   0x00000000 (10.000000)
+0x0000001c: callg  0x00000001
+0x0000001d: pone   0x00000000
+0x0000001e: callfv 0x00000001
+0x0000001f: mcallh 0x00000000 (_)
+0x00000020: meq    0x00000000
+0x00000021: callg  0x00000001
+0x00000022: pzero  0x00000000
+0x00000023: callfv 0x00000001
+0x00000024: mcallh 0x00000000 (_)
+0x00000025: meq    0x00000000
+0x00000026: pop    0x00000000
+0x00000027: pzero  0x00000000
+0x00000028: pzero  0x00000000
+0x00000029: pone   0x00000000
+0x0000002a: pnum   0x00000001 (2.000000)
+0x0000002b: newv   0x00000003
+0x0000002c: slcbeg 0x00000000
+0x0000002d: pone   0x00000000
+0x0000002e: pnum   0x00000001 (2.000000)
+0x0000002f: slc2   0x00000000
+0x00000030: slcend 0x00000000
+0x00000031: pzero  0x00000000
+0x00000032: mcallv 0x00000000
+0x00000033: meq    0x00000000
+0x00000034: pop    0x00000000
+0x00000035: nop    0x00000000
+```
+
+As you could see from the bytecode above,
+`mcall`/`mcallv`/`mcallh` operands' using frequency will reduce,
+`call`/`callv`/`callh`/`callfv`/`callfh` at the opposite.
+
+And because of the new structure of `mcall`,
+`addr_stack`, a stack used to store the memory address,
+is deleted from `vm`,
+and now `vm` use `nas_val** mem_addr` to store the memory address.
+This will not cause fatal errors because the memory address is used __immediately__ after getting it.
+
+### version 7.0 vm (last update 2021/10/8)
+
+2021/6/26 update:
+
+Instruction dispatch is changed from call-threading to computed-goto(with inline function).
+After changing the way of instruction dispatch,
+there is a great improvement in `vm`.
+Now vm can run test/bigloop and test/pi in 0.2s!
+And vm runs test/fib in 0.8s on linux.
+You could see the time use data below,
+in Test data section.
+
+This version uses g++ extension "labels as values",
+which is also supported by clang++.
+(But i don't know if MSVC supports this)
+
+There is also a change in `gc`:
+`std::vector` global is deleted,
+now the global values are all stored on stack(from `val_stack+0` to `val_stack+intg-1`).
+
+2021/6/29 update:
+
+Add some instructions that execute const values:
+`op_addc`,`op_subc`,`op_mulc`,`op_divc`,`op_lnkc`,`op_addeqc`,`op_subeqc`,`op_muleqc`,`op_diveqc`,`op_lnkeqc`.
+
+Now the bytecode of test/bigloop.nas seems like this:
+
+```x86asm
+.number 4e+006
+.number 1
+0x00000000: intg   0x00000001
+0x00000001: pzero  0x00000000
+0x00000002: loadg  0x00000000
+0x00000003: callg  0x00000000
+0x00000004: pnum   0x00000000 (4000000)
+0x00000005: less   0x00000000
+0x00000006: jf     0x0000000b
+0x00000007: mcallg 0x00000000
+0x00000008: addeqc 0x00000001 (1)
+0x00000009: pop    0x00000000
+0x0000000a: jmp    0x00000003
+0x0000000b: nop    0x00000000
+```
+
+And this test file runs in 0.1s after this update.
+Most of the calculations are accelerated.
+
+Also, assignment bytecode has changed a lot.
+Now the first identifier that called in assignment will use `op_load` to assign,
+instead of `op_meq`,`op_pop`.
+
+```javascript
+var (a,b)=(1,2);
+a=b=0;
+```
+
+```x86asm
+.number 2
+0x00000000: intg   0x00000002
+0x00000001: pone   0x00000000
+0x00000002: loadg  0x00000000
+0x00000003: pnum   0x00000000 (2)
+0x00000004: loadg  0x00000001
+0x00000005: pzero  0x00000000
+0x00000006: mcallg 0x00000001
+0x00000007: meq    0x00000000 (b=2 use meq,pop->a)
+0x00000008: loadg  0x00000000 (a=b use loadg)
+0x00000009: nop    0x00000000
+```
+
+### version 8.0 vm (last update 2022/2/12)
+
+2021/10/8 update:
+
+In this version vm_nil and vm_num now is not managed by `gc`,
+this will decrease the usage of `gc::alloc` and increase the efficiency of execution.
+
+New value type is added: `vm_obj`.
+This type is reserved for user to define their own value types.
+Related API will be added in the future.
+
+Fully functional closure:
+Add new operands that get and set upvalues.
+Delete an old operand `op_offset`.
+
+2021/10/13 update:
+
+The format of output information of bytecodes changes to this:
+
+```x86asm
+0x000002f2: newf   0x2f6
+0x000002f3: intl   0x2
+0x000002f4: para   0x3e ("x")
+0x000002f5: jmp    0x309
+0x000002f6: calll  0x1
+0x000002f7: lessc  0x0 (2)
+0x000002f8: jf     0x2fb
+0x000002f9: calll  0x1
+0x000002fa: ret
+0x000002fb: upval  0x0[0x1]
+0x000002fc: upval  0x0[0x1]
+0x000002fd: callfv 0x1
+0x000002fe: calll  0x1
+0x000002ff: subc   0x1d (1)
+0x00000300: callfv 0x1
+0x00000301: upval  0x0[0x1]
+0x00000302: upval  0x0[0x1]
+0x00000303: callfv 0x1
+0x00000304: calll  0x1
+0x00000305: subc   0x0 (2)
+0x00000306: callfv 0x1
+0x00000307: add
+0x00000308: ret
+0x00000309: ret
+0x0000030a: callfv 0x1
+0x0000030b: loadg  0x32
+```
+
+2022/1/22 update:
+
+Delete `op_pone` and `op_pzero`.
+Both of them are meaningless and will be replaced by `op_pnum`.
+
+### version 9.0 vm (last update 2022/5/18)
+
+2022/2/12 update:
+
+Local values now are __stored on stack__.
+So function calling will be faster than before.
+Because in v8.0 when calling a function,
+new `vm_vec` will be allocated by `gc`, this makes gc doing mark-sweep too many times and spends a quite lot of time.
+In test file `test/bf.nas`, it takes too much time to test the file because this file has too many function calls(see test data below in table `version 8.0 (R9-5900HX ubuntu-WSL 2022/1/23)`).
+
+Upvalue now is generated when creating first new function in the local scope, using `vm_vec`.
+And after that when creating new functions, they share the same upvalue, and the upvalue will synchronize with the local scope each time creating a new function.
+
+2022/3/27 update:
+
+In this month's updates we change upvalue from `vm_vec` to `vm_upval`,
+a special gc-managed object,
+which has almost the same structure of that upvalue object in another programming language __`Lua`__.
+
+Today we change the output format of bytecode.
+New output format looks like `objdump`:
+
+```x86asm
+  0x0000029b:       0a 00 00 00 00        newh
+
+func <0x29c>:
+  0x0000029c:       0b 00 00 02 a0        newf    0x2a0
+  0x0000029d:       02 00 00 00 02        intl    0x2
+  0x0000029e:       0d 00 00 00 66        para    0x66 ("libname")
+  0x0000029f:       32 00 00 02 a2        jmp     0x2a2
+  0x000002a0:       40 00 00 00 42        callb   0x42 <__dlopen@0x41dc40>
+  0x000002a1:       4a 00 00 00 00        ret
+<0x29c>;
+
+  0x000002a2:       0c 00 00 00 67        happ    0x67 ("dlopen")
+
+func <0x2a3>:
+  0x000002a3:       0b 00 00 02 a8        newf    0x2a8
+  0x000002a4:       02 00 00 00 03        intl    0x3
+  0x000002a5:       0d 00 00 00 68        para    0x68 ("lib")
+  0x000002a6:       0d 00 00 00 69        para    0x69 ("sym")
+  0x000002a7:       32 00 00 02 aa        jmp     0x2aa
+  0x000002a8:       40 00 00 00 43        callb   0x43 <__dlsym@0x41df00>
+  0x000002a9:       4a 00 00 00 00        ret
+<0x2a3>;
+
+  0x000002aa:       0c 00 00 00 6a        happ    0x6a ("dlsym")
+```
+
+### version 10.0 vm (last update 2022/8/16)
+
+2022/5/19 update:
+
+Now we add coroutine in this runtime:
+
+```javascript
+var coroutine = {
+    create:  func(function) { return __cocreate; },
+    resume:  func(co)       { return __coresume; },
+    yield:   func(args...)  { return __coyield;  },
+    status:  func(co)       { return __costatus; },
+    running: func()         { return __corun;    }
+};
+```
+
+`coroutine.create` is used to create a new coroutine object using a function.
+But this coroutine will not run immediately.
+
+`coroutine.resume` is used to continue running a coroutine.
+
+`coroutine.yield` is used to interrupt the running of a coroutine and throw some values.
+These values will be accepted and returned by `coroutine.resume`.
+And `coroutine.yield` it self returns `vm_nil` in the coroutine function.
+
+`coroutine.status` is used to see the status of a coroutine.
+There are 3 types of status:`suspended` means waiting for running,`running` means is running,`dead` means finished running.
+
+`coroutine.running` is used to judge if there is a coroutine running now.
+
+__CAUTION:__ coroutine should not be created or running inside another coroutine.
+
+__We will explain how resume and yield work here:__
+
+When `op_callb` is called, the stack frame is like this:
+
+```C++
++----------------------+(main stack)
+| old pc(vm_ret)       | <- top[0]
++----------------------+
+| old localr(vm_addr)  | <- top[-1]
++----------------------+
+| old upvalr(vm_upval) | <- top[-2]
++----------------------+
+| local scope(var)     |
+| ...                  |
++----------------------+ <- local pointer stored in localr
+| old funcr(vm_func)   | <- old function stored in funcr
++----------------------+
+```
+
+In `op_callb`'s progress, next step the stack frame is:
+
+```C++
++----------------------+(main stack)
+| nil(vm_nil)          | <- push nil
++----------------------+
+| old pc(vm_ret)       |
++----------------------+
+| old localr(vm_addr)  |
++----------------------+
+| old upvalr(vm_upval) |
++----------------------+
+| local scope(var)     |
+| ...                  |
++----------------------+ <- local pointer stored in localr
+| old funcr(vm_func)   | <- old function stored in funcr
++----------------------+
+```
+
+Then we call `resume`, this function will change stack.
+As we can see, coroutine stack already has some values on it,
+but if we first enter it, the stack top will be `vm_ret`, and the return `pc` is `0`.
+
+So for safe running, when first calling the coroutine, `resume` will return `gc.top[0]`.
+`op_callb` will do `top[0]=resume()`, so the value does not change.
+
+```C++
++----------------------+(coroutine stack)
+| pc:0(vm_ret)         | <- now gc.top[0]
++----------------------+
+```
+
+When we call `yield`, the function will do like this.
+And we find that `op_callb` has put the `nil` at the top.
+but where is the returned `local[1]` sent?
+
+```C++
++----------------------+(coroutine stack)
+| nil(vm_nil)          | <- push nil
++----------------------+
+| old pc(vm_ret)       |
++----------------------+
+| old localr(vm_addr)  |
++----------------------+
+| old upvalr(vm_upval) |
++----------------------+
+| local scope(var)     |
+| ...                  |
++----------------------+ <- local pointer stored in localr
+| old funcr(vm_func)   | <- old function stored in funcr
++----------------------+
+```
+
+When `builtin_coyield` is finished, the stack is set to main stack,
+and the returned `local[1]` in fact is set to the top of the main stack by `op_callb`:
+
+```C++
++----------------------+(main stack)
+| return_value(var)    |
++----------------------+
+| old pc(vm_ret)       |
++----------------------+
+| old localr(vm_addr)  |
++----------------------+
+| old upvalr(vm_upval) |
++----------------------+
+| local scope(var)     |
+| ...                  |
++----------------------+ <- local pointer stored in localr
+| old funcr(vm_func)   | <- old function stored in funcr
++----------------------+
+```
+
+so the main progress feels the value on the top is the returned value of `resume`.
+but in fact the `resume`'s returned value is set on coroutine stack.
+so we conclude this:
+
+```C++
+resume (main->coroutine) return coroutine.top[0]. coroutine.top[0] = coroutine.top[0];
+yield  (coroutine->main) return a vector.         main.top[0]      = vector;
+```
+
+## __Release Notes__
+
+### __version 8.0 release__
+
+I made a __big mistake__ in `v8.0` release:
+
+in __`nasal_dbg.h:215`__: `auto canary=gc.stack+STACK_MAX_DEPTH-1;`
+
+this will cause incorrect `stackoverflow` error.
+please change it to:
+
+`canary=gc.stack+STACK_MAX_DEPTH-1;`
+
+If do not change this line, only the debugger runs abnormally. this bug is fixed in `v9.0`.
+
+Another bug is that in `nasal_err.h:class nasal_err`, we should add a constructor for this class:
+
+```C++
+    nasal_err(): error(0) {}
+```
+
+This bug is fixed in `v9.0`. So we suggest that do not use `v8.0`.
+
+### __version 11.0 release__
+
+1. Use C++ `std=c++17`.
+
+2. Change framework of ast, using visitor pattern.
+
+3. New ast structure dump info format.
+
+4. Change the way of module export, split library into different modules. Symbols begin with `_` will not be exported.
+
+5. Change `stl` to `std`.
+
+6. Add REPL interpreter.
+
+7. Improve structure of virtual machine, split global symbol stack(stores global symbols' values) and value stack(using in process).
+
+8. Delete operand `op_intg`, add operand `op_repl`.
+
+9. Add `CMakeLists.txt` for cmake user(including `Visual Studio`).
+
+10. New ghost type register process.
+
+### __version 11.1 release__
+
+1. Bug fix: debugger in v11.0 is malfunctional.
+
+2. Bug fix: symbol_finder does not check definition in foreach/forindex loop.
+
+3. Change extension syntax `import.xx.xx` to `use xx.xx`.

doc/dev_zh.md

@@ -0,0 +1,643 @@
+# __开发日志__
+
+![buringship](./pic/burningship.png)
+
+## __目录__
+
+* [__语法分析__](#语法分析)
+  * [v1.0](#version-10-parser-last-update-20191014)
+* [__抽象语法树__](#抽象语法树)
+  * [v1.2](#version-12-ast-last-update-20191031)
+  * [v2.0](#version-20-ast-last-update-2020831)
+  * [v3.0](#version-30-ast-last-update-20201023)
+  * [v5.0](#version-50-ast-last-update-202137)
+  * [v11.0](#version-110-ast-latest)
+* [__字节码虚拟机__](#字节码虚拟机)
+  * [v4.0](#version-40-vm-last-update-20201217)
+  * [v5.0](#version-50-vm-last-update-202137)
+  * [v6.0](#version-60-vm-last-update-202161)
+  * [v6.5](#version-65-vm-last-update-2021624)
+  * [v7.0](#version-70-vm-last-update-2021108)
+  * [v8.0](#version-80-vm-last-update-2022212)
+  * [v9.0](#version-90-vm-last-update-2022518)
+  * [v10.0](#version-100-vm-last-update-2022816)
+* [__发行日志__](#发行日志)
+  * [v8.0](#version-80-release)
+  * [v11.0](#version-110-release)
+  * [v11.1](#version-111-release)
+
+## __语法分析__
+
+有特殊语法检查的`LL(1)`语法分析器。
+
+```javascript
+(var a,b,c)=[{b:nil},[1,2],func return 0;];
+(a.b,b[0],c)=(1,2,3);
+```
+
+这两个表达式有同一个first集，所以纯粹的`LL(1)`很难实现这个语言的语法分析。所以我们为其添加了特殊语法检查机制。本质上还是`LL(1)`的内核。
+
+上面这个问题已经解决很久了，不过我最近发现了一个新的语法问题:
+
+```javascript
+var f = func(x, y, z) { return x + y + z }
+(a, b, c) = (0, 1, 2);
+```
+
+这种写法会被错误识别合并成下面这种:
+
+```javascript
+var f = func(x, y, z) { return x + y + z }(a, b, c)
+= (0, 1, 2);
+```
+
+语法分析器会认为这是个严重的语法错误。我在Flightgear中也测试了这个代码，它内置的语法分析器也认为这是错误语法。当然我认为这是语法设计中的一个比较严重的缺漏。为了避免这个语法问题，只需要添加一个分号就可以了:
+
+```javascript
+var f = func(x, y, z) { return x + y + z };
+                                          ^ 就是这里
+(a, b, c) = (0, 1, 2);
+```
+
+### version 1.0 parser (last update 2019/10/14)
+
+第一版功能完备的nasal语法分析器完成了。
+
+在version 1.0之前，我多次尝试构建一个正确的语法分析器但总是存在一些问题。
+
+最终我学习了`LL(1)`和`LL(k)`文法并且在version 0.16(last update 2019/9/14)中完成了一个能识别数学算式的语法分析器。
+
+在version 0.17(2019/9/15) 0.18(2019/9/18) 0.19(2019/10/1)中我只是抱着玩的心态在测试语法分析器，不过在那之后我还是完成了version 1.0的语法分析器。
+
+__该项目于2019/7/25正式开始__。
+
+## __抽象语法树__
+
+### version 1.2 ast (last update 2019/10/31)
+
+抽象语法树在这个版本初步完成。
+
+### version 2.0 ast (last update 2020/8/31)
+
+在这个版本我们基于抽象语法树实现了一个树解释器，并且完成了部分内置函数。
+
+### version 3.0 ast (last update 2020/10/23)
+
+我们重构了抽象语法树的代码，现在可以更容易地读懂代码并进行维护。
+
+这个版本的树解释器用了新的优化方式，所以可以更高效地执行代码。
+
+在这个版本用户已经可以自行添加内置函数。
+
+我想在v4.0发布之后仍然保留这个树解释器，毕竟花了很长时间才写完这坨屎。
+
+### version 5.0 ast (last update 2021/3/7)
+
+我改变想法了，树解释器给维护带来了太大的麻烦。如果想继续保留这个解释器，那么为了兼容性，字节码虚拟机的优化工作会更难推进。
+
+### version 11.0 ast (latest)
+
+改变了语法树的设计模式，采用访问者模式。
+
+## __字节码虚拟机__
+
+![op](../doc/gif/opcode.gif)
+
+### version 4.0 vm (last update 2020/12/17)
+
+我在这个版本实现了第一版字节码虚拟机。不过这个虚拟机仍然在测试中，在这次测试结束之后，我会发布v4.0发行版。
+
+现在我在找一些隐藏很深的bug。如果有人想帮忙的话，非常欢迎！:)
+
+下面是生成的字节码的样例:
+
+```javascript
+for (var i=0;i<4000000;i+=1);
+```
+
+```x86asm
+.number 0
+.number 4e+006
+.number 1
+.symbol i
+0x00000000: pzero  0x00000000
+0x00000001: loadg  0x00000000 (i)
+0x00000002: callg  0x00000000 (i)
+0x00000003: pnum   0x00000001 (4e+006)
+0x00000004: less   0x00000000
+0x00000005: jf     0x0000000b
+0x00000006: pone   0x00000000
+0x00000007: mcallg 0x00000000 (i)
+0x00000008: addeq  0x00000000
+0x00000009: pop    0x00000000
+0x0000000a: jmp    0x00000002
+0x0000000b: nop    0x00000000
+```
+
+### version 5.0 vm (last update 2021/3/7)
+
+从这个版本起，我决定持续优化字节码虚拟机。
+
+毕竟现在这玩意从`0`数到`4000000-1`要花费1.5秒。这效率完全不能忍。
+
+2021/1/23 update: 现在它确实可以在1.5秒内从`0`数到`4000000-1`了。
+
+### version 6.0 vm (last update 2021/6/1)
+
+使用`loadg`/`loadl`/`callg`/`calll`/`mcallg`/`mcalll`指令来减少分支语句的调用。
+
+删除了`vm_scop`类型。
+
+添加作为常量的`vm_num`来减少内存分配的开销。
+
+将垃圾收集器从引用计数改为了标记清理。
+
+`vapp`和`newf`开始使用先前未被使用的.num段来压缩字节码生成数量，减少生成的`exec_code`的大小。
+
+2021/4/3 update: 从`0`数到`4e6-1`只需要不到0.8秒了。
+
+2021/4/19 update: 从`0`数到`4e6-1`只需要不到0.4秒了。
+
+在这次的更新中，我把全局变量和局部变量的存储结构从`unordered_map`变为了`vector`，从而提升执行效率。所以现在生成的字节码大变样了。
+
+```javascript
+for (var i=0;i<4000000;i+=1);
+```
+
+```x86asm
+.number 4e+006
+0x00000000: intg   0x00000001
+0x00000001: pzero  0x00000000
+0x00000002: loadg  0x00000000
+0x00000003: callg  0x00000000
+0x00000004: pnum   0x00000000 (4e+006)
+0x00000005: less   0x00000000
+0x00000006: jf     0x0000000c
+0x00000007: pone   0x00000000
+0x00000008: mcallg 0x00000000
+0x00000009: addeq  0x00000000
+0x0000000a: pop    0x00000000
+0x0000000b: jmp    0x00000003
+0x0000000c: nop    0x00000000
+```
+
+### version 6.5 vm (last update 2021/6/24)
+
+2021/5/31 update:
+
+现在垃圾收集器不会错误地重复收集未使用变量了。
+
+添加了`builtin_alloc`以防止在运行内置函数的时候错误触发标记清除。
+
+建议在获取大空间数组的时候尽量使用setsize，因为`append`在被频繁调用时可能会频繁触发垃圾收集器。
+
+2021/6/3 update:
+
+修复了垃圾收集器还是会重复收集的bug，这次我设计了三个标记状态来保证垃圾是被正确收集了。
+
+将`callf`指令拆分为`callfv`和`callfh`。并且`callfv`将直接从`val_stack`获取传参，而不是先通过一个`vm_vec`把参数收集起来再传入，后者是非常低效的做法。
+
+建议更多使用`callfv`而不是`callfh`，因为`callfh`只能从栈上获取参数并整合为`vm_hash`之后才能传给该指令进行处理，拖慢执行速度。
+
+```javascript
+var f = func(x, y) { return x + y; }
+f(1024, 2048);
+```
+
+```x86asm
+.number 1024
+.number 2048
+.symbol x   
+.symbol y
+0x00000000: intg   0x00000001
+0x00000001: newf   0x00000007
+0x00000002: intl   0x00000003
+0x00000003: offset 0x00000001
+0x00000004: para   0x00000000 (x)
+0x00000005: para   0x00000001 (y)
+0x00000006: jmp    0x0000000b
+0x00000007: calll  0x00000001
+0x00000008: calll  0x00000002
+0x00000009: add    0x00000000
+0x0000000a: ret    0x00000000
+0x0000000b: loadg  0x00000000
+0x0000000c: callg  0x00000000
+0x0000000d: pnum   0x00000000 (1024)
+0x0000000e: pnum   0x00000001 (2048)
+0x0000000f: callfv 0x00000002
+0x00000010: pop    0x00000000
+0x00000011: nop    0x00000000
+```
+
+2021/6/21 update:
+
+现在垃圾收集器不会收集空指针了。并且调用链中含有函数调用的赋值语句现在也可以执行了，下面这些赋值方式是合法的:
+
+```javascript
+var f=func()
+{
+    var _=[{_:0},{_:1}];
+    return func(x)
+    {
+        return _[x];
+    }
+}
+var m=f();
+m(0)._=m(1)._=10;
+
+[0,1,2][1:2][0]=0;
+```
+
+在老版本中，语法分析器会检查左值，并且在检测到有特别调用的情况下直接告知用户这种左值是不被接受的(bad lvalue)。但是现在它可以正常运作了。为了保证这种赋值语句能正常执行，codegen模块会优先使用`codegen::call_gen()`生成前面调用链的字节码而不是全部使用 `codegen::mcall_gen()`，在最后一个调用处才会使用`codegen::mcall_gen()`。
+
+所以现在生成的相关字节码也完全不同了:
+
+```x86asm
+.number 10
+.number 2
+.symbol _
+.symbol x
+0x00000000: intg   0x00000002
+0x00000001: newf   0x00000005
+0x00000002: intl   0x00000002
+0x00000003: offset 0x00000001
+0x00000004: jmp    0x00000017
+0x00000005: newh   0x00000000
+0x00000006: pzero  0x00000000
+0x00000007: happ   0x00000000 (_)
+0x00000008: newh   0x00000000
+0x00000009: pone   0x00000000
+0x0000000a: happ   0x00000000 (_)
+0x0000000b: newv   0x00000002
+0x0000000c: loadl  0x00000001
+0x0000000d: newf   0x00000012
+0x0000000e: intl   0x00000003
+0x0000000f: offset 0x00000002
+0x00000010: para   0x00000001 (x)
+0x00000011: jmp    0x00000016
+0x00000012: calll  0x00000001
+0x00000013: calll  0x00000002
+0x00000014: callv  0x00000000
+0x00000015: ret    0x00000000
+0x00000016: ret    0x00000000
+0x00000017: loadg  0x00000000
+0x00000018: callg  0x00000000
+0x00000019: callfv 0x00000000
+0x0000001a: loadg  0x00000001
+0x0000001b: pnum   0x00000000 (10.000000)
+0x0000001c: callg  0x00000001
+0x0000001d: pone   0x00000000
+0x0000001e: callfv 0x00000001
+0x0000001f: mcallh 0x00000000 (_)
+0x00000020: meq    0x00000000
+0x00000021: callg  0x00000001
+0x00000022: pzero  0x00000000
+0x00000023: callfv 0x00000001
+0x00000024: mcallh 0x00000000 (_)
+0x00000025: meq    0x00000000
+0x00000026: pop    0x00000000
+0x00000027: pzero  0x00000000
+0x00000028: pzero  0x00000000
+0x00000029: pone   0x00000000
+0x0000002a: pnum   0x00000001 (2.000000)
+0x0000002b: newv   0x00000003
+0x0000002c: slcbeg 0x00000000
+0x0000002d: pone   0x00000000
+0x0000002e: pnum   0x00000001 (2.000000)
+0x0000002f: slc2   0x00000000
+0x00000030: slcend 0x00000000
+0x00000031: pzero  0x00000000
+0x00000032: mcallv 0x00000000
+0x00000033: meq    0x00000000
+0x00000034: pop    0x00000000
+0x00000035: nop    0x00000000
+```
+
+从上面这些字节码可以看出，`mcall`/`mcallv`/`mcallh`指令的使用频率比以前减小了一些，而`call`/`callv`/`callh`/`callfv`/`callfh`则相反。
+
+并且因为新的数据结构，`mcall`指令以及`addr_stack`，一个曾用来存储指针的栈，从`vm`中被移除。现在`vm`使用`nas_val** mem_addr`来暂存获取的内存地址。这不会导致严重的问题，因为内存空间是 __获取即使用__ 的。
+
+### version 7.0 vm (last update 2021/10/8)
+
+2021/6/26 update:
+
+指令分派方式从call-threading改为了computed-goto。在更改了指令分派方式之后，`vm`的执行效率有了非常巨大的提升。现在虚拟机可以在0.2秒内执行完`test/bigloop`和`test/pi`！并且在linux平台虚拟机可以在0.8秒内执行完`test/fib`。你可以在下面的测试数据部分看到测试的结果。
+
+这个分派方式使用了g++扩展"labels as values"，clang++目前也支持这种指令分派的实现方式。(不过MSVC支不支持就不得而知了，哈哈)
+
+`gc`中也有部分改动:
+全局变量不再用`std::vector`存储，而是全部存在操作数栈上(从`val_stack+0`到`val_stack+intg-1`)。
+
+2021/6/29 update:
+
+添加了一些直接用常量进行运算的指令:
+`op_addc`,`op_subc`,`op_mulc`,`op_divc`,`op_lnkc`,`op_addeqc`,`op_subeqc`,`op_muleqc`,`op_diveqc`,`op_lnkeqc`。
+
+现在test/bigloop.nas的字节码是这样的:
+
+```x86asm
+.number 4e+006
+.number 1
+0x00000000: intg   0x00000001
+0x00000001: pzero  0x00000000
+0x00000002: loadg  0x00000000
+0x00000003: callg  0x00000000
+0x00000004: pnum   0x00000000 (4000000)
+0x00000005: less   0x00000000
+0x00000006: jf     0x0000000b
+0x00000007: mcallg 0x00000000
+0x00000008: addeqc 0x00000001 (1)
+0x00000009: pop    0x00000000
+0x0000000a: jmp    0x00000003
+0x0000000b: nop    0x00000000
+```
+
+在这次更新之后，这个测试文件可以在0.1秒内运行结束。大多数的运算操作速度都有提升。
+
+并且赋值相关的字节码也有一些改动。现在赋值语句只包含一个标识符时，会优先调用`op_load`来赋值，而不是使用`op_meq`和`op_pop`。
+
+```javascript
+var (a,b)=(1,2);
+a=b=0;
+```
+
+```x86asm
+.number 2
+0x00000000: intg   0x00000002
+0x00000001: pone   0x00000000
+0x00000002: loadg  0x00000000
+0x00000003: pnum   0x00000000 (2)
+0x00000004: loadg  0x00000001
+0x00000005: pzero  0x00000000
+0x00000006: mcallg 0x00000001
+0x00000007: meq    0x00000000 (b=2 use meq,pop->a)
+0x00000008: loadg  0x00000000 (a=b use loadg)
+0x00000009: nop    0x00000000
+```
+
+### version 8.0 vm (last update 2022/2/12)
+
+2021/10/8 update:
+
+从这个版本开始`vm_nil`和`vm_num`不再由`gc`管理，这会大幅度降低`gc::alloc`的调用并且会大幅度提升执行效率。
+
+添加了新的数据类型: `vm_obj`。这个类型是留给用户定义他们想要的数据类型的。相关的API会在未来加入。
+
+功能完备的闭包：添加了读写闭包数据的指令。删除了老的指令`op_offset`。
+
+2021/10/13 update:
+
+字节码信息输出格式修改为如下形式:
+
+```x86asm
+0x000002f2: newf   0x2f6
+0x000002f3: intl   0x2
+0x000002f4: para   0x3e ("x")
+0x000002f5: jmp    0x309
+0x000002f6: calll  0x1
+0x000002f7: lessc  0x0 (2)
+0x000002f8: jf     0x2fb
+0x000002f9: calll  0x1
+0x000002fa: ret
+0x000002fb: upval  0x0[0x1]
+0x000002fc: upval  0x0[0x1]
+0x000002fd: callfv 0x1
+0x000002fe: calll  0x1
+0x000002ff: subc   0x1d (1)
+0x00000300: callfv 0x1
+0x00000301: upval  0x0[0x1]
+0x00000302: upval  0x0[0x1]
+0x00000303: callfv 0x1
+0x00000304: calll  0x1
+0x00000305: subc   0x0 (2)
+0x00000306: callfv 0x1
+0x00000307: add
+0x00000308: ret
+0x00000309: ret
+0x0000030a: callfv 0x1
+0x0000030b: loadg  0x32
+```
+
+2022/1/22 update:
+
+删除`op_pone`和`op_pzero`。这两个指令在目前已经没有实际意义，并且已经被`op_pnum`替代。
+
+### version 9.0 vm (last update 2022/5/18)
+
+2022/2/12 update:
+
+局部变量现在也被 __存储在栈上__。
+所以函数调用比以前也会快速很多。
+在v8.0如果你想调用一个函数，
+新的`vm_vec`将被分配出来用于模拟局部作用域，这个操作会导致标记清除过程会被频繁触发并且浪费太多的执行时间。
+在测试文件`test/bf.nas`中，这种调用方式使得大部分时间都被浪费了，因为这个测试文件包含大量且频繁的函数调用(详细数据请看测试数据一节中`version 8.0 (R9-5900HX ubuntu-WSL 2022/1/23)`)。
+
+现在闭包会在第一次在局部作用域创建新函数的时候产生，使用`vm_vec`。
+在那之后如果再创建新的函数，则他们会共享同一个闭包，这些闭包会在每次于局部作用域创建新函数时同步。
+
+2022/3/27 update:
+
+在这个月的更新中我们把闭包的数据结构从`vm_vec`换成了一个新的对象`vm_upval`，这种类型有着和另外一款编程语言 __`Lua`__ 中闭包相类似的结构。
+
+同时我们也修改了字节码的输出格式。新的格式看起来像是 `objdump`:
+
+```x86asm
+  0x0000029b:       0a 00 00 00 00        newh
+
+func <0x29c>:
+  0x0000029c:       0b 00 00 02 a0        newf    0x2a0
+  0x0000029d:       02 00 00 00 02        intl    0x2
+  0x0000029e:       0d 00 00 00 66        para    0x66 ("libname")
+  0x0000029f:       32 00 00 02 a2        jmp     0x2a2
+  0x000002a0:       40 00 00 00 42        callb   0x42 <__dlopen@0x41dc40>
+  0x000002a1:       4a 00 00 00 00        ret
+<0x29c>;
+
+  0x000002a2:       0c 00 00 00 67        happ    0x67 ("dlopen")
+
+func <0x2a3>:
+  0x000002a3:       0b 00 00 02 a8        newf    0x2a8
+  0x000002a4:       02 00 00 00 03        intl    0x3
+  0x000002a5:       0d 00 00 00 68        para    0x68 ("lib")
+  0x000002a6:       0d 00 00 00 69        para    0x69 ("sym")
+  0x000002a7:       32 00 00 02 aa        jmp     0x2aa
+  0x000002a8:       40 00 00 00 43        callb   0x43 <__dlsym@0x41df00>
+  0x000002a9:       4a 00 00 00 00        ret
+<0x2a3>;
+
+  0x000002aa:       0c 00 00 00 6a        happ    0x6a ("dlsym")
+```
+
+### version 10.0 vm (last update 2022/8/16)
+
+2022/5/19 update:
+
+在这个版本中我们给nasal加入了协程:
+
+```javascript
+var coroutine = {
+    create:  func(function) { return __cocreate; },
+    resume:  func(co)       { return __coresume; },
+    yield:   func(args...)  { return __coyield;  },
+    status:  func(co)       { return __costatus; },
+    running: func()         { return __corun;    }
+};
+```
+
+`coroutine.create`用于创建新的协程对象。不过创建之后协程并不会直接运行。
+
+`coroutine.resume`用于继续运行一个协程。
+
+`coroutine.yield`用于中断一个协程的运行过程并且抛出一些数据。这些数据会被`coroutine.resume`接收并返回。而在协程函数中`coroutine.yield`本身只返回`vm_nil`。
+
+`coroutine.status`用于查看协程的状态。协程有三种不同的状态：`suspended`挂起，`running`运行中，`dead`结束运行。
+
+`coroutine.running`用于判断当前是否有协程正在运行。
+
+__注意:__ 协程不能在其他正在运行的协程中创建。
+
+__接下来我们解释这个协程的运行原理:__
+
+当`op_callb`被执行时，栈帧如下所示:
+
+```C++
++----------------------+(主操作数栈)
+| old pc(vm_ret)       | <- top[0]
++----------------------+
+| old localr(vm_addr)  | <- top[-1]
++----------------------+
+| old upvalr(vm_upval) | <- top[-2]
++----------------------+
+| local scope(var)     |
+| ...                  |
++----------------------+ <- local pointer stored in localr
+| old funcr(vm_func)   | <- old function stored in funcr
++----------------------+
+```
+
+在`op_callb`执行过程中，下一步的栈帧如下:
+
+```C++
++----------------------+(主操作数栈)
+| nil(vm_nil)          | <- push nil
++----------------------+
+| old pc(vm_ret)       |
++----------------------+
+| old localr(vm_addr)  |
++----------------------+
+| old upvalr(vm_upval) |
++----------------------+
+| local scope(var)     |
+| ...                  |
++----------------------+ <- local pointer stored in localr
+| old funcr(vm_func)   | <- old function stored in funcr
++----------------------+
+```
+
+接着我们调用`resume`，这个函数会替换操作数栈。我们会看到，协程的操作数栈上已经保存了一些数据，但是我们首次进入协程执行时，这个操作数栈的栈顶将会是`vm_ret`，并且返回的`pc`值是`0`。
+
+首次调用时，为了保证栈顶的数据不会被破坏，`resume`会返回`gc.top[0]`。`op_callb`将会执行`top[0]=resume()`，所以栈顶的数据虽然被覆盖了一次，但是实际上还是原来的数据。
+
+```C++
++----------------------+(协程操作数栈)
+| pc:0(vm_ret)         | <- now gc.top[0]
++----------------------+
+```
+
+当我们调用`yield`的时候，该函数会执行出这个情况，我们发现`op_callb` 已经把`nil`放在的栈顶。但是应该返回的`local[1]`到底发送到哪里去了？
+
+```C++
++----------------------+(协程操作数栈)
+| nil(vm_nil)          | <- push nil
++----------------------+
+| old pc(vm_ret)       |
++----------------------+
+| old localr(vm_addr)  |
++----------------------+
+| old upvalr(vm_upval) |
++----------------------+
+| local scope(var)     |
+| ...                  |
++----------------------+ <- local pointer stored in localr
+| old funcr(vm_func)   | <- old function stored in funcr
++----------------------+
+```
+
+当`builtin_coyield`执行完毕之后，栈又切换到了主操作数栈上，这时可以看到返回的`local[1]`实际上被`op_callb`放在了这里的栈顶:
+
+```C++
++----------------------+(主操作数栈)
+| return_value(var)    |
++----------------------+
+| old pc(vm_ret)       |
++----------------------+
+| old localr(vm_addr)  |
++----------------------+
+| old upvalr(vm_upval) |
++----------------------+
+| local scope(var)     |
+| ...                  |
++----------------------+ <- local pointer stored in localr
+| old funcr(vm_func)   | <- old function stored in funcr
++----------------------+
+```
+
+所以主程序会认为顶部这个返回值好像是`resume`返回的。而实际上`resume`的返回值在协程的操作数栈顶。综上所述:
+
+```C++
+resume (main->coroutine) return coroutine.top[0]. coroutine.top[0] = coroutine.top[0];
+yield  (coroutine->main) return a vector.         main.top[0]      = vector;
+```
+
+## __发行日志__
+
+### __version 8.0 release__
+
+这个版本的发行版有个 __严重的问题__:
+
+in __`nasal_dbg.h:215`__: `auto canary=gc.stack+STACK_MAX_DEPTH-1;`
+
+这个会导致不正确的`stackoverflow`报错。因为它覆盖了原有的变量。
+请修改为:
+
+`canary=gc.stack+STACK_MAX_DEPTH-1;`
+
+如果不修改这一行，调试器运行肯定是不正常的。在`v9.0`第一个commit中我们修复了这个问题。
+
+另外一个bug在 `nasal_err.h:class nasal_err`这边，要给这个类添加一个构造函数来进行初始化，否则会出问题:
+
+```C++
+    nasal_err(): error(0) {}
+```
+
+同样这个也在`v9.0`中修复了。所以我们建议不要使用`v8.0`。
+
+### __version 11.0 release__
+
+1. 使用C++标准 `std=c++17`。
+
+2. 改变语法树设计模式，采用访问者模式。
+
+3. 全新的语法树结构输出格式。
+
+4. 改变了导出模块的方式，把主要的库分成了多个模块。以`_`开头的变量不会被导出。
+
+5. 文件夹`stl`更名为`std`。
+
+6. 添加交互式解释器 (REPL)。
+
+7. 优化虚拟机结构, 将全局数据栈 (存储全局变量的数据) 和操作数据栈 (用于运算) 分离。
+
+8. 删除`op_intg`指令，添加`op_repl`指令。
+
+9. 添加`CMakeLists.txt` (可在`Visual Studio`中使用)。
+
+10. 全新的自定义类型注册流程。
+
+### __version 11.1 release__
+
+1. Bug 修复: 修复 v11.0 的 debugger 无法启动的问题。
+
+2. Bug 修复: symbol_finder 不检查 foreach/forindex 中的迭代变量声明的问题。
+
+3. 扩展语法 `import.xx.xx` 改为 `use xx.xx`。

doc/namespace.md

@@ -0,0 +1,93 @@
+# Nasal Namespace
+
+![feigenbaum](./pic/feigenbaum.png)
+
+## Introduction
+
+In this nasal interpreter,
+we use this way below to construct namespaces:
+
+- library is linked directly with the script
+- module is wraped by a function generated by linker, and return a hash
+
+## Library
+
+Library file is linked with script file directly, like this:
+
+In `std/lib.nas`:
+
+```nasal
+var a = 1;
+```
+
+In `example.nas`:
+
+```nasal
+var b = 1;
+```
+
+At the link stage,
+in fact we put the ast of two files together to make a new ast,
+so the result is equal to:
+
+```nasal
+var a = 1;
+var b = 1;
+```
+
+## Module
+
+Modules is wraped up by a function,
+and return a hash, for example:
+
+In `std/example_module.nas`:
+
+```nasal
+var a = 1;
+var _a = 1;
+```
+
+We analysed this file and generated the ast.
+Then we find all the global symbols.
+At last we use the information of all the globals symbols in this file to generate a hash to return.
+
+So the result is equal to:
+
+```nasal
+var example_module = func {
+
+    # source code begin
+    var a = 1;
+    var _a = 1;
+
+    # source code end
+    return {
+        a: a
+        # _a begins with underscore so do not export
+    };
+}();
+```
+
+## Import a Module
+
+Here is a module named `std/example_module.nas`:
+
+```nasal
+var a = 1;
+```
+
+Then there's a script file named `test.nas`, import module in this file using this way:
+
+```nasal
+use std.example_module;
+
+println(example_module.a); # 1
+```
+
+Or this way:
+
+```nasal
+import("std/example_module.nas");
+
+println(example_module.a); # 1
+```

doc/nasal-http-test-web.html

@@ -0,0 +1,172 @@
+<!DOCTYPE html>
+    <head>
+        <title> nasal-http-test-web </title>
+        <meta charset="utf-8">
+        <meta author="ValKmjolnir">
+        <style>
+            body{
+                background: white;
+                width: 60%;
+            }
+            pre{
+                background: #303030;
+                font-family: 'Courier New', Courier, monospace;
+                font-size: small;
+                color: #d4d4d4;
+            }
+            h1,h2,h3{
+                padding: 5px;
+                background-color: #555588;
+                font-family: Arial, Helvetica, sans-serif;
+                color: white;
+            }
+            p{
+                margin-left: 15px;
+            }
+            div.badges{
+                text-align: center;
+            }
+            tr{
+                vertical-align: top;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>&nbsp;Nasal | Not another scripting language!</h1>
+        <img src="/doc/pic/social.png" width="900" height="400" style="margin-left: 15px;"><br /></img>
+        <div class="badges">
+            <a href="https://github.com/ValKmjolnir/Nasal-Interpreter"><img src="https://img.shields.io/github/languages/code-size/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github"></img></a>
+            <a href="https://github.com/ValKmjolnir/Nasal-Interpreter"><img src="https://img.shields.io/github/v/release/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github"></img></a>
+            <a href="https://github.com/ValKmjolnir/Nasal-Interpreter"><img src="https://img.shields.io/badge/dev-v11.2-blue?style=flat-square&logo=github"></img></a>
+            <a href="https://github.com/ValKmjolnir/Nasal-Interpreter"><img src="https://img.shields.io/badge/license-GPLv2-green?style=flat-square&logo=github"><br/></img></a>
+        </div>
+        <h2>&nbsp;Introduction | 介绍</h2>
+        <text>
+            <p>
+                Hello, this is a simple HTML document just for test. This simple http server is written in nasal.
+                Nasal is an ECMAscript-like programming language that used in Flightgear designed by Andy Ross.<br/>
+            </p>
+            <p>
+                这是个用于测试的简易HTML文档。该http服务器是用nasal编写的。Nasal是一款用于飞行模拟器Flightgear的、类似ECMAscript的编程语言。该语言由Andy Ross设计完成。
+            </p>
+            <p>
+                The interpreter is totally rewritten by <a href="https://github.com/ValKmjolnir">ValKmjolnir</a> using C++(-std=c++11) without reusing the code in Andy Ross's nasal interpreter.
+                But we really appreciate that Andy created this amazing programming language and his interpreter project.
+                Now this project uses <a href="/license">GPL-2.0 license</a>.<br/>
+            </p>
+            <p>
+                这个解释器是由<a href="https://github.com/ValKmjolnir">ValKmjolnir</a>用C++11编写的，完全没有复用Andy Ross版解释器的代码。但是我们仍然非常感谢Andy为我们带来了这么一款有趣的编程语言。
+                现在这个项目使用<a href="/license">GPL-2.0协议</a>开源。
+            </p>
+        </text>
+        <h2>&nbsp;Benchmark | 执行效率</h2>
+        <img src="/doc/pic/benchmark.png" width="450" height="350"></img>
+        <img src="/doc/pic/mandelbrot.png" width="450" height="350"><br /></img>
+        <text>
+            <p>
+                Benchmark of different versions of nasal interpreter(left).
+                Beautiful picture generated by brainfuck interpreter written in nasal(right).
+            </p>
+            <p>
+                不同版本的nasal解释器执行效率图(左)。
+                nasal运行brainfuck绘制的曼德勃罗集合(右)。
+            </p>
+            <p>
+                Nasal can run this test file(test/bf.nas) to draw this picture in about 220 seconds.
+                In fact this test file cost over 2200 seconds before ver 8.0 .
+            </p>
+            <p>
+                Nasal现在可以在220秒内运行该文件(test/bf.nas)并绘制出这张图。
+                在8.0版本中这个解释器需要跑超过2200秒来绘制这张图。
+            </p>
+            <p>
+                The figure below is the feigenbaum-figure and burningship-figure generated by ppm script written in nasal.
+            </p>
+            <p>
+                下方是使用 nasal 的 ppm 生成脚本生成的 feigenbaum 和 burningship 图形。
+            </p>
+        </text>
+        <img src="/doc/pic/feigenbaum.png" width="900" height="550" style="margin-left: 15px;"><br /></img>
+        <img src="/doc/pic/burningship.png" width="900" height="550" style="margin-left: 15px;"><br /></img>
+        <h2>&nbsp;Example | 样例代码</h2>
+        <form method="get">
+            <text style="margin-left: 15px;"> </text>
+            <input type="text" name="filename" value="ascii-art.nas">
+            <input type="submit" value="search">
+        </form>
+        <table>
+            <tr>
+                <td>
+                    <ul>
+                        <li><a href="/ascii-art.nas">ascii-art.nas</a></li>
+                        <li><a href="/auto_crash.nas">auto_crash.nas</a></li>
+                        <li><a href="/bf.nas">bf.nas</a></li>
+                        <li><a href="/bfconvertor.nas">bfconvertor.nas</a></li>
+                        <li><a href="/bfs.nas">bfs.nas</a></li>
+                        <li><a href="/bigloop.nas">bigloop.nas</a></li>
+                        <li><a href="/bp.nas">bp.nas</a></li>
+                        <li><a href="/calc.nas">calc.nas</a></li>
+                        <li><a href="/choice.nas">choice.nas</a></li>
+                    </ul>
+                </td>
+                <td>
+                    <ul>
+                        <li><a href="/class.nas">class.nas</a></li>
+                        <li><a href="/coroutine.nas">coroutine.nas</a></li>
+                        <li><a href="/diff.nas">diff.nas</a></li>
+                        <li><a href="/exception.nas">exception.nas</a></li>
+                        <li><a href="/fib.nas">fib.nas</a></li>
+                        <li><a href="/filesystem.nas">filesystem.nas</a></li>
+                        <li><a href="/hexdump.nas">hexdump.nas</a></li>
+                        <li><a href="/httptest.nas">httptest.nas</a></li>
+                        <li><a href="/json.nas">json.nas</a></li>
+                    </ul>
+                </td>
+                <td>
+                    <ul>
+                        <li><a href="/leetcode1319.nas">leetcode1319.nas</a></li>
+                        <li><a href="/lexer.nas">lexer.nas</a></li>
+                        <li><a href="/life.nas">life.nas</a></li>
+                        <li><a href="/loop.nas">loop.nas</a></li>
+                        <li><a href="/mandelbrot.nas">mandelbrot.nas</a></li>
+                        <li><a href="/mandelbrotset.nas">mandelbrotset.nas</a></li>
+                        <li><a href="/mcpu.nas">mcpu.nas</a></li>
+                        <li><a href="/md5_self.nas">md5_self.nas</a></li>
+                        <li><a href="/md5compare.nas">md5compare.nas</a></li>
+                    </ul>
+                </td>
+                <td>
+                    <ul>
+                        <li><a href="/module_test.nas">module_test.nas</a></li>
+                        <li><a href="/nasal_test.nas">nasal_test.nas</a></li>
+                        <li><a href="/occupation.nas">occupation.nas</a></li>
+                        <li><a href="/pi.nas">pi.nas</a></li>
+                        <li><a href="/ppmgen.nas">ppmgen.nas</a></li>
+                        <li><a href="/prime.nas">prime.nas</a></li>
+                        <li><a href="/qrcode.nas">qrcode.nas</a></li>
+                        <li><a href="/quick_sort.nas">quick_sort.nas</a></li>
+                        <li><a href="/scalar.nas">scalar.nas</a></li>
+                    </ul>
+                </td>
+                <td>
+                    <ul>
+                        <li><a href="/snake.nas">snake.nas</a></li>
+                        <li><a href="/tetris.nas">tetris.nas</a></li>
+                        <li><a href="/trait.nas">trait.nas</a></li>
+                        <li><a href="/turingmachine.nas">turingmachine.nas</a></li>
+                        <li><a href="/utf8chk.nas">utf8chk.nas</a></li>
+                        <li><a href="/watchdog.nas">watchdog.nas</a></li>
+                        <li><a href="/wavecollapse.nas">wavecollapse.nas</a></li>
+                        <li><a href="/word_collector.nas">word_collector.nas</a></li>
+                        <li><a href="/ycombinator.nas">ycombinator.nas</a></li>
+                    </ul>
+                </td>
+            </tr>
+        </table>
+    </body>
+    <h2>&nbsp;Shutdown | 关闭服务器</h2>
+    <text>
+        <p>Click <a href="/shutdown">here</a> to shutdown http server.</p>
+        <p>Don't click <a href="/teapot">me</a> besauce i am just a teapot.</p>
+    </text>
+</html>

doc/nasal.ebnf

@@ -10,6 +10,7 @@ nil   ::= nil;
 id    ::= identifier;
 number::= number;
 string::= string;
+bool  ::= true | false;
 vector::= 
     '[' {calculation ','} ']'
 ;
@@ -20,7 +21,7 @@ hashmember::=
     id|string ':' calculation
 ;
 function::= 
-    func argument_list expressions
+    func {argument_list} exprs|expr
 ;
 argument_list::=
     '(' [{id ','} ([id '...']|{id '=' scalar ','})] ')'
@@ -35,13 +36,22 @@ expr::=
     |continue_expr
     |break_expr
 ;
-expressions::=
+exprs::=
     '{' {expr} '}'
 ;
 calculation::=
     calculation '?' calculation ':' calculation
-    |or_expr
-    |calculation ('=' | '+=' | '-=' | '*=' | '/=' | '~=') calculation
+    |bitwise_or
+    |calculation ('=' | '+=' | '-=' | '*=' | '/=' | '~=' | '^=' | '&=' | '|=') calculation
+;
+bitwise_or::=
+    bitwise_xor '|' bitwise_xor
+;
+bitwise_xor::=
+    bitwise_and '^' bitwise_and
+;
+bitwise_and::=
+    or_expr '&' or_expr
 ;
 or_expr::=
     and_expr or and_expr
@@ -59,16 +69,16 @@ multive_expr::=
     (unary|scalar) ('*' | '/') (unary|scalar)
 ;
 unary::=
-    ('-'|'!') (unary|scalar)
+    ('-'|'!'|'~') (unary|scalar)
 ;
 scalar::=
     function {call_scalar}
-    |[func] identifier {call_scalar}
     |vector {call_scalar}
     |hash {call_scalar}
     |number
     |string
     |nil
+    |bool
     |'(' calculation ')' {call_scalar}
 ;
 call_scalar::=
@@ -109,18 +119,18 @@ loop::=
     |forei_loop
 ;
 while_loop::=
-    while '(' calculation ')' expressions
+    while '(' calculation ')' exprs
 ;
 for_loop::=
-    for '(' [definition|calculation] ';' [calculation] ';' [calculation] ')' expressions
+    for '(' [definition|calculation] ';' [calculation] ';' [calculation] ')' exprs
 ;
 forei_loop::=
-    (forindex | foreach) '(' (definition | calculation) ';' calculation ')' expressions
+    (forindex | foreach) '(' (definition | calculation) ';' calculation ')' exprs
 ;
 conditional::=
-    if '(' calculation ')' expressions
-    {elsif '(' calculation ')' expressions}
-    [else expressions]
+    if '(' calculation ')' exprs
+    {elsif '(' calculation ')' exprs}
+    [else exprs]
 ;
 continue_expr::=
     continue

doc/svg/nasal.svg

@@ -0,0 +1,19 @@
+<svg width="100" height="100" viewBox="0 0 100 100" xmlns="http://www.w3.org/2000/svg">
+  <rect width="100" height="100" fill="#9eb0d8"/>
+  <g transform="translate(6,0)">
+    <g fill="#1d2c4e">
+      <!-- left side -->
+      <path d="M 10 10 L 10 80 L 20 90 L 25 90 L 25 20 L 15 10 Z"/>
+      <path d="M 10 10 L 84 84 L 84 90 L 70 90 L 10 30 Z"/>
+      <!-- right-up corner -->
+      <path d="M 30 10 L 70 50 L 70 55 L 30 15 Z" />
+      <path d="M 30 10 L 43 10 L 70 37 L 70 55 Z" />
+      <path d="M 68 10 L 68 55 L 83 55 L 83 18 L 75 10 Z" />
+      <path d="M 70 50 L 70 55 L 65 55 L 55 45 L 55 35 Z"/>
+    </g>
+    <g fill="#97363a">
+      <!-- right-down corner -->
+      <path d="M 83 60 L 83 75 L 68 60 Z" />
+    </g>
+  </g>
+</svg>

doc/svg/nasal_transparent.svg

@@ -0,0 +1,19 @@
+<svg width="100" height="100" viewBox="0 0 100 100" xmlns="http://www.w3.org/2000/svg">
+  <!-- <rect width="100" height="100" fill="#9eb0d8"/> -->
+  <g transform="translate(6,0)">
+    <g fill="#6e93e9">
+      <!-- left side -->
+      <path d="M 10 10 L 10 80 L 20 90 L 25 90 L 25 20 L 15 10 Z"/>
+      <path d="M 10 10 L 84 84 L 84 90 L 70 90 L 10 30 Z"/>
+      <!-- right-up corner -->
+      <path d="M 30 10 L 70 50 L 70 55 L 30 15 Z" />
+      <path d="M 30 10 L 43 10 L 70 37 L 70 55 Z" />
+      <path d="M 68 10 L 68 55 L 83 55 L 83 18 L 75 10 Z" />
+      <path d="M 70 50 L 70 55 L 65 55 L 55 45 L 55 35 Z"/>
+    </g>
+    <g fill="#97363a">
+      <!-- right-down corner -->
+      <path d="M 83 60 L 83 75 L 68 60 Z" />
+    </g>
+  </g>
+</svg>

doc/tutorial.md

@@ -0,0 +1,770 @@
+# <img src="./svg/nasal_transparent.svg" height="50px"/> __Tutorial__
+
+![mandelbrotset](../doc/pic/mandelbrotset.png)
+
+Nasal is __easy__ to learn.
+After reading this tutorial about 15 minutes,
+You could totally use nasal.
+
+## __Contents__
+
+* [__Basic Type__](#basic-type)
+* [__Operators__](#operators)
+* [__Definition__](#definition)
+* [__Multi-Assignment__](#multi-assignment)
+* [__Conditional Expression__](#conditional-expression)
+* [__Loop__](#loop)
+* [__Subvec__](#subvec)
+* [__Special function call__](#special-function-call)
+* [__Lambda__](#lambda)
+* [__Closure__](#closure)
+* [__Trait__](#trait)
+* [__Multi-Files/Modules Import__](#multi-filesmodules-import)
+* [__Native Functions and Module Import__](#native-functions-and-module-import)
+* [__C++ Modules (for lib developers)__](#c-modules-for-lib-developers)
+* [__Ghost Type (for lib developers)__](#ghost-type-for-lib-developers)
+
+## Basic Type
+
+__`none`__ is error type used to interrupt the execution.
+This type is not created by user program.
+
+__`nil`__ is a null type. Just like `null`.
+
+```javascript
+var spc = nil;
+```
+
+__`num`__ has 3 formats: `dec`, `hex` and `oct`. Using IEEE754 `double` to store.
+
+```javascript
+# this language use '#' to write notes
+var n = 2.71828;    # dec
+var n = 2.147e16;   # dec
+var n = 1e-10;      # dec
+var n = 0xAA55;     # hex
+var n = 0o170001;   # oct
+
+# caution: true and false also useful in nasal now
+var n = true;       # in fact n is now 1.0
+var n = false;      # in face n is now 0.0
+```
+
+__`str`__ has 3 formats. The third one is used to declare a character.
+
+```javascript
+var s = 'str';
+var s = "another string";
+var s = `c`;
+# some special characters is allowed in this language:
+'\a'; '\b'; '\e'; '\f';
+'\n'; '\r'; '\t'; '\v';
+'\0'; '\\'; '\?'; '\'';
+'\"';
+```
+
+__`vec`__ has unlimited length and can store all types of values.
+
+```javascript
+var vec = [];
+var vec = [0, nil, {}, [], func() { return 0 }];
+append(vec, 0, 1, 2);
+```
+
+__`hash`__ is a hashmap (or like a `dict` in `python`) that stores values with strings/identifiers as the key.
+
+```javascript
+var hash = {
+    member1: nil,
+    member2: "str",
+    "member3": "member\'s name can also be a string constant",
+    funct: func() {
+        return me.member2~me.member3;
+    }
+};
+```
+
+__`func`__ is a function type (in fact it is `lambda`).
+
+```javascript
+var f = func(x, y, z) {
+    return nil;
+}
+# function could be declared without parameters and `(`, `)`
+var f = func {
+    return 114514;
+}
+var f = func(x, y, z, deft = 1) {
+    return x+y+z+deft;
+}
+var f = func(args...) {
+    var sum = 0;
+    foreach(var i; args) {
+        sum += i;
+    }
+    return sum;
+}
+```
+
+__`upval`__ is used to store upvalues, used in __`vm`__ to make sure closure runs correctly.
+
+__`ghost`__ is used to store other complex `C/C++` data types.
+This type is created by native-function of nasal. If want to define a new data type, see how to add native-functions by editing code.
+
+## Operators
+
+Nasal has basic math operators `+` `-` `*` `/` and a special operator `~` that joints strings or vectors.
+
+```javascript
+1+2-(1+3)*(2+4)/(16-9);
+"str1"~"str2";
+[0]~[1]; # should be [0, 1]
+```
+
+For conditional expressions, operators `==` `!=` `<` `>` `<=` `>=` are used to compare two values.
+`and` `or` have the same function as C/C++ `&&` `||`.
+
+```javascript
+1+1 and (1<0 or 1>0);
+1<=0 and 1>=0;
+1==0 or 1!=0;
+```
+
+Unary operators `-` `!` have the same function as C/C++.
+
+```javascript
+-1;
+!0;
+```
+
+Bitwise operators `~` `|` `&` `^` have the same function as C/C++.
+
+```javascript
+# these operators will:
+# 1. convert f64 to i32 (static_cast<int32_t>)
+# 2. do the bitwise function
+
+~0x80000000; # not 2147483647
+0x8|0x1;     # or
+0x1&0x2;     # and
+0x8^0x1;     # xor
+```
+
+Operators `=` `+=` `-=` `*=` `/=` `~=` `^=` `&=` `|=` are used in assignment expressions.
+
+```javascript
+a = b = c = d = 1;
+a += 1;
+a -= 1;
+a *= 1;
+a /= 1;
+a ~= "string";
+
+a ^= 0xff;
+a &= 0xca;
+a |= 0xba;
+
+a = [0];
+a ~= [1]; # should be [0, 1]
+```
+
+Operator `??` is used to check left hand side value is `nil` or not, if not,
+return the right hand side value:
+
+```javascript
+print(nil??"should get this string");
+```
+
+The example above will print `should get this string`.
+
+Operator `?.` is used to get hash member if left hand side value is not `nil`.
+And if left hand side value is not `nil` and not `hash`,
+will cause error and exit.
+
+```javascript
+var a = nil;
+print(a?.try_get); # nil
+
+var a = {try_get: "congrats!"};
+print(a?.try_get); # "congrats!"
+```
+
+## Definition
+
+As follows.
+
+```javascript
+var a = 1;             # define single variable
+var (a, b, c) = [0, 1, 2]; # define multiple variables from a vector
+var (a, b, c) = (0, 1, 2); # define multiple variables from a tuple
+```
+
+Nasal has many special global symbols:
+
+```javascript
+globals; # hashmap including all global symbols and their values
+arg;     # in global scope, arg is the command line arguments
+         # in local scope, arg is the dynamic arguments of this function call
+```
+
+For example:
+
+```javascript
+var a = 1;
+println(globals); # will print {a:1}
+```
+
+```javascript
+# nasal a b c
+println(arg); # will print ["a", "b", "c"]
+
+func() {
+    println(arg);
+}(1, 2, 3);   # will print [1, 2, 3]
+```
+
+## Multi-assignment
+
+The last one is often used to swap two variables.
+
+```javascript
+(a, b[0], c.d) = [0, 1, 2];
+(a, b[1], c.e) = (0, 1, 2);
+(a, b) = (b, a);
+```
+
+## Conditional expression
+
+In nasal there's a new key word `elsif`.
+It has the same functions as `else if`.
+
+```javascript
+if (1) {
+    ;
+} elsif (2) {
+    ;
+} else if (3) {
+    ;
+} else {
+    ;
+}
+```
+
+## Loop
+
+While loop and for loop is simalar to C/C++.
+
+```javascript
+while (condition) {
+    continue;
+}
+for (var i = 0; i<10; i += 1) {
+    break;
+}
+```
+
+Nasal has another two kinds of loops that iterates through a vector:
+
+`forindex` will get the index of a vector. Index will be `0` to `size(elem)-1`.
+
+```javascript
+forindex(var i; elem) {
+    print(elem[i]);
+}
+```
+
+`foreach` will get the element of a vector. Element will be `elem[0]` to `elem[size(elem)-1]`.
+
+```javascript
+foreach(var i; elem) {
+    print(i);
+}
+```
+
+## Subvec
+
+Nasal provides this special syntax to help user generate a new vector by getting values by one index or getting values by indexes in a range from an old vector.
+If there's only one index in the bracket, then we will get the value directly.
+Use index to search one element in the string will get the __ascii number__ of this character.
+If you want to get the character, use built-in function `chr()`.
+
+```javascript
+a[0];
+a[-1, 1, 0:2, 0:, :3, :, nil:8, 3:nil, nil:nil];
+"hello world"[0];
+```
+
+## Special function call
+
+This is not very efficient,
+because hashmap use string as the key to compare.
+
+But if it really useful, the efficientcy may not be so important...
+
+```javascript
+f(x:0, y:nil, z:[]);
+```
+
+## Lambda
+
+Also functions have this kind of use:
+
+```javascript
+func(x, y) {
+    return x+y
+}(0, 1);
+func(x) {
+    return 1/(1+math.exp(-x));
+}(0.5);
+```
+
+There's an interesting test file `y-combinator.nas`,
+try it for fun:
+
+```javascript
+var fib = func(f) {
+    return f(f);
+}(
+    func(f) {
+        return func(x) {
+            if (x<2) return x;
+            return f(f)(x-1)+f(f)(x-2);
+        }
+    }
+);
+```
+
+## Closure
+
+Closure means you could get the variable that is not in the local scope of a function that you called.
+Here is an example, result is `1`:
+
+```javascript
+var f = func() {
+    var a = 1;
+    return func() {return a;};
+}
+print(f()());
+```
+
+Using closure makes it easier to OOP.
+
+```javascript
+var student = func(n, a) {
+    var (name, age) = (n, a);
+    return {
+        print_info: func()  {println(name, ' ', age);},
+        set_age:    func(a) {age = a;},
+        get_age:    func()  {return age;},
+        set_name:   func(n) {name = n;},
+        get_name:   func()  {return name;}
+    };
+}
+```
+
+## Trait
+
+Also there's another way to OOP, that is `trait`.
+
+When a hash has a member named `parents` and the value type is vector,
+then when you are trying to find a member that is not in this hash,
+virtual machine will search the member in `parents`.
+If there is a hash that has the member, you will get the member's value.
+
+Using this mechanism, we could OOP like this, the result is `114514`:
+
+```javascript
+var trait = {
+    get: func {return me.val;},
+    set: func(x) {me.val = x;}
+};
+
+var class = {
+    new: func() {
+        return {
+            val: nil,
+            parents: [trait]
+        };
+    }
+};
+var a = class.new();
+a.set(114514);
+println(a.get());
+```
+
+First virtual machine cannot find member `set` in hash `a`, but in `a.parents` there's a hash `trait` has the member `set`, so we get the `set`.
+variable `me` points to hash `a`, so we change the `a.val`.
+And `get` has the same process.
+
+And we must remind you that if you do this:
+
+```javascript
+var trait = {
+    get: func {return me.val;},
+    set: func(x) {me.val = x;}
+};
+
+var class = {
+    new: func() {
+        return {
+            val: nil,
+            parents: [trait]
+        };
+    }
+};
+var a = class.new();
+var b = class.new();
+a.set(114);
+b.set(514);
+println(a.get());
+println(b.get());
+
+var c = a.get;
+var d = b.get;
+
+println(c());
+println(c());
+println(d());
+println(d());
+```
+
+You will get this result now:
+
+```bash
+114
+514
+514
+514
+514
+514
+```
+
+Because `a.get` will set `me=a` in the `trait.get`. Then `b.get` do the `me=b`. So in fact c is `b.get` too after running `var d=b.get`.
+If you want to use this trick to make the program running more efficiently, you must know this special mechanism.
+
+## Multi-Files/Modules Import</summary>
+
+See more details in [namespace.md](./namespace.md)
+
+## Native functions and module import
+
+This part shows how we add native functions in this interpreter.
+If you are interested in this part, this may help you.
+And...
+
+__CAUTION:__ If you want to add your own functions __without__ changing the source code, see the __`module`__ after this part.
+
+If you really want to change source code, check built-in functions in `lib.nas` and see the example below.
+
+Definition:
+
+```C++
+// you could also use a macro to define one.
+var builtin_print(context*, gc*);
+```
+
+Then complete this function using C++:
+
+```C++
+var builtin_print(context* ctx, gc* ngc) {
+    // find value with index begin from 1
+    // because local[0] is reserved for value 'me'
+    for (auto& i : ctx->localr[1].vec().elems) {
+        std::cout << i;
+    }
+    std::cout << std::flush;
+    // generate return value,
+    // use ngc::alloc(type) to make a new value
+    // or use reserved reference nil/one/zero
+    return nil;
+}
+```
+
+When running a builtin function, alloc will run more than one time, this may cause mark-sweep in `gc::alloc`.
+The value got before will be collected, but stil in use in this builtin function, this will cause a fatal error.
+
+So use `gc::temp` in builtin functions to temprorarily store the gc-managed value that you want to return later. Like this:
+
+```C++
+var builtin_keys(context* ctx, gc* ngc) {
+    auto hash = ctx->localr[1];
+    if (hash.type!=vm_hash && hash.type!=vm_map) {
+        return nas_err("keys", "\"hash\" must be hash");
+    }
+    // use gc.temp to store the gc-managed-value, to avoid being sweeped
+    auto res = ngc->temp = ngc->alloc(vm_vec);
+    auto& vec = res.vec().elems;
+    if (hash.type==vm_hash) {
+        for (const auto& iter : hash.hash().elems) {
+            vec.push_back(ngc->newstr(iter.first));
+        }
+    } else {
+        for (const auto& iter : hash.map().mapper) {
+            vec.push_back(ngc->newstr(iter.first));
+        }
+    }
+    ngc->temp = nil;
+    return res;
+}
+```
+
+After that, register the built-in function's name(in nasal) and the function's pointer in this table:
+
+```C++
+nasal_builtin_table builtin[] = {
+    {"__print", builtin_print},
+    {nullptr,  nullptr}
+};
+```
+
+At last, wrap the `__print` up in a nasal file:
+
+```javascript
+var print = func(elems...) {
+    return __print(elems);
+};
+```
+
+In fact the arguments that `__print` uses are not necessary.
+So writting it like this is also right:
+
+```javascript
+var print = func(elems...) {
+    return __print;
+};
+```
+
+If you don't wrap built-in function up in a normal nasal function,
+this native function may cause __segmentation fault__ when searching arguments.
+
+Use `import("filename.nas")` to get the nasal file including your built-in functions, then you could use it.
+Also there's another way of importing nasal files, the two way of importing have the same function:
+
+```javascript
+use dirname.dirname.filename;
+import("./dirname/dirname/filename.nas");
+```
+
+## C++ Modules (for lib developers)
+
+If there is only one way to add your own functions into nasal,
+that is really inconvenient.
+
+Luckily, we have developed some useful native-functions to help you add modules that created by you.
+
+Functions used to load dynamic libraries are added to `std/dylib.nas`:
+
+```javascript
+var dlopen = func(libname) {
+    ...
+}
+
+var dlclose = func(lib) {
+    ...
+}
+
+var dlcall = func(ptr, args...) {
+    ...
+}
+
+var limitcall = func(arg_size = 0) {
+    ...
+}
+```
+
+As you could see, these functions are used to load dynamic libraries into the nasal runtime and execute.
+Let's see how they work.
+
+First, write a cpp file that you want to generate the dynamic lib, take the `fib.cpp` as the example(example codes are in `./module`):
+
+```C++
+// add header file nasal.h to get api
+#include "nasal.h"
+double fibonaci(double x) {
+    if (x<=2) {
+        return x;
+    }
+    return fibonaci(x-1)+fibonaci(x-2);
+}
+// module functions' parameter list example
+var fib(var* args, usize size, gc* ngc) {
+    if (!size) {
+        return nas_err("fib", "lack arguments");
+    }
+    // the arguments are generated into a vm_vec: args
+    // get values from the vector that must be used here
+    var num = args[0];
+    // if you want your function safer, try this
+    // nas_err will print the error info on screen
+    // and return vm_null for runtime to interrupt
+    if (num.type!=vm_num) {
+        return nas_err("extern_fib", "\"num\" must be number");
+    }
+    // ok, you must know that vm_num now is not managed by gc
+    // if want to return a gc object, use ngc->alloc(type)
+    // usage of gc is the same as adding a native function
+    return var::num(fibonaci(num.tonum()));
+}
+
+// then put function name and address into this table
+// make sure the end of the table is {nullptr,nullptr}
+module_func_info func_tbl[] = {
+    {"fib", fib},
+    {nullptr, nullptr}
+};
+
+// must write this function, this will help nasal to
+// get the function pointer by name
+// the reason why using this way to get function pointer
+// is because `var` has constructors, which is not compatiable in C
+// so "extern "C" var fib" may get compilation warnings
+NASAL_EXTERN module_func_info* get() {
+    return func_tbl;
+}
+```
+
+Next, compile this `fib.cpp` into dynamic lib.
+
+Linux(`.so`):
+
+`clang++ -c -O3 fib.cpp -fPIC -o fib.o`
+
+`clang++ -shared -o libfib.so fib.o`
+
+Mac(`.so` & `.dylib`): same as Linux.
+
+Windows(`.dll`):
+
+`g++ -c -O3 fib.cpp -fPIC -o fib.o`
+
+`g++ -shared -o libfib.dll fib.o`
+
+Then we write a test nasal file to run this fib function:
+
+```javascript
+use std.dylib;
+var dlhandle = dylib.dlopen("libfib");
+var fib = dlhandle.fib;
+for (var i = 1; i<30; i += 1)
+    println(dylib.dlcall(fib, i));
+dylib.dlclose(dlhandle.lib);
+```
+
+`dylib.dlopen` is used to load dynamic library and get the function address.
+
+`dylib.dlcall` is used to call the function, the first argument is the function address, make sure this argument is `vm_obj` and `type=obj_extern`.
+
+`dylib.dlclose` is used to unload the library, at the moment that you call the function, all the function addresses that got from it are invalid.
+
+`dylib.limitcall` is used to get `dlcall` function that has limited parameter size, this function will prove the performance of your code because it does not use `vm_vec` to store the arguments, instead it uses local scope to store them, so this could avoid frequently garbage collecting. And the code above could also be written like this:
+
+```javascript
+use std.dylib;
+var dlhandle = dylib.dlopen("libfib");
+var fib = dlhandle.fib;
+var invoke = dylib.limitcall(1); # this means the called function has only one parameter
+for (var i = 1; i<30; i += 1)
+    println(invoke(fib, i));
+dylib.dlclose(dlhandle.lib);
+```
+
+If get this, Congratulations!
+
+```bash
+./nasal a.nas
+1
+2 
+3 
+5 
+8 
+13
+21
+34
+55
+89
+144
+233
+377
+610
+987
+1597
+2584
+4181
+6765
+10946
+17711
+28657
+46368
+75025
+121393
+196418
+317811
+514229
+832040
+```
+
+## Ghost Type (for lib developers)
+
+It's quite easy to create a new ghost by yourself now.
+Look at the example below:
+
+```c++
+const auto ghost_for_test = "ghost_for_test";
+
+// declare destructor for ghost type
+void ghost_for_test_destructor(void* ptr) {
+    std::cout << "ghost_for_test::destructor (0x";
+    std::cout << std::hex << reinterpret_cast<u64>(ptr) << std::dec << ") {\n";
+    delete static_cast<u32*>(ptr);
+    std::cout << "    delete 0x" << std::hex;
+    std::cout << reinterpret_cast<u64>(ptr) << std::dec << ";\n";
+    std::cout << "}\n";
+}
+
+var create_new_ghost(var* args, usize size, gc* ngc) {
+    var res = ngc->alloc(vm_obj);
+    // create ghost type
+    res.ghost().set(ghost_for_test, ghost_for_test_destructor, new u32);
+    return res;
+}
+
+var set_new_ghost(var* args, usize size, gc* ngc) {
+    var res = args[0];
+    if (!res.object_check(ghost_for_test)) {
+        std::cout << "set_new_ghost: not ghost for test type.\n";
+        return nil;
+    }
+    f64 num = args[1].num();
+    *(reinterpret_cast<u32*>(res.ghost().pointer)) = static_cast<u32>(num);
+    std::cout << "set_new_ghost: successfully set ghost = " << num << "\n";
+    return nil;
+}
+
+var print_new_ghost(var* args, usize size, gc* ngc) {
+    var res = args[0];
+    // check ghost type by the type name
+    if (!res.object_check(ghost_for_test)) {
+        std::cout << "print_new_ghost: not ghost for test type.\n";
+        return nil;
+    }
+    std::cout << "print_new_ghost: " << res.ghost() << " result = "
+              << *((u32*)res.ghost().pointer) << "\n";
+    return nil;
+}
+```
+
+We use this function to create a new ghost type:
+
+`void nas_ghost::set(const std::string&, nasal::nas_ghost::destructor, void*);`
+
+`const std::string&` is the name of the ghost type.
+
+`nasal::nas_ghost::destructor` is the pointer of the destructor of the ghost type.
+
+`void*` is the pointer of the ghost type instance.
+
+And we use this function to check if value is the correct ghost type:
+
+`bool var::object_check(const std::string&);`
+
+The parameter is the name of the ghost type.

doc/tutorial_zh.md

@@ -0,0 +1,748 @@
+# <img src="./svg/nasal_transparent.svg" height="50px"/> __教程__
+
+![mandelbrotset](../doc/pic/mandelbrotset.png)
+
+Nasal非常容易上手，你可以在15分钟之内看完基本教程并直接开始编写程序。
+
+## __目录__
+
+* [__基本类型__](#基本类型)
+* [__运算符__](#运算符)
+* [__定义变量__](#定义变量)
+* [__多变量赋值__](#多变量赋值)
+* [__条件语句__](#条件语句)
+* [__循环语句__](#循环语句)
+* [__生成子列表(subvec)__](#生成子列表subvec)
+* [__特殊函数调用语法__](#特殊函数调用语法)
+* [__Lambda 表达式__](#lambda表达式)
+* [__闭包__](#闭包)
+* [__特性与继承__](#特性与继承)
+* [__多文件/模块导入__](#多文件模块导入)
+* [__原生内置函数以及模块导入__](#原生内置函数以及模块导入)
+* [__C++ 模块(开发者教程)__](#c-模块开发者教程)
+* [__自定义类型(开发者教程)__](#自定义类型开发者教程)
+
+## 基本类型
+
+__`none`__ 是特殊的错误类型。这个类型用于终止虚拟机的执行，该类型只能由虚拟机在抛出错误时产生。
+
+__`nil`__ 是空类型。类似于null。
+
+```javascript
+var spc = nil;
+```
+
+__`num`__ 有三种形式:十进制，十六进制以及八进制。并且该类型使用IEEE754标准的浮点数`double`格式来存储。
+
+```javascript
+# 该语言用 '#' 来作为注释的开头
+var n = 2.71828;    # dec 十进制
+var n = 2.147e16;   # dec 十进制
+var n = 1e-10;      # dec 十进制
+var n = 0xAA55;     # hex 十六进制
+var n = 0o170001;   # oct 八进制
+
+# 注意: true 和 false 关键字在现在的 nasal 里也是可用的
+var n = true;       # n 实际上是数字 1.0
+var n = false;      # n 实际上是数字 0.0
+```
+
+__`str`__ 也有三种不同的格式。第三种只允许包含一个的字符。
+
+```javascript
+var s = 'str';
+var s = "another string";
+var s = `c`;
+# 该语言也支持一些特别的转义字符:
+'\a'; '\b'; '\e'; '\f';
+'\n'; '\r'; '\t'; '\v';
+'\0'; '\\'; '\?'; '\'';
+'\"';
+```
+
+__`vec`__ 有不受限制的长度并且可以存储所有类型的数据。(当然不能超过可分配内存空间的长度)
+
+```javascript
+var vec = [];
+var vec = [0, nil, {}, [], func() { return 0 }];
+append(vec, 0, 1, 2);
+```
+
+__`hash`__ 使用哈希表 (类似于`python`中的`dict`)，通过键值对来存储数据。key可以是一个字符串，也可以是一个标识符。
+
+```javascript
+var hash = {
+    member1: nil,
+    member2: "str",
+    "member3": "member\'s name can also be a string constant",
+    funct: func() {
+        return me.member2~me.member3;
+    }
+};
+```
+
+__`func`__ 函数类型。(实际上在这个语言里函数是一种`lambda`表达式)
+
+```javascript
+var f = func(x, y, z) {
+    return nil;
+}
+# 函数声明可以没有参数列表以及 `(`, `)`
+var f = func {
+    return 114514;
+}
+var f = func(x, y, z, deft = 1) {
+    return x+y+z+deft;
+}
+var f = func(args...) {
+    var sum = 0;
+    foreach(var i; args) {
+        sum += i;
+    }
+    return sum;
+}
+```
+
+__`upval`__ 是存储闭包数据的特殊类型, 在 __`vm`__ 中使用，以确保闭包功能正常。
+
+__`ghost`__ 是用来存储`C/C++`的一些复杂数据结构。这种类型的数据由内置函数生成。如果想为nasal添加新的数据结构, 可以看下文如何通过修改本项目来添加内置函数。
+
+## 运算符
+
+Nasal拥有基本的四种数学运算符 `+` `-` `*` `/`以及一个特别的运算符 `~`，用于拼接字符串或者数组。
+
+```javascript
+1+2-(1+3)*(2+4)/(16-9);
+"str1"~"str2";
+[0]~[1]; # should be [0, 1]
+```
+
+对于条件语句，可以使用`==` `!=` `<` `>` `<=` `>=`来比较数据。`and` `or` 与C/C++中 `&&` `||`运算符一致。
+
+```javascript
+1+1 and (1<0 or 1>0);
+1<=0 and 1>=0;
+1==0 or 1!=0;
+```
+
+单目运算符`-` `!`与C/C++中的运算符功能类似。
+
+```javascript
+-1;
+!0;
+```
+
+位运算符`~` `|` `&` `^`与C/C++中的运算符功能类似。
+
+```javascript
+# 运行过程:
+# 1. 将 f64 强转为 i32 (static_cast<int32_t>)
+# 2. 执行位运算符
+
+~0x80000000; # 按位取反 2147483647
+0x8|0x1;     # 按位或
+0x1&0x2;     # 按位与
+0x8^0x1;     # 按位异或
+```
+
+赋值运算符`=` `+=` `-=` `*=` `/=` `~=` `^=` `&=` `|=`正如其名，用于进行赋值。
+
+```javascript
+a = b = c = d = 1;
+a += 1;
+a -= 1;
+a *= 1;
+a /= 1;
+a ~= "string";
+
+a ^= 0xff;
+a &= 0xca;
+a |= 0xba;
+
+a = [0];
+a ~= [1]; # should be [0, 1]
+```
+
+`??` 运算符用于检查左侧值是否为 `nil`，如果不是则返回右侧的值：
+
+```javascript
+print(nil??"should get this string");
+```
+
+上面的例子会输出 `should get this string`。
+
+`?.` 运算符用于先检查左侧不为 `nil`，如果左侧不是 `nil` 则尝试获取 hash 的字段。
+当然如果左侧此时也不是 `hash` 类型，则报错退出。
+
+```javascript
+var a = nil;
+print(a?.try_get); # nil
+
+var a = {try_get: "congrats!"};
+print(a?.try_get); # "congrats!"
+```
+
+## 定义变量
+
+如下所示。
+
+```javascript
+var a = 1;             # 定义单个变量
+var (a, b, c) = [0, 1, 2]; # 从数组中初始化多个变量
+var (a, b, c) = (0, 1, 2); # 从元组中初始化多个变量
+```
+
+Nasal 有很多特别的全局变量：
+
+```javascript
+globals; # 包含所有全局声明变量名和对应数据的哈希表
+arg;     # 在全局作用域，arg 是包含命令行参数的数组
+         # 在局部作用域，arg 是函数调用时的动态参数数组
+```
+
+具体实例：
+
+```javascript
+var a = 1;
+println(globals); # 输出 {a:1}
+```
+
+```javascript
+# nasal a b c
+println(arg); # 输出 ["a", "b", "c"]
+
+func() {
+    println(arg);
+}(1, 2, 3);   # 输出 [1, 2, 3]
+```
+
+## 多变量赋值
+
+最后这个语句通常用于交换两个变量的数据，类似于Python中的操作。
+
+```javascript
+(a, b[0], c.d) = [0, 1, 2];
+(a, b[1], c.e) = (0, 1, 2);
+(a, b) = (b, a);
+```
+
+## 条件语句
+
+nasal在提供`else if`的同时还有另外一个关键字`elsif`。该关键字与`else if`有相同的功能。
+
+```javascript
+if (1) {
+    ;
+} elsif (2) {
+    ;
+} else if (3) {
+    ;
+} else {
+    ;
+}
+```
+
+## 循环语句
+
+while循环和for循环大体上与C/C++是一致的。
+
+```javascript
+while (condition) {
+    continue;
+}
+for (var i = 0; i<10; i += 1) {
+    break;
+}
+```
+
+同时，nasal还有另外两种直接遍历列表的循环方式:
+
+`forindex` 会获取列表的下标，依次递增. 下标会从`0`递增到`size(elem)-1`结束。
+
+```javascript
+forindex(var i; elem) {
+    print(elem[i]);
+}
+```
+
+`foreach`会依次直接获取列表中的数据. 这些数据会从`elem[0]`依次获取到`elem[size(elem)-1]`.
+
+```javascript
+foreach(var i; elem) {
+    print(i);
+}
+```
+
+## 生成子列表(subvec)
+
+nasal提供了下面第一句的类似语法来从列表中随机或者按照一个区间获取数据，并且拼接生成一个新的列表。当然如果中括号内只有一个下标的话，你会直接获得这个下标对应的数据而不是一个子列表。如果直接对string使用下标来获取内容的话，会得到对应字符的 __ascii值__。如果你想进一步获得这个字符串，可以尝试使用内置函数`chr()`。
+
+```javascript
+a[0];
+a[-1, 1, 0:2, 0:, :3, :, nil:8, 3:nil, nil:nil];
+"hello world"[0];
+```
+
+## 特殊函数调用语法
+
+这种调用方式不是很高效，因为哈希表会使用字符串比对来找到数据存放的位置。
+
+然而如果它用起来非常舒适，那效率也显得不是非常重要了……
+
+```javascript
+f(x:0, y:nil, z:[]);
+```
+
+## lambda表达式
+
+函数有这样一种直接编写函数体并且立即调用的方式:
+
+```javascript
+func(x, y) {
+    return x+y;
+}(0, 1);
+func(x) {
+    return 1/(1+math.exp(-x));
+}(0.5);
+```
+
+测试文件中有一个非常有趣的文件`y-combinator.nas`，可以试一试:
+
+```javascript
+var fib = func(f) {
+    return f(f);
+}(
+    func(f) {
+        return func(x) {
+            if (x<2) return x;
+            return f(f)(x-1)+f(f)(x-2);
+        }
+    }
+);
+```
+
+## 闭包
+
+闭包是一种特别的作用域，你可以从这个作用域中获取其保存的所有变量，
+而这些变量原本不是你当前运行的函数的局部作用域中的。
+下面这个例子里，结果是`1`:
+
+```javascript
+var f = func() {
+    var a = 1;
+    return func() {return a;};
+}
+print(f()());
+```
+
+如果善用闭包，你可以使用它来进行面向对象编程。
+
+```javascript
+var student = func(n, a) {
+    var (name, age) = (n, a);
+    return {
+        print_info: func()  {println(name, ' ', age);},
+        set_age:    func(a) {age = a;},
+        get_age:    func()  {return age;},
+        set_name:   func(n) {name = n;},
+        get_name:   func()  {return name;}
+    };
+}
+```
+
+## 特性与继承
+
+当然，也有另外一种办法来面向对象编程，那就是利用`trait`。
+
+当一个hash类型中，有一个成员的key是`parents`，并且该成员是一个数组的话，
+那么当你试图从这个hash中寻找一个它自己没有的成员名时，虚拟机会进一步搜索`parents`数组。
+如果该数组中有一个hash类型，有一个成员的key与当前你搜索的成员名一致，
+那么你会得到这个成员对应的值。
+
+使用这个机制，我们可以进行面向对象编程，下面样例的结果是`114514`:
+
+```javascript
+var trait = {
+    get: func {return me.val;},
+    set: func(x) {me.val = x;}
+};
+
+var class = {
+    new: func() {
+        return {
+            val: nil,
+            parents: [trait]
+        };
+    }
+};
+var a = class.new();
+a.set(114514);
+println(a.get());
+```
+
+首先虚拟机会发现在`a`中找不到成员`set`，但是在`a.parents`中有个hash类型`trait`存在该成员，所以返回了这个成员的值。
+成员`me`指向的是`a`自身，类似于一些语言中的`this`，所以我们通过这个函数，实际上修改了`a.val`。`get`函数的调用实际上也经过了相同的过程。
+
+不过我们必须提醒你一点，如果你在这个地方使用该优化来减少hash的搜索开销:
+
+```javascript
+var trait = {
+    get: func {return me.val;},
+    set: func(x) {me.val = x;}
+};
+
+var class = {
+    new: func() {
+        return {
+            val: nil,
+            parents: [trait]
+        };
+    }
+};
+var a = class.new();
+var b = class.new();
+a.set(114);
+b.set(514);
+println(a.get());
+println(b.get());
+
+var c = a.get;
+var d = b.get;
+
+println(c());
+println(c());
+println(d());
+println(d());
+```
+
+那么你会发现现在虚拟机会输出这个结果:
+
+```bash
+114
+514
+514
+514
+514
+514
+```
+
+因为执行`a.get`时在`trait.get`函数的属性中进行了`me=a`的操作。而`b.get`则执行了`me=b`的操作。所以在运行`var d=b.get`后实际上c也变成`b.get`了。
+如果你想要用这种小技巧来让程序运行更高效的话，最好是要知道这里存在这样一个机制。
+
+## 多文件/模块导入
+
+详情可见 [namespace.md](./namespace.md)
+
+## 原生内置函数以及模块导入
+
+这个部分对于纯粹的使用者来说是不需要了解的，
+它将告诉你我们是如何为解释器添加新的内置函数的。
+如果你对此很感兴趣，那么这个部分可能会帮到你，并且……
+
+__警告:__ 如果你 __不想__ 通过直接修改解释器源码来添加你自定义的函数，那么你应该看下一个节 __`模块`__ 的内容。
+
+如果你确实是想修改源码来搞一个自己私人订制的解释器 ———— “我他妈就是想自己私人订制，你们他妈的管得着吗？”，
+参考源码中关于内置函数的部分，以及`lib.nas`中是如何包装这些函数的，下面是其中一个样例:
+
+定义新的内置函数:
+
+```C++
+// 你可以使用这个宏来直接定义一个新的内置函数
+var builtin_print(context*, gc*);
+```
+
+然后用C++完成这个函数的函数体:
+
+```C++
+var builtin_print(context* ctx, gc* ngc) {
+    // 局部变量的下标其实是从 1 开始的
+    // 因为 local[0] 是保留给 'me' 的空间
+    for (auto& i : ctx->localr[1].vec().elems) {
+        std::cout << i;
+    }
+    std::cout << std::flush;
+    // 最后生成返回值,返回值必须是一个内置的类型，
+    // 可以使用ngc::alloc(type)来申请一个需要内存管理的复杂数据结构
+    // 或者用我们已经定义好的nil/one/zero，这些可以直接使用
+    return nil;
+}
+```
+
+当运行内置函数的时候，内存分配器如果运行超过一次，那么会有更大可能性多次触发垃圾收集器的mark-sweep。这个操作会在`gc::alloc`中触发。
+如果先前获取的数值没有被正确存到可以被垃圾收集器索引到的地方，那么它会被错误地回收，这会导致严重的错误。
+
+可以使用`gc::temp`来暂时存储一个会被返回的需要gc管理的变量，这样可以防止内部所有的申请错误触发垃圾回收。如下所示：
+
+```C++
+var builtin_keys(context* ctx, gc* ngc) {
+    auto hash = ctx->localr[1];
+    if (hash.type!=vm_hash && hash.type!=vm_map) {
+        return nas_err("keys", "\"hash\" must be hash");
+    }
+    // 使用gc.temp来存储gc管理的变量，防止错误的回收
+    auto res = ngc->temp = ngc->alloc(vm_vec);
+    auto& vec = res.vec().elems;
+    if (hash.type==vm_hash) {
+        for (const auto& iter : hash.hash().elems) {
+            vec.push_back(ngc->newstr(iter.first));
+        }
+    } else {
+        for (const auto& iter : hash.map().mapper) {
+            vec.push_back(ngc->newstr(iter.first));
+        }
+    }
+    ngc->temp = nil;
+    return res;
+}
+```
+
+这些工作都完成之后，在内置函数注册表中填写它在nasal中的别名，并且在表中填对这个函数的函数指针:
+
+```C++
+nasal_builtin_table builtin[] = {
+    {"__print", builtin_print},
+    {nullptr,  nullptr}
+};
+```
+
+最后，将其包装到nasal文件中:
+
+```javascript
+var print = func(elems...) {
+    return __print(elems);
+};
+```
+
+事实上`__print`后面跟着的传参列表不是必须要写的。所以这样写也对:
+
+```javascript
+var print = func(elems...) {
+    return __print;
+};
+```
+
+如果你不把内置函数包装到一个普通的nasal函数中，那么直接调用这个内置函数会在参数传入阶段出现 __segmentation fault(段错误)__。
+
+在nasal文件中使用`import("文件名.nas")`可以导入该文件中你包装的所有内置函数，接下来你就可以使用他们了。
+当然也有另外一种办法来导入这些nasal文件，下面两种导入方式的效果是一样的：
+
+```javascript
+use dirname.dirname.filename;
+import("./dirname/dirname/filename.nas");
+```
+
+## C++ 模块(开发者教程)
+
+如果只有上文中那种方式来添加你自定义的函数到nasal中，这肯定是非常麻烦的。
+因此，我们实现了一组实用的内置函数来帮助你添加你自己创建的模块。
+
+用于加载动态库的函数在`std/dylib.nas`中:
+
+```javascript
+var dlopen = func(libname) {
+    ...
+}
+
+var dlclose = func(lib) {
+    ...
+}
+
+var dlcall = func(ptr, args...) {
+    ...
+}
+
+var limitcall = func(arg_size = 0) {
+    ...
+}
+```
+
+这些函数是用来加载动态库的，这样nasal解释器可以根据用户需求灵活加载动态库来执行。让我们看看这些函数该如何使用。
+
+首先，用C++写个项目，并且编译成动态库。我们就拿`fib.cpp`作为例子来说明(样例代码可以在`./module`中找到):
+
+```C++
+// 这个头文件得加上，因为我们需要拿到nasal的api
+#include "nasal.h"
+double fibonaci(double x) {
+    if (x<=2) {
+        return x;
+    }
+    return fibonaci(x-1)+fibonaci(x-2);
+}
+
+// 模块函数的参数列表一律以这个为准
+var fib(var* args, usize size, gc* ngc) {
+    if (!size) {
+        return nas_err("fib", "lack arguments");
+    }
+    // 传参会给予一个var指针，指向一个vm_vec的data()
+    var num = args[0];
+    // 如果你想让这个函数有更强的稳定性，那么一定要进行合法性检查
+    // nas_err会输出错误信息并返回错误类型让虚拟机终止执行
+    if (num.type!=vm_num) {
+        return nas_err("extern_fib", "\"num\" must be number");
+    }
+    // vm_num作为普通的数字类型，不是内存管理的对象，所以无需申请
+    // 如果需要返回内存管理的对象，请使用ngc->alloc(type)
+    return var::num(fibonaci(num.tonum()));
+}
+
+// 然后将函数名字和函数地址放到一个表里，一定要记住表尾是{nullptr,nullptr}
+module_func_info func_tbl[] = {
+    {"fib", fib},
+    {nullptr, nullptr}
+};
+
+// 必须实现这个函数, 这样nasal可以通过字符串名字获得函数指针
+// 之所以用这种方式来获取函数指针, 是因为`var`是有构造函数的
+// 有构造函数的类型作为返回值, 和C是不兼容的, 这导致
+// 类似 "extern "C" var fib" 的写法会得到编译错误
+NASAL_EXTERN module_func_info* get() {
+    return func_tbl;
+}
+```
+
+接着我们把`fib.cpp`编译成动态库。
+
+Linux(`.so`):
+
+`clang++ -c -O3 fib.cpp -fPIC -o fib.o`
+
+`clang++ -shared -o libfib.so fib.o`
+
+Mac(`.so` & `.dylib`): 和Linux下操作相同。
+
+Windows(`.dll`):
+
+`g++ -c -O3 fib.cpp -fPIC -o fib.o`
+
+`g++ -shared -o libfib.dll fib.o`
+
+好了，那么我们可以写一个测试用的nasal代码来运行这个斐波那契函数了:
+
+```javascript
+use std.dylib;
+var dlhandle = dylib.dlopen("libfib");
+var fib = dlhandle.fib;
+for (var i = 1; i<30; i += 1)
+    println(dylib.dlcall(fib, i));
+dylib.dlclose(dlhandle.lib);
+```
+
+`dylib.dlopen`用于加载动态库并从动态库中获得函数地址。
+
+`dylib.dlcall`用于调用函数，第一个参数是动态库函数的地址，这是个特殊类型，一定要保证这个参数是`vm_obj`类型并且`type=obj_extern`。
+
+`dylib.dlclose`用于卸载动态库，当然，在这个函数调用之后，所有从该库中获取的函数都作废。
+
+`dylib.limitcall`用于获取使用固定长度传参的 `dlcall` 函数，这种函数可以提高你的程序运行效率，因为它不需要用 `vm_vec` 来存储传入参数，而是使用局部作用域来直接存储，从而避免了频繁调用可能导致的频繁垃圾收集。所以上面展示的代码同样可以这样写：
+
+```javascript
+use std.dylib;
+var dlhandle = dylib.dlopen("libfib");
+var fib = dlhandle.fib;
+var invoke = dylib.limitcall(1); # this means the called function has only one parameter
+for (var i = 1; i<30; i += 1)
+    println(invoke(fib, i));
+dylib.dlclose(dlhandle.lib);
+```
+
+如果得到如下运行结果，恭喜你！
+
+```bash
+./nasal a.nas
+1
+2 
+3 
+5 
+8 
+13
+21
+34
+55
+89
+144
+233
+377
+610
+987
+1597
+2584
+4181
+6765
+10946
+17711
+28657
+46368
+75025
+121393
+196418
+317811
+514229
+832040
+```
+
+## 自定义类型(开发者教程)
+
+创建一个自定义类型很容易。下面是使用示例：
+
+```c++
+const auto ghost_for_test = "ghost_for_test";
+
+// 声明自定义类型的析构函数
+void ghost_for_test_destructor(void* ptr) {
+    std::cout << "ghost_for_test::destructor (0x";
+    std::cout << std::hex << reinterpret_cast<u64>(ptr) << std::dec << ") {\n";
+    delete static_cast<u32*>(ptr);
+    std::cout << "    delete 0x" << std::hex;
+    std::cout << reinterpret_cast<u64>(ptr) << std::dec << ";\n";
+    std::cout << "}\n";
+}
+
+var create_new_ghost(var* args, usize size, gc* ngc) {
+    var res = ngc->alloc(vm_obj);
+    // 创建自定义类型
+    res.ghost().set(ghost_for_test, ghost_for_test_destructor, new u32);
+    return res;
+}
+
+var set_new_ghost(var* args, usize size, gc* ngc) {
+    var res = args[0];
+    if (!res.object_check(ghost_for_test)) {
+        std::cout << "set_new_ghost: not ghost for test type.\n";
+        return nil;
+    }
+    f64 num = args[1].num();
+    *(reinterpret_cast<u32*>(res.ghost().pointer)) = static_cast<u32>(num);
+    std::cout << "set_new_ghost: successfully set ghost = " << num << "\n";
+    return nil;
+}
+
+var print_new_ghost(var* args, usize size, gc* ngc) {
+    var res = args[0];
+    // 用自定义类型的名字来检查是否是正确的自定义类型
+    if (!res.object_check(ghost_for_test)) {
+        std::cout << "print_new_ghost: not ghost for test type.\n";
+        return nil;
+    }
+    std::cout << "print_new_ghost: " << res.ghost() << " result = "
+              << *((u32*)res.ghost().pointer) << "\n";
+    return nil;
+}
+```
+
+我们使用下面这个函数来创建一个自定义类型：
+
+`void nas_ghost::set(const std::string&, nasal::nas_ghost::destructor, void*);`
+
+`const std::string&` 是自定义类型的类型名。
+
+`nasal::nas_ghost::destructor` 是自定义类型的析构函数指针。
+
+`void*` 是指向自定义类型实例的指针。
+
+我们使用下面的这个函数检测是否是正确的自定义类型：
+
+`bool var::object_check(const std::string&);`
+
+参数是自定义类型的类型名。

doc/windows-build.md

@@ -0,0 +1,27 @@
+# Build Nasal-Interpreter on Windows
+
+## MSVC / Visual Studio
+
+Need CMake and Visual Studio 2022. Remember to add MSBuild.exe to Path.
+
+Valid on powershell:
+
+```sh
+mkdir cmake-windows-msvc
+cd cmake-windows-msvc
+cmake .. -DCMAKE_BUILD_TYPE=Release -G "Visual Studio 17 2022"
+MSBuild.exe nasal.sln /p:Configuration=Release /p:Platform=x64
+```
+
+## MingW-W64
+
+Need CMake and MingW-W64. Remember to add MingW-W64 bin to Path.
+
+Valid on powershell:
+
+```sh
+mkdir cmake-windows-mingw
+cd cmake-windows-mingw
+cmake .. -DCMAKE_BUILD_TYPE=Release -G "MinGW Makefiles" -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
+mingw32-make.exe -j6
+```

lib.nas

@@ -1,144 +0,0 @@
-var import=func(filename)
-{
-    return __builtin_import(filename);
-}
-var print=func(elems...)
-{
-    return __builtin_print(elems);
-};
-var println=func(elems...)
-{
-    __builtin_print(elems);
-    elems=['\n'];
-    return __builtin_print(elems);
-}
-var append=func(vec,elems...)
-{
-    return __builtin_append(vec,elems);
-}
-var setsize=func(vec,size)
-{
-    return __builtin_setsize(vec,size);
-}
-var system=func(str)
-{
-    return __builtin_system(str);
-}
-var input=func()
-{
-    return __builtin_input();
-}
-var sleep=func(duration)
-{
-    return __builtin_sleep(duration);
-}
-var split=func(deli,str)
-{
-    return __builtin_split(deli,str);
-}
-var rand=func(seed=nil)
-{
-    return __builtin_rand(seed);
-}
-var id=func(object)
-{
-    return __builtin_id(object);
-}
-var int=func(val)
-{
-    return __builtin_int(val);
-}
-var num=func(val)
-{
-    return __builtin_num(val);
-}
-var pop=func(vec)
-{
-    return __builtin_pop(vec);
-}
-var str=func(num)
-{
-    return __builtin_str(num);
-}
-var size=func(object)
-{
-    return __builtin_size(object);
-}
-var contains=func(hash,key)
-{
-    return __builtin_contains(hash,key);
-}
-var delete=func(hash,key)
-{
-    return __builtin_delete(hash,key);
-}
-var keys=func(hash)
-{
-    return __builtin_keys(hash);
-}
-var time=func(begin_time)
-{
-    return __builtin_time(begin_time);
-}
-var die=func(str)
-{
-    return __builtin_die(str);
-}
-var typeof=func(object)
-{
-    return __builtin_type(object);
-}
-var substr=func(str,begin,len)
-{
-    return __builtin_substr(str,begin,len);
-}
-var streq=func(a,b)
-{
-    return __builtin_streq(a,b);
-}
-var left=func(str,len)
-{
-    return __builtin_left(str,len);
-}
-var right=func(str,len)
-{
-    return __builtin_right(str,len);
-}
-var cmp=func(a,b)
-{
-    return __builtin_cmp(a,b);
-}
-var chr=func(code)
-{
-    return __builtin_chr(code);
-}
-
-var io=
-{
-    fin: func(filename){return __builtin_fin(filename);},
-    fout:func(filename,str){return __builtin_fout(filename,str);}
-};
-
-var bits=
-{
-    bitxor:  func(a,b){return __builtin_xor(a,b); },
-    bitand:  func(a,b){return __builtin_and(a,b); },
-    bitor:   func(a,b){return __builtin_or(a,b);  },
-    bitnand: func(a,b){return __builtin_nand(a,b);},
-    bitnot:  func(a)  {return __builtin_not(a);   }
-};
-
-var math=
-{
-    e:     2.7182818284590452354,
-    pi:    3.14159265358979323846264338327950288,
-    sin:   func(x)  {return __builtin_sin(x);    },
-    cos:   func(x)  {return __builtin_cos(x);    },
-    tan:   func(x)  {return __builtin_tan(x);    },
-    exp:   func(x)  {return __builtin_exp(x);    }, 
-    ln:    func(x)  {return __builtin_ln(x);     },
-    sqrt:  func(x)  {return __builtin_sqrt(x);   },
-    atan2: func(x,y){return __builtin_atan2(x,y);}
-};
-
-var D2R=math.pi/180;

main.cpp

@@ -1,173 +0,0 @@
-#include "nasal.h"
-
-void help_interact()
-{
-	std::cout
-	<<">> [     ] input a file name to execute.  \n"
-	<<">> [help ] show help.                     \n"
-	<<">> [clear] clear the screen.              \n"
-	<<">> [lex  ] view tokens.                   \n"
-	<<">> [ast  ] view abstract syntax tree.     \n"
-	<<">> [code ] view byte code.                \n"
-	<<">> [exec ] execute program on bytecode vm.\n"
-	<<">> [logo ] print logo of nasal .          \n"
-	<<">> [exit ] quit nasal interpreter.        \n";
-	return;
-}
-void help_cmd()
-{
-	std::cout
-#ifdef _WIN32
-	<<"use command \'chcp 65001\' if want to use unicode.\n"
-#endif
-	<<"nasal             | use interactive interpreter.\n"
-	<<"nasal -h -help    | get help.\n"
-	<<"nasal -v -version | get version of nasal interpreter.\n"
-	<<"nasal filename    | execute script file.\n";
-	return;
-}
-void info()
-{
-	std::cout
-	<<">> Nasal interpreter ver 6.5.\n"
-	<<">> Thanks to https://github.com/andyross/nasal\n"
-	<<">> Code: https://github.com/ValKmjolnir/Nasal-Interpreter\n"
-	<<">> Code: https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
-	<<">> Info: http://wiki.flightgear.org/Nasal_scripting_language\n"
-	<<">> Input \"help\" to get help .\n";
-	return;
-}
-void logo()
-{
-    std::cout
-	<<"       __                _      \n"
-	<<"    /\\ \\ \\__ _ ___  __ _| |  \n"
-	<<"   /  \\/ / _` / __|/ _` | |    \n"
-	<<"  / /\\  / (_| \\__ \\ (_| | |  \n"
-	<<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n";
-    return;
-}
-void die(const char* stage,std::string& filename)
-{
-	std::cout<<">> ["<<stage<<"] in <\""<<filename<<"\">: error(s) occurred,stop.\n";
-	return;
-}
-void execute(std::string& file,std::string& command)
-{
-	nasal_lexer   lexer;
-	nasal_parse   parse;
-	nasal_import  import;
-	nasal_codegen codegen;
-	nasal_vm      vm;
-	lexer.openfile(file);
-	lexer.scanner();
-	if(lexer.get_error())
-	{
-		die("lexer",file);
-		return;
-	}
-	if(command=="lex")
-	{
-		lexer.print_token();
-		return;
-	}
-	parse.set_toklist(lexer.get_token_list());
-	lexer.get_token_list().clear();
-	parse.main_process();
-	if(parse.get_error())
-	{
-		die("parse",file);
-		return;
-	}
-	if(command=="ast")
-	{
-		parse.get_root().print_ast(0);
-		return;
-	}
-	import.link(parse.get_root());
-	parse.get_root().clear();
-	if(import.get_error())
-	{
-		die("import",file);
-		return;
-	}
-	codegen.main_progress(import.get_root());
-	if(codegen.get_error())
-	{
-		die("codegen",file);
-		return;
-	}
-	if(command=="code")
-	{
-		codegen.print_byte_code();
-		return;
-	}
-	vm.init(
-		codegen.get_str_table(),
-		codegen.get_num_table(),
-		codegen.get_exec_code()
-	);
-	vm.run();
-	vm.clear();
-	return;
-}
-void interact()
-{
-#ifdef _WIN32
-	// use chcp 65001 to use unicode io
-	system("chcp 65001");
-#endif
-	std::string command,file="null";
-	logo();
-	info();
-    while(1)
-	{
-		std::cout<<">> ";
-		std::cin>>command;
-		if(command=="help")
-			help_interact();
-		else if(command=="clear")
-		{
-#ifdef _WIN32
-			system("cls");
-#else
-			int rs=system("clear");
-#endif
-		}
-		else if(command=="logo")
-			logo();
-		else if(command=="exit")
-			return;
-		else if(command=="lex" || command=="ast" || command=="code" || command=="exec")
-			execute(file,command);
-		else
-			file=command;
-	}
-}
-int main(int argc,const char* argv[])
-{
-	std::string command,file="null";
-	if(argc==1)
-		interact();
-	else if(argc==2 && (!strcmp(argv[1],"-v") || !strcmp(argv[1],"-version")))
-	{
-		logo();
-		std::cout<<"Nasal interpreter ver 6.5\n";
-	}
-	else if(argc==2 && (!strcmp(argv[1],"-h") || !strcmp(argv[1],"-help")))
-		help_cmd();
-	else if(argc==2 && argv[1][0]!='-')
-	{
-		file=argv[1];
-		command="exec";
-		execute(file,command);
-		return 0;
-	}
-	else
-	{
-		std::cout
-		<<"invalid command.\n"
-		<<"use nasal -h to get help.\n";
-	}
-    return 0;
-}

makefile

@@ -0,0 +1,63 @@
+STD = c++17
+
+ifndef OS
+	OS = $(shell uname)
+endif
+ifeq ($(OS), Darwin)
+	CXXFLAGS = -std=$(STD) -c -O3 -fPIC -mmacosx-version-min=10.15 -I src
+else
+	CXXFLAGS = -std=$(STD) -c -O3 -fPIC -I src
+endif
+
+.PHONY: clean
+clean:
+	@ echo "[clean] nasal" && if [ -e nasal ]; then rm nasal; fi
+	@ echo "[clean] nasal.exe" && if [ -e nasal.exe ]; then rm nasal.exe; fi
+
+.PHONY: test
+test:
+	@ ./nasal -t -d test/andy_gc_test.nas
+	@ ./nasal test/argparse_test.nas
+	@ ./nasal -e test/ascii-art.nas
+	@ ./nasal -t -d test/bfs.nas
+	@ ./nasal -t test/bigloop.nas
+	@ ./nasal -t test/bp.nas
+	@ ./nasal -d test/calc.nas
+	@ ./nasal test/caller.nas
+	@ ./nasal -e test/choice.nas
+	@ ./nasal -e test/class.nas
+	@ ./nasal -t -d test/console3D.nas 20
+	@ ./nasal -e test/coroutine.nas
+	@ ./nasal -t -d test/datalog.nas
+	@ ./nasal -e test/diff.nas
+	@ ./nasal -e test/donuts.nas 15
+	-@ ./nasal -d test/exception.nas
+	@ ./nasal -t -d test/fib.nas
+	@ ./nasal -e test/filesystem.nas
+	@ ./nasal -t -d test/globals_test.nas
+	@ ./nasal -d test/hexdump.nas
+	@ ./nasal -e test/json.nas
+	@ ./nasal -e test/leetcode1319.nas
+	@ ./nasal -d test/lexer.nas
+	@ ./nasal -d test/life.nas
+	@ ./nasal -t test/loop.nas
+	@ ./nasal -t test/mandelbrot.nas
+	@ ./nasal -t test/md5_self.nas
+	@ ./nasal -t -d test/md5compare.nas
+	@ ./nasal -d test/module_test.nas
+	@ ./nasal -e test/nasal_test.nas
+	@ ./nasal -t -d test/occupation.nas 2
+	@ ./nasal -t -d test/pi.nas
+	@ ./nasal -t -d test/prime.nas
+	@ ./nasal -e test/qrcode.nas
+	@ ./nasal -t -d test/quick_sort.nas
+	@ ./nasal -t -d test/regex_test.nas
+	@ ./nasal -t -d test/replace_test.nas
+	@ ./nasal -e test/scalar.nas hello world
+	@ ./nasal -t test/subprocess_test.nas
+	@ ./nasal -t test/trait.nas
+	@ ./nasal -t -d test/turingmachine.nas
+	@ ./nasal -t -d test/wavecollapse.nas
+	@ ./nasal -t -d test/wavecity.nas
+	@ ./nasal -t test/word_collector.nas test/md5compare.nas
+	@ ./nasal -t -d test/ycombinator.nas

module/fib.cpp

@@ -0,0 +1,131 @@
+// module for test
+
+#include <iostream>
+#include "../src/nasal.h"
+#include "../src/nasal_type.h"
+#include "../src/nasal_gc.h"
+
+namespace nasal {
+namespace fib_module {
+
+double fibonaci(double x) {
+    if (x<=2) {
+        return x;
+    }
+    return fibonaci(x-1)+fibonaci(x-2);
+}
+
+var fib(var* args, usize size, gc* ngc) {
+    if (!size) {
+        return nas_err("fib", "lack arguments");
+    }
+    var num = args[0];
+    return var::num(fibonaci(num.to_num()));
+}
+
+var quick_fib(var* args, usize size, gc* ngc) {
+    if (!size) {
+        return nas_err("quick_fib", "lack arguments");
+    }
+    double num = args[0].to_num();
+    if (num<2) {
+        return var::num(num);
+    }
+    double a = 1, b = 1, res = 0;
+    for (double i = 1; i<num; ++i) {
+        res = a+b;
+        a = b;
+        b = res;
+    }
+    return var::num(res);
+}
+
+const auto ghost_for_test = "ghost_for_test";
+
+struct ghost_obj {
+    u32 number = 0;
+    var test_string = nil;
+};
+
+// if the dynamic library is closed, the pointer of this function will be unsafe
+// make sure gc deletes the object before closing the dynamic library
+// or just do not close the dynamic library...
+void ghost_for_test_destructor(void* ptr) {
+    std::cout << "ghost_for_test::destructor (0x";
+    std::cout << std::hex << reinterpret_cast<u64>(ptr) << std::dec << ") {\n";
+
+    delete static_cast<ghost_obj*>(ptr);
+
+    std::cout << "    delete 0x" << std::hex;
+    std::cout << reinterpret_cast<u64>(ptr) << std::dec << ";\n";
+    std::cout << "}\n";
+}
+
+void ghost_for_test_gc_marker(void* ptr, std::vector<var>* bfs_queue) {
+    std::cout << "ghost_for_test::mark (0x";
+    std::cout << std::hex << reinterpret_cast<u64>(ptr) << std::dec << ") {\n";
+
+    bfs_queue->push_back(static_cast<ghost_obj*>(ptr)->test_string);
+
+    std::cout << "    mark 0x" << std::hex;
+    std::cout << reinterpret_cast<u64>(ptr) << std::dec << "->test_string;\n";
+    std::cout << "}\n";
+}
+
+var create_new_ghost(var* args, usize size, gc* ngc) {
+    var res = ngc->alloc(vm_type::vm_ghost);
+    res.ghost().set(
+        ghost_for_test,
+        ghost_for_test_destructor,
+        ghost_for_test_gc_marker,
+        new ghost_obj
+    );
+    return res;
+}
+
+var set_new_ghost(var* args, usize size, gc* ngc) {
+    var res = args[0];
+    if (!res.object_check(ghost_for_test)) {
+        std::cout << "set_new_ghost: not ghost for test type.\n";
+        return nil;
+    }
+    f64 num = args[1].num();
+
+    res.ghost().get<ghost_obj>()->number = static_cast<u32>(num);
+    std::cout << "set_new_ghost: successfully set ghost.number = " << num << "\n";
+
+    res.ghost().get<ghost_obj>()->test_string = ngc->newstr("just for test");
+    std::cout << "set_new_ghost: successfully set ghost.test_string = just for test\n";
+    return nil;
+}
+
+var print_new_ghost(var* args, usize size, gc* ngc) {
+    var res = args[0];
+    if (!res.object_check(ghost_for_test)) {
+        std::cout << "print_new_ghost: not ghost for test type.\n";
+        return nil;
+    }
+    std::cout << "print_new_ghost: " << res.ghost() << " number = "
+              << res.ghost().get<ghost_obj>()->number
+              << " test_string = "
+              << res.ghost().get<ghost_obj>()->test_string
+              << "\n";
+    return nil;
+}
+
+module_func_info func_tbl[] = {
+    {"fib", fib},
+    {"quick_fib", quick_fib},
+    {"create_ghost", create_new_ghost},
+    {"set_ghost", set_new_ghost},
+    {"print_ghost", print_new_ghost},
+    {nullptr, nullptr}
+};
+
+}
+
+NASAL_EXPORT module_func_info* get() {
+    return fib_module::func_tbl;
+}
+
+}

module/keyboard.cpp

@@ -0,0 +1,118 @@
+#include "../src/nasal.h"
+#include "../src/nasal_type.h"
+#include "../src/nasal_gc.h"
+#include <iostream>
+
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (disable:4996)
+#endif
+
+#ifdef _WIN32
+#include <conio.h>
+#else
+#include <fcntl.h>
+#include <termios.h>
+#endif
+
+namespace nasal {
+
+class noecho_input {
+private:
+#ifndef _WIN32
+    struct termios init_termios;
+    struct termios new_termios;
+    int peek_char = -1;
+#endif
+public:
+    noecho_input() {
+#ifndef _WIN32
+        tcflush(0, TCIOFLUSH);
+        tcgetattr(0, &init_termios);
+        new_termios = init_termios;
+        new_termios.c_lflag &= ~(ICANON|ECHO|ECHONL|ECHOE);
+        // vmin = 0 is nonblock input,
+        // but in wsl1 there is a bug that will block input
+        // so we use fcntl to write the nonblock input
+        new_termios.c_cc[VMIN] = 1;
+        new_termios.c_cc[VTIME] = 0;
+        tcsetattr(0, TCSANOW, &new_termios);
+#endif
+    }
+
+    ~noecho_input() {
+#ifndef _WIN32
+        tcflush(0, TCIOFLUSH);
+        tcsetattr(0, TCSANOW, &init_termios);
+#endif
+    }
+
+    int noecho_kbhit() {
+#ifndef _WIN32
+        unsigned char ch = 0;
+        int nread = 0;
+        if (peek_char!=-1) {
+            return 1;
+        }
+        int flag = fcntl(0, F_GETFL);
+        fcntl(0, F_SETFL, flag|O_NONBLOCK);
+        nread = read(0, &ch, 1);
+        fcntl(0, F_SETFL, flag);
+        if (nread==1) {
+            peek_char = ch;
+            return 1;
+        }
+        return 0;
+#else
+        return kbhit();
+#endif
+    }
+
+    int noecho_getch() {
+#ifndef _WIN32
+        int ch = 0;
+        if (peek_char!=-1) {
+            ch = peek_char;
+            peek_char = -1;
+            return ch;
+        }
+        ssize_t tmp = read(0, &ch, 1);
+        return ch;
+#else
+        return getch();
+#endif
+    }
+};
+
+noecho_input this_window;
+
+var nas_getch(var* args, usize size, gc* ngc) {
+    return var::num(static_cast<double>(this_window.noecho_getch()));
+}
+
+var nas_kbhit(var* args, usize size, gc* ngc) {
+    return var::num(static_cast<double>(this_window.noecho_kbhit()));
+}
+
+var nas_noblock(var* args, usize size, gc* ngc) {
+    if (this_window.noecho_kbhit()) {
+        return var::num(static_cast<double>(this_window.noecho_getch()));
+    }
+    return nil;
+}
+
+module_func_info func_tbl[] = {
+    {"nas_getch", nas_getch},
+    {"nas_kbhit", nas_kbhit},
+    {"nas_noblock", nas_noblock},
+    {nullptr, nullptr}
+};
+
+NASAL_EXPORT module_func_info* get() {
+    return func_tbl;
+}
+
+}

module/libfib.nas

@@ -0,0 +1,58 @@
+use std.dylib;
+use std.os;
+
+var _dl = dylib.dlopen("libfib");
+
+var _fib = _dl.fib;
+
+var _qfib = _dl.quick_fib;
+
+var _create_ghost = _dl.create_ghost;
+
+var _set_ghost = _dl.set_ghost;
+
+var _print_ghost = _dl.print_ghost;
+
+var _zero_call = dylib.limitcall(0);
+
+var _call = dylib.limitcall(1);
+
+var _test_call = dylib.limitcall(2);
+
+var fib = func(x) {
+    return _call(_fib, x)
+}
+
+var qfib = func(x) {
+    return _call(_qfib, x)
+}
+
+var create_ghost = func() {
+    return _zero_call(_create_ghost)
+}
+
+var set_ghost = func(object, x) {
+    return _test_call(_set_ghost, object, x)
+}
+
+var print_ghost = func(object) {
+    return _call(_print_ghost, object)
+}
+
+var test_ghost = func() {
+    var ghost = create_ghost();
+    print_ghost(nil); # err
+    print("\n");
+    print_ghost(ghost); # random
+    print("\n");
+    set_ghost(nil, 114); # err
+    print("\n");
+    set_ghost(ghost, 114); # success
+    print("\n");
+    for (var i = 0; i<256; i+=1) {
+        var temp = []; # try to trigger gc
+    }
+    print("\n");
+    print_ghost(ghost); # 114
+    print("\n");
+}

module/libkey.nas

@@ -0,0 +1,19 @@
+use std.dylib;
+use std.os;
+
+var (
+    kbhit,
+    getch,
+    nonblock
+) = func {
+    var lib = dylib.dlopen("libkey");
+    var kb = lib.nas_kbhit;
+    var gt = lib.nas_getch;
+    var nb = lib.nas_noblock;
+    var call = dylib.limitcall(0);
+    return [
+        func() {return call(kb);},
+        func() {return call(gt);},
+        func() {return call(nb);}
+    ];
+}();

module/libmat.nas

@@ -0,0 +1,67 @@
+use std.dylib;
+use std.os;
+
+var _dl = dylib.dlopen("libmat");
+
+var _vec2 = _dl.nas_vec2;
+
+var _vec3 = _dl.nas_vec3;
+
+var (_vec2add, _vec2sub, _vec2mul, _vec2div, _vec2neg, _vec2norm, _vec2len, _vec2dot)=(
+    _dl.nas_vec2_add,
+    _dl.nas_vec2_sub,
+    _dl.nas_vec2_mult,
+    _dl.nas_vec2_div,
+    _dl.nas_vec2_neg,
+    _dl.nas_vec2_norm,
+    _dl.nas_vec2_len,
+    _dl.nas_vec2_dot
+);
+var (_vec3add, _vec3sub, _vec3mul, _vec3div, _vec3neg, _vec3norm, _vec3len, _vec3dot)=(
+    _dl.nas_vec3_add,
+    _dl.nas_vec3_sub,
+    _dl.nas_vec3_mult,
+    _dl.nas_vec3_div,
+    _dl.nas_vec3_neg,
+    _dl.nas_vec3_norm,
+    _dl.nas_vec3_len,
+    _dl.nas_vec3_dot
+);
+var (_rotate_x, _rotate_y, _rotate_z)=(
+    _dl.nas_rotate_x,
+    _dl.nas_rotate_y,
+    _dl.nas_rotate_z
+);
+var (_invoke_i, _invoke_ii, _invoke_iii)=(
+    dylib.limitcall(1),
+    dylib.limitcall(2),
+    dylib.limitcall(3)
+);
+
+var vec2 = {
+    new:  func(x, y) {return _invoke_ii(_vec2, x, y);},
+    add:  func(v0, v1) {return _invoke_ii(_vec2add, v0, v1);},
+    sub:  func(v0, v1) {return _invoke_ii(_vec2sub, v0, v1);},
+    mul:  func(v0, v1) {return _invoke_ii(_vec2mul, v0, v1);},
+    div:  func(v0, v1) {return _invoke_ii(_vec2div, v0, v1);},
+    neg:  func(v0) {return _invoke_i(_vec2neg, v0);},
+    norm: func(v0) {return _invoke_i(_vec2norm, v0);},
+    len:  func(v0) {return _invoke_i(_vec2len, v0);},
+    dot:  func(v0, v1) {return _invoke_ii(_vec2dot, v0, v1);}
+};
+
+var vec3 = {
+    new:  func(x, y, z) {return _invoke_iii(_vec3, x, y, z);},
+    add:  func(v0, v1) {return _invoke_ii(_vec3add, v0, v1);},
+    sub:  func(v0, v1) {return _invoke_ii(_vec3sub, v0, v1);},
+    mul:  func(v0, v1) {return _invoke_ii(_vec3mul, v0, v1);},
+    div:  func(v0, v1) {return _invoke_ii(_vec3div, v0, v1);},
+    neg:  func(v0) {return _invoke_i(_vec3neg, v0);},
+    norm: func(v0) {return _invoke_i(_vec3norm, v0);},
+    len:  func(v0) {return _invoke_i(_vec3len, v0);},
+    rx:   func(v0, angle) {return _invoke_ii(_rotate_x, v0, angle);},
+    ry:   func(v0, angle) {return _invoke_ii(_rotate_y, v0, angle);},
+    rz:   func(v0, angle) {return _invoke_ii(_rotate_z, v0, angle);},
+    dot:  func(v0, v1) {return _invoke_ii(_vec3dot, v0, v1);}
+};
+

module/libnasock.nas

@@ -0,0 +1,120 @@
+use std.dylib;
+use std.os;
+
+var socket = func() {
+    var lib = dylib.dlopen("libnasock");
+    
+    var sock = lib.nas_socket;
+    var closesocket = lib.nas_closesocket;
+    var shutdown = lib.nas_shutdown;
+    var bind = lib.nas_bind;
+    var listen = lib.nas_listen;
+    var connect = lib.nas_connect;
+    var accept = lib.nas_accept;
+    var send = lib.nas_send;
+    var sendto = lib.nas_sendto;
+    var recv = lib.nas_recv;
+    var recvfrom = lib.nas_recvfrom;
+    var errno = lib.nas_errno;
+
+    var (invoke, invoke_i, invoke_ii, invoke_iii, invoke_iiii, invoke_iiiii) = (
+        dylib.limitcall(0),
+        dylib.limitcall(1),
+        dylib.limitcall(2),
+        dylib.limitcall(3),
+        dylib.limitcall(4),
+        dylib.limitcall(5),
+    );
+    return {
+        AF_UNSPEC:0,
+        AF_UNIX: 1,
+        AF_INET: 2,
+        AF_IMPLINK: 3,
+        AF_PUP: 4,
+        AF_CHAOS: 5,
+        AF_IPX: 6,
+        AF_NS: 6,
+        AF_ISO: 7,
+        AF_OSI: 7,
+        AF_ECMA: 8,
+        AF_DATAKIT: 9,
+        AF_CCITT: 10,
+        AF_SNA: 11,
+        AF_DECnet: 12,
+        AF_DLI: 13,
+        AF_LAT: 14,
+        AF_HYLINK: 15,
+        AF_APPLETALK: 16,
+        AF_NETBIOS: 17,
+        AF_VOICEVIEW: 18,
+        AF_FIREFOX: 19,
+        AF_UNKNOWN1: 20,
+        AF_BAN: 21,
+        AF_MAX: 22,
+
+        SOCKET_ERROR: -1,
+        SOCK_STREAM: 1,
+        SOCK_DGRAM: 2,
+        SOCK_RAW: 3,
+        SOCK_RDM: 4,
+        SOCK_SEQPACKET: 5,
+
+        IPPROTO_IP:0,IPPROTO_ICMP:1,IPPROTO_IGMP:2,IPPROTO_GGP:3,
+        IPPROTO_TCP:6,IPPROTO_PUP:12,IPPROTO_UDP:17,IPPROTO_IDP:22,
+        IPPROTO_ND:77,IPPROTO_RAW:255,IPPROTO_MAX:256,
+
+        IPPORT_ECHO:7,IPPORT_DISCARD:9,IPPORT_SYSTAT:11,IPPORT_DAYTIME:13,
+        IPPORT_NETSTAT:15,IPPORT_FTP:21,IPPORT_TELNET:23,IPPORT_SMTP:25,
+        IPPORT_TIMESERVER:37,IPPORT_NAMESERVER:42,IPPORT_WHOIS:43,IPPORT_MTP:57,
+        IPPORT_TFTP:69,IPPORT_RJE:77,IPPORT_FINGER:79,IPPORT_TTYLINK:87,
+        IPPORT_SUPDUP:95,IPPORT_EXECSERVER:512,IPPORT_LOGINSERVER:513,IPPORT_CMDSERVER:514,
+        IPPORT_EFSSERVER:520,IPPORT_BIFFUDP:512,IPPORT_WHOSERVER:513,IPPORT_ROUTESERVER:520,
+        IPPORT_RESERVED:1024,
+
+        SHUT_RD  : 0x00,
+        SHUT_WR  : 0x01,
+        SHUT_RDWR: 0x02,
+
+        MSG_OOB: 0x1,
+        MSG_PEEK: 0x2,
+        MSG_DONTROUTE: 0x4,
+        MSG_DONTWAIT: 0x40,
+
+        socket: func(af, type, proto = 0) {
+            return invoke_iii(sock, af, type, proto);
+        },
+        closesocket: func(sd) {
+            return invoke_i(closesocket, sd);
+        },
+        shutdown: func(sd, how) {
+            return invoke_ii(shutdown, sd, how);
+        },
+        bind: func(sd, ip, port) {
+            return invoke_iii(bind, sd, ip, port);
+        },
+        listen: func(sd, backlog) {
+            return invoke_ii(listen, sd, backlog);
+        },
+        connect: func(sd, hostname, port) {
+            return invoke_iii(connect, sd, hostname, port);
+        },
+        accept: func(sd) {
+            return invoke_i(accept, sd);
+        },
+        send: func(sd, buff, flags = 0) {
+            return invoke_iii(send, sd, buff, flags);
+        },
+        sendto: func(sd, hostname, port, buff, flags = 0) {
+            return invoke_iiiii(sendto, sd, hostname, port, buff, flags);
+        },
+        recv: func(sd, len, flags = 0) {
+            return invoke_iii(recv, sd, len, flags);
+        },
+        recvfrom: func(sd, len, flags = 0) {
+            return invoke_iii(recvfrom, sd, len, flags);
+        },
+        errno: func() {
+            return invoke(errno);
+        }
+    };
+}();

module/makefile

@@ -0,0 +1,77 @@
+.PHONY = clean all winall
+
+dynamic_libs_so = libfib.so libkey.so libnasock.so libmat.so
+dynamic_libs_dll = libfib.dll libkey.dll libnasock.dll libmat.dll
+
+used_header = ../src/nasal.h ../src/util/util.h ../src/nasal_type.h ../src/nasal_gc.h
+used_object = ../build/util.o ../build/nasal_type.o ../build/nasal_gc.o
+
+STD = c++17
+
+ifndef OS
+	OS = $(shell uname)
+endif
+ifeq ($(OS), Darwin)
+	CXXFLAGS = -std=$(STD) -c -O3 -fPIC -mmacosx-version-min=10.15 -I ../src
+else
+	CXXFLAGS = -std=$(STD) -c -O3 -fPIC -I ../src
+endif
+
+all: $(dynamic_libs_so)
+	@ echo "[Compiling] done"
+winall: $(dynamic_libs_dll)
+	@ echo [Compiling] done
+
+libfib.so: fib.cpp $(used_header) $(used_object)
+	@ echo "[Compiling] libfib.so"
+	@ $(CXX) $(CXXFLAGS) fib.cpp -o fib.o
+	@ $(CXX) -shared -o libfib.so fib.o $(used_object)
+	@ rm fib.o
+libfib.dll: fib.cpp $(used_header) $(used_object)
+	@ echo [Compiling] libfib.dll
+	@ $(CXX) -std=$(STD) -c -O3 fib.cpp -fPIC -o fib.o -I ../src
+	@ $(CXX) -shared -o libfib.dll fib.o $(used_object) -static
+	@ del fib.o
+
+libkey.so: keyboard.cpp $(used_header) $(used_object)
+	@ echo "[Compiling] libkey.so"
+	@ $(CXX) $(CXXFLAGS) keyboard.cpp -o keyboard.o
+	@ $(CXX) -shared -o libkey.so keyboard.o $(used_object)
+	@ rm keyboard.o
+libkey.dll: keyboard.cpp $(used_header) $(used_object)
+	@ echo [Compiling] libkey.dll
+	@ $(CXX) -std=$(STD) -c -O3 keyboard.cpp -fPIC -o keyboard.o -static -I ../src
+	@ $(CXX) -shared -o libkey.dll keyboard.o $(used_object) -static
+	@ del keyboard.o
+
+libnasock.so: nasocket.cpp $(used_header) $(used_object)
+	@ echo "[Compiling] libnasock.so"
+	@ $(CXX) $(CXXFLAGS) nasocket.cpp -o nasocket.o
+	@ $(CXX) -shared -o libnasock.so nasocket.o $(used_object)
+	@ rm nasocket.o
+libnasock.dll: nasocket.cpp $(used_header) $(used_object)
+	@ echo [Compiling] libnasock.dll
+	@ $(CXX) -std=$(STD) -c -O3 nasocket.cpp -fPIC -I ../src -o nasocket.o -lwsock32 -static
+	@ $(CXX) -shared -o libnasock.dll nasocket.o $(used_object) -lwsock32 -static
+	@ del nasocket.o
+
+libmat.so: matrix.cpp $(used_header) $(used_object)
+	@ echo "[Compiling] libmat.so"
+	@ $(CXX) $(CXXFLAGS) matrix.cpp -o matrix.o
+	@ $(CXX) -shared -o libmat.so matrix.o $(used_object)
+	@ rm matrix.o
+libmat.dll: matrix.cpp $(used_header) $(used_object)
+	@ echo [Compiling] libmat.dll
+	@ $(CXX) -std=$(STD) -c -O3 matrix.cpp -fPIC -I ../src -o matrix.o -static
+	@ $(CXX) -shared -o libmat.dll matrix.o $(used_object) -static
+	@ del matrix.o
+
+clean:
+	@ echo "[clean] libfib.so" && if [ -e libfib.so ]; then rm libfib.so; fi
+	@ echo "[clean] libkey.so" && if [ -e libkey.so ]; then rm libkey.so; fi
+	@ echo "[clean] libnasock.so" && if [ -e libnasock.so ]; then rm libnasock.so; fi
+	@ echo "[clean] libmat.so" && if [ -e libmat.so ]; then rm libmat.so; fi
+	@ echo "[clean] libfib.dll" &&if [ -e libfib.dll ]; then rm libfib.dll; fi
+	@ echo "[clean] libkey.dll" &&if [ -e libkey.dll ]; then rm libkey.dll; fi
+	@ echo "[clean] libnasock.dll" &&if [ -e libnasock.dll ]; then rm libnasock.dll; fi
+	@ echo "[clean] libmat.dll" &&if [ -e libmat.dll ]; then rm libmat.dll; fi

module/matrix.cpp

@@ -0,0 +1,302 @@
+#include "../src/nasal.h"
+#include "../src/nasal_type.h"
+#include "../src/nasal_gc.h"
+#include <cmath>
+
+namespace nasal {
+
+var nas_vec2(var* args, usize size, gc* ngc) {
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(args[0]);
+    res.vec().elems.push_back(args[1]);
+    return res;
+}
+
+var nas_vec3(var* args, usize size, gc* ngc) {
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(args[0]);
+    res.vec().elems.push_back(args[1]);
+    res.vec().elems.push_back(args[2]);
+    return res;
+}
+
+var nas_vec2_add(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=2 || v1.size()!=2)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()+v1[0].num()));
+    res.vec().elems.push_back(var::num(v0[1].num()+v1[1].num()));
+    return res;
+}
+
+var nas_vec2_sub(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=2 || v1.size()!=2)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()-v1[0].num()));
+    res.vec().elems.push_back(var::num(v0[1].num()-v1[1].num()));
+    return res;
+}
+
+var nas_vec2_mult(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=2 || v1.size()!=2)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()*v1[0].num()));
+    res.vec().elems.push_back(var::num(v0[1].num()*v1[1].num()));
+    return res;
+}
+
+var nas_vec2_div(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=2 || v1.size()!=2)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()/v1[0].num()));
+    res.vec().elems.push_back(var::num(v0[1].num()/v1[1].num()));
+    return res;
+}
+
+var nas_vec2_neg(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    if (v0.size()!=2)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(-v0[0].num()));
+    res.vec().elems.push_back(var::num(-v0[1].num()));
+    return res;
+}
+
+var nas_vec2_norm(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    if (v0.size()!=2)
+        return nil;
+    auto x = v0[0].num();
+    auto y = v0[1].num();
+    auto t = std::sqrt(x*x+y*y);
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(x/t));
+    res.vec().elems.push_back(var::num(y/t));
+    return res;
+}
+
+var nas_vec2_len(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    if (v0.size()!=2)
+        return nil;
+    auto x = v0[0].num();
+    auto y = v0[1].num();
+    return var::num(std::sqrt(x*x+y*y));
+}
+
+var nas_vec2_dot(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=2 || v1.size()!=2)
+        return nil;
+    return var::num(v0[0].num()*v1[0].num()+v0[1].num()*v1[1].num());
+}
+
+var nas_vec3_add(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=3 || v1.size()!=3)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()+v1[0].num()));
+    res.vec().elems.push_back(var::num(v0[1].num()+v1[1].num()));
+    res.vec().elems.push_back(var::num(v0[2].num()+v1[2].num()));
+    return res;
+}
+
+var nas_vec3_sub(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=3 || v1.size()!=3)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()-v1[0].num()));
+    res.vec().elems.push_back(var::num(v0[1].num()-v1[1].num()));
+    res.vec().elems.push_back(var::num(v0[2].num()-v1[2].num()));
+    return res;
+}
+
+var nas_vec3_mult(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=3 || v1.size()!=3)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()*v1[0].num()));
+    res.vec().elems.push_back(var::num(v0[1].num()*v1[1].num()));
+    res.vec().elems.push_back(var::num(v0[2].num()*v1[2].num()));
+    return res;
+}
+
+var nas_vec3_div(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=3 || v1.size()!=3)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()/v1[0].num()));
+    res.vec().elems.push_back(var::num(v0[1].num()/v1[1].num()));
+    res.vec().elems.push_back(var::num(v0[2].num()/v1[2].num()));
+    return res;
+}
+
+var nas_vec3_neg(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    if (v0.size()!=3)
+        return nil;
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(-v0[0].num()));
+    res.vec().elems.push_back(var::num(-v0[1].num()));
+    res.vec().elems.push_back(var::num(-v0[2].num()));
+    return res;
+}
+
+var nas_vec3_norm(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    if (v0.size()!=3)
+        return nil;
+    auto x = v0[0].num();
+    auto y = v0[1].num();
+    auto z = v0[2].num();
+    auto t = std::sqrt(x*x+y*y+z*z);
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(x/t));
+    res.vec().elems.push_back(var::num(y/t));
+    res.vec().elems.push_back(var::num(z/t));
+    return res;
+}
+
+var nas_vec3_len(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    if (v0.size()!=3)
+        return nil;
+    auto x = v0[0].num();
+    auto y = v0[1].num();
+    auto z = v0[2].num();
+    return var::num(std::sqrt(x*x+y*y+z*z));
+}
+
+var nas_rotate_x(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    if (v0.size()!=3)
+        return nil;
+    auto angle = args[1].num();
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()));
+    res.vec().elems.push_back(var::num(v0[2].num()*std::sin(angle)+v0[1].num()*std::cos(angle)));
+    res.vec().elems.push_back(var::num(v0[2].num()*std::cos(angle)-v0[1].num()*std::sin(angle)));
+    return res;
+}
+
+var nas_rotate_y(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    if (v0.size()!=3)
+        return nil;
+    auto angle = args[1].num();
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()*std::cos(angle)-v0[2].num()*std::sin(angle)));
+    res.vec().elems.push_back(var::num(v0[1].num()));
+    res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[2].num()*std::cos(angle)));
+    return res;
+}
+
+var nas_rotate_z(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    if (v0.size()!=3)
+        return nil;
+    auto angle = args[1].num();
+    var res = ngc->alloc(vm_type::vm_vec);
+    res.vec().elems.push_back(var::num(v0[0].num()*std::cos(angle)-v0[1].num()*std::sin(angle)));
+    res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[1].num()*std::cos(angle)));
+    res.vec().elems.push_back(var::num(v0[2].num()));
+    return res;
+}
+
+var nas_vec3_dot(var* args, usize size, gc* ngc) {
+    if (!args[0].is_vec() || !args[1].is_vec())
+        return nil;
+    auto& v0 = args[0].vec().elems;
+    auto& v1 = args[1].vec().elems;
+    if (v0.size()!=3 || v1.size()!=3)
+        return nil;
+    return var::num(v0[0].num()*v1[0].num()+v0[1].num()*v1[1].num()+v0[2].num()*v1[2].num());
+}
+
+module_func_info func_tbl[] = {
+    {"nas_vec2", nas_vec2},
+    {"nas_vec2_add", nas_vec2_add},
+    {"nas_vec2_sub", nas_vec2_sub},
+    {"nas_vec2_mult", nas_vec2_mult},
+    {"nas_vec2_div", nas_vec2_div},
+    {"nas_vec2_neg", nas_vec2_neg},
+    {"nas_vec2_norm", nas_vec2_norm},
+    {"nas_vec2_len", nas_vec2_len},
+    {"nas_vec2_dot", nas_vec2_dot},
+    {"nas_vec3", nas_vec3},
+    {"nas_vec3_add", nas_vec3_add},
+    {"nas_vec3_sub", nas_vec3_sub},
+    {"nas_vec3_mult", nas_vec3_mult},
+    {"nas_vec3_div", nas_vec3_div},
+    {"nas_vec3_neg", nas_vec3_neg},
+    {"nas_vec3_norm", nas_vec3_norm},
+    {"nas_vec3_len", nas_vec3_len},
+    {"nas_rotate_x", nas_rotate_x},
+    {"nas_rotate_y", nas_rotate_y},
+    {"nas_rotate_z", nas_rotate_z},
+    {"nas_vec3_dot", nas_vec3_dot},
+    {nullptr, nullptr}
+};
+
+NASAL_EXPORT module_func_info* get() {
+    return func_tbl;
+}
+
+}

module/nasocket.cpp

@@ -0,0 +1,269 @@
+#include "../src/nasal.h"
+#include "../src/nasal_type.h"
+#include "../src/nasal_gc.h"
+
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (disable:4996)
+#endif
+
+#ifdef _WIN32
+// load socket library on windows platform
+#include <winsock.h>
+#pragma comment(lib,"ws2_32")
+
+class WSAmanager {
+private:
+    WSAData data;
+public:
+    WSAmanager() {
+        WSAStartup(0x1010, &data);
+    }
+    ~WSAmanager() {
+        WSACleanup();
+    }
+};
+// use static object to do WSAStartup and WSACleanup
+static WSAmanager win;
+
+#else
+#include <netdb.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#endif
+
+namespace nasal {
+
+var nas_socket(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num() || !args[1].is_num() || !args[2].is_num())
+        return nas_err("socket", "\"af\", \"type\", \"protocol\" should be number");
+    int sd = socket(args[0].num(), args[1].num(), args[2].num());
+    return var::num(static_cast<double>(sd));
+}
+
+var nas_closesocket(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("closesocket", "\"sd\" should be number");
+#ifdef _WIN32
+    return var::num(static_cast<double>(closesocket(args[0].num())));
+#else
+    return var::num(static_cast<double>(close(args[0].num())));
+#endif
+}
+
+var nas_shutdown(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("shutdown", "\"sd\" must be a number");
+    if (!args[1].is_num())
+        return nas_err("shutdown", "\"how\" must be a number");
+    return var::num(static_cast<double>(shutdown(args[0].num(), args[1].num())));
+}
+
+var nas_bind(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("bind", "\"sd\" muse be a number");
+    if (!args[1].is_str())
+        return nas_err("bind", "\"ip\" should be a string including an ip with correct format");
+    if (!args[2].is_num())
+        return nas_err("bind", "\"port\" must be a number");
+    sockaddr_in server;
+    memset(&server, 0, sizeof(sockaddr_in));
+    server.sin_family = AF_INET;
+    server.sin_addr.s_addr = inet_addr(args[1].str().c_str());
+    server.sin_port = htons(args[2].num());
+    return var::num(static_cast<double>(bind(
+        args[0].num(),
+        reinterpret_cast<sockaddr*>(&server),
+        sizeof(server)
+    )));
+}
+
+var nas_listen(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("listen", "\"sd\" must be a number");
+    if (!args[1].is_num())
+        return nas_err("listen", "\"backlog\" must be a number");
+    return var::num(static_cast<double>(listen(args[0].num(), args[1].num())));
+}
+
+var nas_connect(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("connect", "\"sd\" must be a number");
+    if (!args[1].is_str())
+        return nas_err("connect", "\"hostname\" must be a string");
+    if (!args[2].is_num())
+        return nas_err("connect", "\"port\" must be a number");
+    sockaddr_in addr;
+    memset(&addr, 0, sizeof(sockaddr_in));
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(args[2].num());
+    hostent* entry = gethostbyname(args[1].str().c_str());
+    memcpy(&addr.sin_addr, entry->h_addr, entry->h_length);
+    return var::num(static_cast<double>(connect(
+        args[0].num(),
+        reinterpret_cast<sockaddr*>(&addr),
+        sizeof(sockaddr_in)
+    )));
+}
+
+var nas_accept(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("accept", "\"sd\" must be a number");
+    sockaddr_in client;
+    int socklen = sizeof(sockaddr_in);
+#ifdef _WIN32
+    int client_sd = accept(
+        args[0].num(),
+        reinterpret_cast<sockaddr*>(&client),
+        &socklen
+    );
+#else
+    int client_sd = accept(
+        args[0].num(),
+        reinterpret_cast<sockaddr*>(&client),
+        reinterpret_cast<socklen_t*>(&socklen)
+    );
+#endif
+    var res = ngc->temp = ngc->alloc(vm_type::vm_hash);
+    auto& hash = res.hash().elems;
+    hash["sd"] = var::num(static_cast<double>(client_sd));
+    hash["ip"] = ngc->newstr(inet_ntoa(client.sin_addr));
+    ngc->temp = nil;
+    return res;
+}
+
+var nas_send(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("send", "\"sd\" must be a number");
+    if (!args[1].is_str())
+        return nas_err("send", "\"buff\" must be a string");
+    if (!args[2].is_num())
+        return nas_err("send", "\"flags\" muse be a number");
+    return var::num(static_cast<double>(send(
+        args[0].num(),
+        args[1].str().c_str(),
+        args[1].str().length(),
+        args[2].num()
+    )));
+}
+
+var nas_sendto(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("sendto", "\"sd\" must be a number");
+    if (!args[1].is_str())
+        return nas_err("sendto", "\"hostname\" must be a string");
+    if (!args[2].is_num())
+        return nas_err("sendto", "\"port\" must be a number");
+    if (!args[3].is_str())
+        return nas_err("sendto", "\"buff\" must be a string");
+    if (!args[4].is_num())
+        return nas_err("sendto", "\"flags\" must be a number");
+    sockaddr_in addr;
+    memset(&addr, 0, sizeof(sockaddr_in));
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(args[2].num());
+    hostent* entry = gethostbyname(args[1].str().c_str());
+    memcpy(&addr.sin_addr, entry->h_addr, entry->h_length);
+    return var::num(static_cast<double>(sendto(
+        args[0].num(),
+        args[3].str().c_str(),
+        args[3].str().length(),
+        args[4].num(),
+        reinterpret_cast<sockaddr*>(&addr),
+        sizeof(sockaddr_in)
+    )));
+}
+
+var nas_recv(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("recv", "\"sd\" must be a number");
+    if (!args[1].is_num())
+        return nas_err("recv", "\"len\" must be a number");
+    if (args[1].num()<=0 || args[1].num()>16*1024*1024)
+        return nas_err("recv", "\"len\" out of range");
+    if (!args[2].is_num())
+        return nas_err("recv", "\"flags\" muse be a number");
+    var res = ngc->temp = ngc->alloc(vm_type::vm_hash);
+    auto& hash = res.hash().elems;
+    char* buf = new char[static_cast<int>(args[1].num())];
+    auto recvsize = recv(args[0].num(), buf, args[1].num(), args[2].num());
+    hash["size"] = var::num(static_cast<double>(recvsize));
+    buf[recvsize>=0? recvsize:0] = 0;
+    hash["str"] = ngc->newstr(buf);
+    delete[] buf;
+    ngc->temp = nil;
+    return res;
+}
+
+var nas_recvfrom(var* args, usize size, gc* ngc) {
+    if (!args[0].is_num())
+        return nas_err("recvfrom", "\"sd\" must be a number");
+    if (!args[1].is_num())
+        return nas_err("recvfrom", "\"len\" must be a number");
+    if (args[1].num()<=0 || args[1].num()>16*1024*1024)
+        return nas_err("recvfrom", "\"len\" out of range");
+    if (!args[2].is_num())
+        return nas_err("recvfrom", "\"flags\" muse be a number");
+    sockaddr_in addr;
+    int socklen = sizeof(sockaddr_in);
+    var res = ngc->temp = ngc->alloc(vm_type::vm_hash);
+    auto& hash = res.hash().elems;
+    char* buf = new char[static_cast<int>(args[1].num()+1)];
+#ifdef _WIN32
+    auto recvsize = recvfrom(
+        args[0].num(),
+        buf,
+        args[1].num(),
+        args[2].num(),
+        reinterpret_cast<sockaddr*>(&addr),
+        &socklen
+    );
+#else
+    auto recvsize = recvfrom(
+        args[0].num(),
+        buf,
+        args[1].num(),
+        args[2].num(),
+        reinterpret_cast<sockaddr*>(&addr),
+        reinterpret_cast<socklen_t*>(&socklen)
+    );
+#endif
+    hash["size"] = var::num(static_cast<double>(recvsize));
+    buf[recvsize>=0? recvsize:0] = 0;
+    hash["str"] = ngc->newstr(buf);
+    delete[] buf;
+    hash["fromip"] = ngc->newstr(inet_ntoa(addr.sin_addr));
+    hash["port"] = var::num(ntohs(addr.sin_port));
+    ngc->temp = nil;
+    return res;
+}
+
+var nas_errno(var* args, usize size, gc* ngc) {
+    return ngc->newstr(strerror(errno));
+}
+
+module_func_info func_tbl[] = {
+    {"nas_socket", nas_socket},
+    {"nas_closesocket", nas_closesocket},
+    {"nas_shutdown", nas_shutdown},
+    {"nas_bind", nas_bind},
+    {"nas_listen", nas_listen},
+    {"nas_connect", nas_connect},
+    {"nas_accept", nas_accept},
+    {"nas_send", nas_send},
+    {"nas_sendto", nas_sendto},
+    {"nas_recv", nas_recv},
+    {"nas_recvfrom", nas_recvfrom},
+    {"nas_errno", nas_errno},
+    {nullptr, nullptr}
+};
+
+NASAL_EXPORT module_func_info* get() {
+    return func_tbl;
+}
+
+}

nasal-web-app/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "nasal-web-app",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "express": "^4.21.1",
+    "ffi-napi": "^4.0.3",
+    "yargs": "^17.7.2"
+  }
+}

nasal-web-app/public/index.html

@@ -0,0 +1,638 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Nasal Interpreter Web Demo</title>
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/codemirror.min.css" rel="stylesheet">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/theme/monokai.min.css" rel="stylesheet">
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background-color: #f5f5f5;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        .header {
+            text-align: center;
+            margin-bottom: 20px;
+            padding: 30px;
+            background: linear-gradient(145deg, #2c3e50, #3498db);
+            border-radius: 12px;
+            color: white;
+            box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+        }
+
+        .logo {
+            margin-bottom: 2px;
+        }
+
+        .ascii-art {
+            font-family: 'Monaco', monospace;
+            color: #ecf0f1;
+            text-shadow: 0 0 10px rgba(255,255,255,0.3);
+            margin: 0;
+            line-height: 1.2;
+            user-select: none;
+        }
+
+        .header h1 {
+            font-size: 2.5em;
+            margin: 0 0 10px 0;
+            font-weight: 700;
+            background: linear-gradient(to right, #fff, #ecf0f1);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            text-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+
+        .subtitle {
+            font-size: 1.2em;
+            color: #ecf0f1;
+            margin: 0 0 25px 0;
+            opacity: 0.9;
+        }
+
+        .credits {
+            display: flex;
+            justify-content: center;
+            gap: 30px;
+            flex-wrap: wrap;
+        }
+
+        .credit-item {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .credit-label {
+            color: #bdc3c7;
+            font-size: 0.9em;
+        }
+
+        .credit-link {
+            text-decoration: none;
+            padding: 5px 10px;
+            border-radius: 20px;
+            background: rgba(255,255,255,0.1);
+            transition: all 0.3s ease;
+            display: flex;
+            align-items: center;
+            gap: 5px;
+        }
+
+        .credit-link:hover {
+            background: rgba(255,255,255,0.2);
+            transform: translateY(-1px);
+            box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+        }
+
+        .highlight {
+            color: #fff;
+            font-weight: 500;
+        }
+
+        .author {
+            color: #bdc3c7;
+            font-size: 0.9em;
+        }
+
+        @media (max-width: 600px) {
+            .header {
+                padding: 20px;
+            }
+
+            .header h1 {
+                font-size: 2em;
+            }
+
+            .credits {
+                flex-direction: column;
+                align-items: center;
+                gap: 15px;
+            }
+        }
+
+        .editor-container {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin-bottom: 20px;
+        }
+
+        .code-section, .output-section {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+
+        .CodeMirror {
+            height: 400px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+        }
+
+        .output-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 10px;
+        }
+
+        .status-indicator {
+            display: inline-block;
+            width: 10px;
+            height: 10px;
+            border-radius: 50%;
+            margin-right: 5px;
+        }
+
+        .status-success {
+            background-color: #2ecc71;
+        }
+
+        .status-error {
+            background-color: #e74c3c;
+        }
+
+        #output {
+            height: 400px;
+            background: #282c34;
+            color: #abb2bf;
+            padding: 10px;
+            border-radius: 4px;
+            border: none;
+            overflow-y: auto;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            line-height: 1.5;
+        }
+
+        .message {
+            margin: 4px 0;
+            padding: 8px;
+            border-radius: 4px;
+            background: #2c313a;
+        }
+
+        .error-message {
+            border-left: 3px solid #e06c75;
+        }
+
+        .success-message {
+            border-left: 3px solid #98c379;
+        }
+
+        .timestamp {
+            color: #5c6370;
+            font-size: 0.9em;
+            margin-right: 8px;
+        }
+
+        .terminal-output {
+            margin: 8px 0 0 0;
+            padding: 8px;
+            background: #21252b;
+            border-radius: 3px;
+            white-space: pre-wrap;
+            overflow-x: auto;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            line-height: 1.5;
+        }
+
+        .terminal-output:empty {
+            display: none;
+        }
+
+        .message + .message {
+            margin-top: 8px;
+        }
+
+        .status-indicator {
+            display: inline-block;
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            margin-right: 6px;
+        }
+
+        .status-success {
+            background-color: #98c379;
+        }
+
+        .status-error {
+            background-color: #e06c75;
+        }
+
+        .output-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 10px;
+            padding: 0 10px;
+        }
+
+        .output-header h2 {
+            margin: 0;
+            color: #abb2bf;
+        }
+
+        .controls {
+            text-align: center;
+            margin: 20px 0;
+        }
+
+        button {
+            background-color: #3498db;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 16px;
+            transition: background-color 0.3s;
+            margin-right: 10px;
+        }
+
+        button:hover {
+            background-color: #2980b9;
+        }
+
+        button:disabled {
+            background-color: #bdc3c7;
+            cursor: not-allowed;
+        }
+
+        .examples {
+            margin-top: 20px;
+        }
+
+        .example-btn {
+            background-color: #27ae60;
+            margin: 0 5px;
+        }
+
+        .example-btn:hover {
+            background-color: #219a52;
+        }
+
+        .terminal-output {
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            margin: 0;
+            padding: 8px;
+            background: #2c3e50;
+            color: #ecf0f1;
+            border-radius: 4px;
+        }
+
+        .timestamp {
+            font-size: 0.9em;
+            color: #7f8c8d;
+            margin-bottom: 4px;
+        }
+
+        .terminal-red-bold {
+            color: #ff5555;
+            font-weight: bold;
+        }
+
+        .terminal-cyan-bold {
+            color: #8be9fd;
+            font-weight: bold;
+        }
+
+        .terminal-bold {
+            font-weight: bold;
+        }
+
+        .terminal-caret {
+            color: #ff5555;
+            font-weight: bold;
+        }
+
+        .error-message {
+            background: #2c3e50;
+            border-left: 4px solid #e74c3c;
+            padding: 10px;
+            margin: 5px 0;
+            color: #ecf0f1;
+        }
+
+        .success-message {
+            background: #2c3e50;
+            border-left: 4px solid #2ecc71;
+            padding: 10px;
+            margin: 5px 0;
+            color: #ecf0f1;
+        }
+
+        #output {
+            background: #34495e;
+            color: #ecf0f1;
+            padding: 15px;
+            border-radius: 4px;
+            border: none;
+            box-shadow: inset 0 2px 4px rgba(0,0,0,0.1);
+        }
+
+        .error-message pre, .success-message pre {
+            margin: 0;
+        }
+
+        /* Error message styling */
+        .error-type {
+            color: #e06c75;
+            font-weight: bold;
+        }
+
+        .error-desc {
+            color: #abb2bf;
+            font-weight: bold;
+        }
+
+        .error-arrow {
+            color: #56b6c2;
+            font-weight: bold;
+        }
+
+        .error-file {
+            color: #e06c75;
+            font-weight: bold;
+        }
+
+        .error-loc {
+            color: #abb2bf;
+        }
+
+        .error-line-number {
+            color: #56b6c2;
+            user-select: none;
+        }
+
+        .error-code {
+            color: #abb2bf;
+            margin-left: 8px;
+        }
+
+        .error-pointer-space {
+            color: #abb2bf;
+            white-space: pre;
+        }
+
+        .error-pointer {
+            color: #e06c75;
+            font-weight: bold;
+        }
+
+        .terminal-output {
+            margin: 8px 0 0 0;
+            padding: 8px;
+            background: #21252b;
+            border-radius: 3px;
+            white-space: pre-wrap;
+            overflow-x: auto;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            line-height: 1.5;
+        }
+
+        .timing-checkbox {
+            display: inline-flex;
+            align-items: center;
+            margin-left: 10px;
+            color: #abb2bf;
+        }
+
+        .timing-checkbox input {
+            margin-right: 5px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <div class="logo">
+                <pre class="ascii-art">
+       __                _
+    /\ \ \__ _ ___  __ _| |
+   /  \/ / _` / __|/ _` | |
+  / /\  / (_| \__ \ (_| | |
+  \_\ \/ \__,_|___/\__,_|_|
+        </pre>
+            </div>
+            <h1>Nasal Interpreter Web Demo</h1>
+            <p class="subtitle">Write and execute Nasal code directly in your browser</p>
+            <div class="credits">
+                <div class="credit-item">
+                    <span class="credit-label">Powered by</span>
+                    <a href="https://www.fgprc.org.cn/nasal_interpreter.html" class="credit-link">
+                        <span class="highlight">Nasal Interpreter</span>
+                        <span class="author">by ValKmjolnir</span>
+                    </a>
+                </div>
+                <div class="credit-item">
+                    <span class="credit-label">Web App by</span>
+                    <a href="https://sidi762.github.io" class="credit-link">
+                        <span class="highlight">LIANG Sidi</span>
+                    </a>
+                </div>
+            </div>
+        </div>
+
+        <div class="editor-container">
+            <div class="code-section">
+                <h2>Code Editor</h2>
+                <textarea id="code">var x = 1 + 2;
+println(x);</textarea>
+            </div>
+            <div class="output-section">
+                <div class="output-header">
+                    <h2>Output</h2>
+                    <div id="status"></div>
+                </div>
+                <div id="output"></div>
+            </div>
+        </div>
+
+        <div class="controls">
+            <button id="runBtn" onclick="runCode()">Run</button>
+            <button onclick="clearOutput()">Clear Output</button>
+            <label class="timing-checkbox">
+                <input type="checkbox" id="showTime"> Show execution time
+            </label>
+        </div>
+
+        <div class="examples">
+            <h3>Example Programs:</h3>
+            <button class="example-btn" onclick="loadExample('basic')">Basic Math</button>
+            <button class="example-btn" onclick="loadExample('loops')">Loops</button>
+            <button class="example-btn" onclick="loadExample('functions')">Functions</button>
+        </div>
+    </div>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/codemirror.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/mode/javascript/javascript.min.js"></script>
+    <script>
+        // Initialize CodeMirror
+        var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+            lineNumbers: true,
+            mode: "javascript", // Using JavaScript mode as it's close enough to Nasal
+            theme: "monokai",
+            autoCloseBrackets: true,
+            matchBrackets: true,
+            indentUnit: 4,
+            tabSize: 4,
+            lineWrapping: true
+        });
+
+        // Example programs
+        const examples = {
+            basic: `# Basic math operations
+var a = 10;
+var b = 5;
+
+println("Addition: ", a + b);
+println("Subtraction: ", a - b);
+println("Multiplication: ", a * b);
+println("Division: ", a / b);`,
+
+            loops: `# Loop example
+var sum = 0;
+for (var i = 1; i <= 5; i += 1) {
+    sum += i;
+    println("Current sum: ", sum);
+}
+println("Final sum: ", sum);`,
+
+            functions: `# Function example
+var factorial = func(n) {
+    if (n <= 1) return 1;
+    return n * factorial(n - 1);
+}
+
+for (var i = 0; i <= 5; i += 1) {
+    println("Factorial of ", i, " is ", factorial(i));
+}`
+        };
+
+        function loadExample(type) {
+            editor.setValue(examples[type]);
+        }
+
+        function formatTerminalOutput(text) {
+            // Remove the output/error message header if present
+            text = text.replace(/^\[(.*?)\] (Output|Error):\s*\n/, '');
+            
+            // Convert ANSI color codes to CSS classes
+            const colorMap = {
+                '\u001b[91;1m': '<span class="terminal-red-bold">',    // bright red bold
+                '\u001b[36;1m': '<span class="terminal-cyan-bold">',   // bright cyan bold
+                '\u001b[0m': '</span>',                                // reset
+                '\u001b[1m': '<span class="terminal-bold">'           // bold
+            };
+
+            // Replace ANSI codes with HTML spans
+            Object.entries(colorMap).forEach(([code, html]) => {
+                text = text.replace(new RegExp(escapeRegExp(code), 'g'), html);
+            });
+
+            // Preserve whitespace and arrow formatting
+            text = text.replace(/\^/g, '<span class="terminal-caret">^</span>');
+            
+            return text;
+        }
+
+        // Utility function to escape special characters in strings for RegExp
+        function escapeRegExp(string) {
+            return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        }
+
+        function formatErrorMessage(text) {
+            // Replace ANSI escape codes with CSS classes
+            return text
+                // Remove any existing formatting first
+                .replace(/\u001b\[\d+(?:;\d+)*m/g, '')
+                // Format the error line
+                .replace(/^parse: (.+)$/m, '<span class="error-type">parse:</span> <span class="error-desc">$1</span>')
+                // Format the file location
+                .replace(/^\s*--> (.+?)(\d+):(\d+)$/m, '<span class="error-arrow">--></span> <span class="error-file">$1</span><span class="error-loc">$2:$3</span>')
+                // Format the code line
+                .replace(/^(\d+ \|)(.*)$/m, '<span class="error-line-number">$1</span><span class="error-code">$2</span>')
+                // Format the error pointer
+                .replace(/^(\s*\|)(\s*)(\^+)$/m, '<span class="error-line-number">$1</span><span class="error-pointer-space">$2</span><span class="error-pointer">$3</span>');
+        }
+
+        async function runCode() {
+            const runBtn = document.getElementById('runBtn');
+            const output = document.getElementById('output');
+            const status = document.getElementById('status');
+            const showTime = document.getElementById('showTime').checked;
+            
+            try {
+                runBtn.disabled = true;
+                const code = editor.getValue();
+                
+                const response = await fetch('/eval', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ 
+                        code,
+                        showTime 
+                    })
+                });
+                
+                const data = await response.json();
+                const timestamp = new Date().toLocaleTimeString();
+                
+                if (data.error) {
+                    status.innerHTML = '<span class="status-indicator status-error"></span>';
+                    output.innerHTML += `<div class="message error-message">
+                        <span class="timestamp">[${timestamp}]</span>
+                        <pre class="terminal-output">${formatErrorMessage(data.error)}</pre>
+                    </div>`;
+                } else {
+                    status.innerHTML = '<span class="status-indicator status-success"></span>';
+                    output.innerHTML += `<div class="message success-message">
+                        <span class="timestamp">[${timestamp}]</span>
+                        <pre class="terminal-output">${data.result.trim()}</pre>
+                    </div>`;
+                }
+                
+                output.scrollTop = output.scrollHeight;
+            } catch (err) {
+                status.innerHTML = '<span class="status-indicator status-error"></span>';
+                output.innerHTML += `<div class="message error-message">
+                    <span class="timestamp">[${new Date().toLocaleTimeString()}]</span>
+                    <pre class="terminal-output">Server Error: ${err.message}</pre>
+                </div>`;
+            } finally {
+                runBtn.disabled = false;
+            }
+        }
+
+        function clearOutput() {
+            document.getElementById('output').innerHTML = '';
+            document.getElementById('status').innerHTML = '';
+        }
+
+        // Utility function to escape HTML to prevent XSS
+        function escapeHtml(text) {
+            const map = {
+                '&': '&amp;',
+                '<': '&lt;',
+                '>': '&gt;',
+                '"': '&quot;',
+                "'": '&#039;'
+            };
+            return text.replace(/[&<>"']/g, function(m) { return map[m]; });
+        }
+    </script>
+</body>
+</html>

nasal-web-app/public/repl.html

@@ -0,0 +1,240 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Nasal Interpreter Web REPL</title>
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/codemirror.min.css" rel="stylesheet">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/theme/monokai.min.css" rel="stylesheet">
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background-color: #2c3e50;
+            color: #ecf0f1;
+        }
+
+        .container {
+            max-width: 1000px;
+            margin: 0 auto;
+        }
+
+        .header {
+            text-align: center;
+            margin-bottom: 20px;
+        }
+
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+        }
+
+        .repl-container {
+            background: #34495e;
+            padding: 20px;
+            border-radius: 8px;
+            height: 600px;
+            display: flex;
+            flex-direction: column;
+        }
+
+        .repl-output {
+            flex-grow: 1;
+            background: #21252b;
+            color: #abb2bf;
+            padding: 10px;
+            border-radius: 4px;
+            margin-bottom: 10px;
+            overflow-y: auto;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            line-height: 1.5;
+            white-space: pre-wrap;
+        }
+
+        .repl-input-container {
+            display: flex;
+            align-items: flex-start;
+        }
+
+        .repl-prompt {
+            color: #3498db;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            padding: 5px;
+            user-select: none;
+        }
+
+        .repl-input {
+            flex-grow: 1;
+            background: #21252b;
+            border: none;
+            color: #abb2bf;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            font-size: 14px;
+            padding: 5px;
+            outline: none;
+            resize: none;
+            min-height: 24px;
+            overflow-y: hidden;
+        }
+
+        .controls {
+            text-align: center;
+            margin-top: 20px;
+        }
+
+        button {
+            background-color: #3498db;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 16px;
+            transition: background-color 0.3s;
+            margin-right: 10px;
+        }
+
+        button:hover {
+            background-color: #2980b9;
+        }
+
+        button:disabled {
+            background-color: #bdc3c7;
+            cursor: not-allowed;
+        }
+
+        .examples {
+            margin-top: 20px;
+            text-align: center;
+        }
+
+        .example-btn {
+            background-color: #27ae60;
+            margin: 0 5px;
+        }
+
+        .example-btn:hover {
+            background-color: #219a52;
+        }
+
+        .output-line {
+            margin: 2px 0;
+            min-height: 1.2em;
+        }
+
+        .input-line {
+            color: #3498db;
+            white-space: pre;
+        }
+
+        .error-line {
+            color: #e74c3c;
+            white-space: pre;
+        }
+
+        .result-line {
+            color: #2ecc71;
+            white-space: pre;
+            margin-left: 4px;  /* Slight indent for results */
+        }
+
+        .system-message {
+            color: #7f8c8d;
+            font-style: italic;
+        }
+
+        .help-text {
+            color: #95a5a6;
+            white-space: pre;
+            font-family: monospace;
+        }
+
+        .error-type {
+            color: #ff5f5f;
+            font-weight: bold;
+        }
+
+        .error-desc {
+            color: #abb2bf;
+            font-weight: bold;
+        }
+
+        .error-arrow, .error-line-number {
+            color: #56b6c2;
+            font-weight: bold;
+        }
+
+        .error-file {
+            color: #ff5f5f;
+            font-weight: bold;
+        }
+
+        .error-code {
+            color: #abb2bf;
+        }
+
+        .error-pointer-space {
+            white-space: pre;
+        }
+
+        .error-pointer {
+            color: #ff5f5f;
+            font-weight: bold;
+        }
+
+        .error-red-bold {
+            color: #e06c75;
+            font-weight: bold;
+        }
+
+        .error-cyan-bold {
+            color: #56b6c2;
+            font-weight: bold;
+        }
+
+        .error-bold {
+            font-weight: bold;
+        }
+
+        @media (max-width: 768px) {
+            .repl-container {
+                height: 400px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>Nasal Interpreter Web REPL</h1>
+            <p>Interactive Read-Eval-Print Loop for Nasal</p>
+            <p>Powered by ValKmjolnir's <a href="https://www.fgprc.org.cn/nasal_interpreter.html">Nasal Interpreter</a>, Web App by <a href="https://sidi762.github.io">LIANG Sidi</a></p>
+        </div>
+
+        <div class="repl-container">
+            <div id="repl-output" class="repl-output">
+                <div class="output-line">Welcome to Nasal Web REPL Demo!</div>
+            </div>
+            <div class="repl-input-container">
+                <span class="repl-prompt">>>></span>
+                <textarea id="repl-input" class="repl-input" rows="1" 
+                    placeholder="Enter Nasal code here..."></textarea>
+            </div>
+        </div>
+
+        <div class="controls">
+            <button onclick="clearREPL()">Clear REPL</button>
+        </div>
+
+        <div class="examples">
+            <h3>Example Commands:</h3>
+            <button class="example-btn" onclick="insertExample('basic')">Basic Math</button>
+            <button class="example-btn" onclick="insertExample('loops')">Loops</button>
+            <button class="example-btn" onclick="insertExample('functions')">Functions</button>
+        </div>
+    </div>
+
+    <script src="repl.js"></script>
+</body>
+</html> 

nasal-web-app/public/repl.js

@@ -0,0 +1,249 @@
+let replSessionId = null;
+let multilineInput = [];
+let historyIndex = -1;
+let commandHistory = [];
+let multilineBuffer = [];
+let isMultilineMode = false;
+
+// Initialize REPL
+async function initRepl() {
+    try {
+        const response = await fetch('/repl/init', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' }
+        });
+        const data = await response.json();
+        if (data.sessionId) {
+            replSessionId = data.sessionId;
+            console.log('REPL session initialized:', replSessionId);
+            
+            // Display version info
+            appendOutput('Nasal REPL interpreter version ' + data.version);
+            appendOutput('Type your code below and press Enter to execute.');
+            appendOutput('Use Shift+Enter for multiline input.\n');
+            showPrompt();
+        } else {
+            throw new Error('Failed to initialize REPL session');
+        }
+    } catch (err) {
+        appendOutput(`Error: ${err.message}`, 'error-line');
+    }
+}
+
+// Format error messages to match command-line REPL
+function formatError(error) {
+    // Split the error message into lines
+    const lines = error.split('\n');
+    return lines.map(line => {
+        // Add appropriate indentation for the error pointer
+        if (line.includes('-->')) {
+            return '  ' + line;
+        } else if (line.includes('^')) {
+            return '  ' + line;
+        }
+        return line;
+    }).join('\n');
+}
+
+// Handle input
+const input = document.getElementById('repl-input');
+input.addEventListener('keydown', async (e) => {
+    if (e.key === 'Enter') {
+        if (e.shiftKey) {
+            // Shift+Enter: add newline
+            const pos = input.selectionStart;
+            const value = input.value;
+            input.value = value.substring(0, pos) + '\n' + value.substring(pos);
+            input.selectionStart = input.selectionEnd = pos + 1;
+            input.style.height = 'auto';
+            input.style.height = input.scrollHeight + 'px';
+            e.preventDefault();
+            return;
+        }
+        e.preventDefault();
+        
+        const code = input.value.trim();
+        
+        // Skip empty lines but still show prompt
+        if (!code) {
+            showPrompt(isMultilineMode ? '... ' : '>>> ');
+            return;
+        }
+
+        try {
+            // First check if input is complete
+            const checkResponse = await fetch('/repl/eval', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    sessionId: replSessionId,
+                    line: code,
+                    check: true,
+                    buffer: multilineBuffer // Send existing buffer
+                })
+            });
+
+            const checkData = await checkResponse.json();
+            
+            if (checkData.needsMore) {
+                // Add to multiline buffer and show continuation prompt
+                multilineBuffer.push(code);
+                isMultilineMode = true;
+                
+                // Display the input with continuation prompt
+                appendOutput(code, 'input-line', multilineBuffer.length === 1 ? '>>> ' : '... ');
+                
+                input.value = '';
+                showPrompt('... ');
+                return;
+            }
+
+            // If we were in multiline mode, add the final line
+            if (isMultilineMode) {
+                multilineBuffer.push(code);
+            }
+
+            // Get the complete code to evaluate
+            const fullCode = isMultilineMode ? 
+                multilineBuffer.join('\n') : code;
+
+            // Display the input
+            appendOutput(code, 'input-line', isMultilineMode ? '... ' : '>>> ');
+
+            // Evaluate the code
+            const response = await fetch('/repl/eval', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    sessionId: replSessionId,
+                    line: fullCode
+                })
+            });
+
+            const data = await response.json();
+            
+            if (data.error) {
+                appendOutput(formatError(data.error.trim()), 'error-line');
+            } else if (data.result) {
+                handleResult(data.result);
+            }
+
+            // Reset multiline state
+            multilineBuffer = [];
+            isMultilineMode = false;
+            input.value = '';
+            showPrompt('>>> ');
+
+        } catch (err) {
+            appendOutput(`Error: ${err.message}`, 'error-line');
+            multilineBuffer = [];
+            isMultilineMode = false;
+            input.value = '';
+            showPrompt('>>> ');
+        }
+    } else if (e.key === 'ArrowUp') {
+        e.preventDefault();
+        if (historyIndex > 0) {
+            historyIndex--;
+            input.value = commandHistory[historyIndex];
+        }
+    } else if (e.key === 'ArrowDown') {
+        e.preventDefault();
+        if (historyIndex < commandHistory.length - 1) {
+            historyIndex++;
+            input.value = commandHistory[historyIndex];
+        } else {
+            historyIndex = commandHistory.length;
+            input.value = '';
+        }
+    }
+});
+
+// Auto-resize input
+input.addEventListener('input', () => {
+    input.style.height = 'auto';
+    input.style.height = input.scrollHeight + 'px';
+});
+
+// Show prompt and scroll to bottom
+function showPrompt(prompt = '>>> ') {
+    const promptSpan = document.querySelector('.repl-prompt');
+    if (promptSpan) {
+        promptSpan.textContent = prompt;
+    }
+}
+
+// Append output to REPL
+function appendOutput(text, className = '', prefix = '') {
+    const output = document.getElementById('repl-output');
+    const line = document.createElement('div');
+    line.className = `output-line ${className}`;
+
+    line.innerHTML = prefix + formatErrorMessage(text);
+   
+    
+    output.appendChild(line);
+    output.scrollTop = output.scrollHeight;
+}
+
+// Clear REPL
+function clearREPL() {
+    const output = document.getElementById('repl-output');
+    output.innerHTML = '';
+    appendOutput('Screen cleared', 'system-message');
+    showPrompt();
+}
+
+// Example snippets
+const examples = {
+    basic: `var x = 1011 + 1013;
+println("x = ", x);`,
+    
+    loops: `var sum = 0;
+for (var i = 1; i <= 5; i += 1) {
+    sum += i;
+}
+println("Sum:", sum);`,
+    
+    functions: `var factorial = func(n) {
+    if (n <= 1) return 1;
+    return n * factorial(n - 1);
+};
+factorial(5);`
+};
+
+// Insert example into input
+function insertExample(type) {
+    input.value = examples[type];
+    input.style.height = 'auto';
+    input.style.height = input.scrollHeight + 'px';
+    input.focus();
+}
+
+// Initialize REPL on page load
+window.addEventListener('load', initRepl);
+
+// Add these utility functions
+function formatErrorMessage(text) {
+    // Replace ANSI escape codes with CSS classes
+    return text
+        // Remove any existing formatting first
+        .replace(/\u001b\[\d+(?:;\d+)*m/g, '')
+        // Format the error line
+        .replace(/^parse: (.+)$/m, '<span class="error-type">parse:</span> <span class="error-desc">$1</span>')
+        // Format the file location
+        .replace(/^\s*--> (.+?)(\d+):(\d+)$/m, '<span class="error-arrow">--></span> <span class="error-file">$1</span><span class="error-loc">$2:$3</span>')
+        // Format the code line
+        .replace(/^(\d+ \|)(.*)$/m, '<span class="error-line-number">$1</span><span class="error-code">$2</span>')
+        // Format the error pointer
+        .replace(/^(\s*\|)(\s*)(\^+)$/m, '<span class="error-line-number">$1</span><span class="error-pointer-space">$2</span><span class="error-pointer">$3</span>');
+}
+
+function handleResult(result) {
+    const lines = result.split('\n');
+    lines.forEach(line => {
+        if (line.trim()) {
+            appendOutput(line.trim(), 'result-line');
+        }
+    });
+}

nasal-web-app/server.js

@@ -0,0 +1,96 @@
+const express = require('express');
+const path = require('path');
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+const koffi = require('koffi');
+require('expose-gc');
+
+// Parse command line arguments
+const argv = yargs(hideBin(process.argv))
+    .usage('Usage: $0 [options]')
+    .option('verbose', {
+        alias: 'v',
+        type: 'boolean',
+        description: 'Run with verbose logging'
+    })
+    .option('port', {
+        alias: 'p',
+        type: 'number',
+        description: 'Port to run the server on',
+        default: 3000
+    })
+    .option('host', {
+        type: 'string',
+        description: 'Host to run the server on',
+        default: 'localhost'
+    })
+    .help()
+    .alias('help', 'h')
+    .version()
+    .argv;
+
+const app = express();
+
+app.use(express.json());
+app.use(express.static('public'));
+
+let nasalLib;
+try {
+    // First load the library
+    const lib = koffi.load(path.join(__dirname, '../module/libnasal-web.dylib'));
+
+    // Then declare the functions explicitly
+    nasalLib = {
+        nasal_init: lib.func('nasal_init', 'void*', []),
+        nasal_cleanup: lib.func('nasal_cleanup', 'void', ['void*']),
+        nasal_eval: lib.func('nasal_eval', 'const char*', ['void*', 'const char*', 'int']),
+        nasal_get_error: lib.func('nasal_get_error', 'const char*', ['void*'])
+    };
+
+} catch (err) {
+    console.error('Failed to load nasal library:', err);
+    process.exit(1);
+}
+
+app.post('/eval', (req, res) => {
+    const { code, showTime = false } = req.body;
+    if (!code) {
+        return res.status(400).json({ error: 'No code provided' });
+    }
+
+    if (argv.verbose) {
+        console.log('Received code evaluation request:', code);
+        console.log('Show time:', showTime);
+    }
+
+    const ctx = nasalLib.nasal_init();
+    try {
+        const result = nasalLib.nasal_eval(ctx, code, showTime ? 1 : 0);
+        const error = nasalLib.nasal_get_error(ctx);
+
+        if (error && error !== 'null') {
+            if (argv.verbose) console.log('Nasal error:', error);
+            res.json({ error: error });
+        } else if (result && result.trim() !== '') {
+            if (argv.verbose) console.log('Nasal output:', result);
+            res.json({ result: result });
+        } else {
+            if (argv.verbose) console.log('No output or error returned');
+            res.json({ error: 'No output or error returned' });
+        }
+    } catch (err) {
+        if (argv.verbose) console.error('Server error:', err);
+        res.status(500).json({ error: err.message });
+    } finally {
+        if (argv.verbose) console.log('Cleaning up Nasal context');
+        nasalLib.nasal_cleanup(ctx);
+        global.gc()
+    }
+});
+
+const PORT = argv.port || 3000;
+app.listen(PORT, () => {
+    console.log(`Server running on port ${PORT}`);
+    console.log(`Visit http://localhost:${PORT} to use the Nasal interpreter`);
+    if (argv.verbose) console.log('Verbose logging enabled');
+});

nasal-web-app/server_repl.js

@@ -0,0 +1,188 @@
+const express = require('express');
+const path = require('path');
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+const koffi = require('koffi');
+
+// Parse command line arguments
+const argv = yargs(hideBin(process.argv))
+    .usage('Usage: $0 [options]')
+    .option('verbose', {
+        alias: 'v',
+        type: 'boolean',
+        description: 'Run with verbose logging'
+    })
+    .option('port', {
+        alias: 'p',
+        type: 'number',
+        description: 'Port to run the server on',
+        default: 3001
+    })
+    .option('host', {
+        type: 'string',
+        description: 'Host to run the server on',
+        default: 'localhost'
+    })
+    .help()
+    .alias('help', 'h')
+    .version()
+    .argv;
+
+const app = express();
+app.use(express.json());
+app.use(express.static('public'));
+
+
+// Load Nasal REPL library functions
+let nasalLib;
+try {
+    const lib = koffi.load(path.join(__dirname, '../module/libnasal-web.dylib'));
+    
+    nasalLib = {
+        nasal_repl_init: lib.func('nasal_repl_init', 'void*', []),
+        nasal_repl_cleanup: lib.func('nasal_repl_cleanup', 'void', ['void*']),
+        nasal_repl_eval: lib.func('nasal_repl_eval', 'const char*', ['void*', 'const char*']),
+        nasal_repl_is_complete: lib.func('nasal_repl_is_complete', 'int', ['void*', 'const char*']),
+        nasal_repl_get_version: lib.func('nasal_repl_get_version', 'const char*', [])
+    };
+
+    if (argv.verbose) {
+        console.log('REPL Library loaded successfully');
+    }
+} catch (err) {
+    console.error('Failed to load REPL library:', err);
+    process.exit(1);
+}
+
+// Store active REPL sessions
+const replSessions = new Map();
+
+// Clean up inactive sessions periodically (30 minutes timeout)
+const SESSION_TIMEOUT = 30 * 60 * 1000;
+setInterval(() => {
+    const now = Date.now();
+    for (const [sessionId, session] of replSessions.entries()) {
+        if (now - session.lastAccess > SESSION_TIMEOUT) {
+            if (argv.verbose) {
+                console.log(`Cleaning up inactive session: ${sessionId}`);
+            }
+            nasalLib.nasal_repl_cleanup(session.context);
+            replSessions.delete(sessionId);
+        }
+    }
+}, 60000); // Check every minute
+
+app.post('/repl/init', (req, res) => {
+    try {
+        const ctx = nasalLib.nasal_repl_init();
+        const sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const version = nasalLib.nasal_repl_get_version();
+        
+        replSessions.set(sessionId, {
+            context: ctx,
+            lastAccess: Date.now()
+        });
+
+        if (argv.verbose) {
+            console.log(`New REPL session initialized: ${sessionId}`);
+        }
+
+        res.json({ 
+            sessionId,
+            version
+        });
+    } catch (err) {
+        if (argv.verbose) {
+            console.error('Failed to initialize REPL session:', err);
+        }
+        res.status(500).json({ error: 'Failed to initialize REPL session' });
+    }
+});
+
+app.post('/repl/eval', (req, res) => {
+    const { sessionId, line, check, buffer } = req.body;
+    
+    if (!sessionId || !replSessions.has(sessionId)) {
+        return res.status(400).json({ error: 'Invalid or expired session' });
+    }
+
+    if (!line) {
+        return res.status(400).json({ error: 'No code provided' });
+    }
+
+    try {
+        const session = replSessions.get(sessionId);
+        session.lastAccess = Date.now();
+
+        if (check) {
+            const codeToCheck = buffer ? [...buffer, line].join('\n') : line;
+            const isComplete = nasalLib.nasal_repl_is_complete(session.context, codeToCheck);
+            
+            if (isComplete === 1) {
+                return res.json({ needsMore: true });
+            } else if (isComplete === -1) {
+                return res.json({ error: 'Invalid input' });
+            }
+        }
+
+        const result = nasalLib.nasal_repl_eval(session.context, line);
+        
+        if (argv.verbose) {
+            console.log(`REPL evaluation for session ${sessionId}:`, { line, result });
+        }
+
+        res.json({ result });
+    } catch (err) {
+        if (argv.verbose) {
+            console.error(`REPL evaluation error for session ${sessionId}:`, err);
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.post('/repl/cleanup', (req, res) => {
+    const { sessionId } = req.body;
+    
+    if (!sessionId || !replSessions.has(sessionId)) {
+        return res.status(400).json({ error: 'Invalid session' });
+    }
+
+    try {
+        const session = replSessions.get(sessionId);
+        nasalLib.nasal_repl_cleanup(session.context);
+        replSessions.delete(sessionId);
+
+        if (argv.verbose) {
+            console.log(`REPL session cleaned up: ${sessionId}`);
+        }
+
+        res.json({ message: 'Session cleaned up successfully' });
+    } catch (err) {
+        if (argv.verbose) {
+            console.error(`Failed to cleanup session ${sessionId}:`, err);
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// Handle cleanup on server shutdown
+process.on('SIGINT', () => {
+    console.log('\nCleaning up REPL sessions before exit...');
+    for (const [sessionId, session] of replSessions.entries()) {
+        try {
+            nasalLib.nasal_repl_cleanup(session.context);
+            if (argv.verbose) {
+                console.log(`Cleaned up session: ${sessionId}`);
+            }
+        } catch (err) {
+            console.error(`Error cleaning up session ${sessionId}:`, err);
+        }
+    }
+    process.exit(0);
+});
+
+const PORT = argv.port || 3001;
+app.listen(PORT, () => {
+    console.log(`REPL Server running on http://localhost:${PORT}`);
+    if (argv.verbose) console.log('Verbose logging enabled');
+}); 

nasal-web-app/std

@@ -0,0 +1 @@
+../std

nasal.h

@@ -1,128 +0,0 @@
-#ifndef __NASAL_H__
-#define __NASAL_H__
-
-#pragma GCC optimize(2)
-
-#include <stdint.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <algorithm>
-#include <cstring>
-#include <cstdlib>
-#include <ctime>
-#include <cmath>
-#include <thread>
-#include <list>
-#include <stack>
-#include <queue>
-#include <vector>
-#include <unordered_map>
-
-/*
-	check if a string can be converted to a number
-	if this string cannot be converted to a number,it will return nan
-*/
-inline double hex_to_double(const char* str)
-{
-	double ret=0;
-	for(;*str;++str)
-	{
-		ret*=16;
-		if('0'<=*str && *str<='9')
-			ret+=(*str-'0');
-		else if('a'<=*str && *str<='f')
-			ret+=(*str-'a'+10);
-		else if('A'<=*str && *str<='F')
-			ret+=(*str-'A'+10);
-		else
-			return nan("");
-	}
-	return ret;
-}
-inline double oct_to_double(const char* str)
-{
-	double ret=0;
-	for(;*str;++str)
-	{
-		ret*=8;
-		if('0'<=*str && *str<='8')
-			ret+=(*str-'0');
-		else
-			return nan("");
-	}
-	return ret;
-}
-inline double dec_to_double(const char* str)
-{
-	double ret=0,negative=1,num_pow=0;
-	while('0'<=*str && *str<='9')
-		ret=ret*10+(*str++-'0');
-	if(!*str) return ret;
-	if(*str=='.')
-	{
-		if(!*++str) return nan("");
-		num_pow=0.1;
-		while('0'<=*str && *str<='9')
-		{
-			ret+=num_pow*(*str++-'0');
-			num_pow*=0.1;
-		}
-		if(!*str) return ret;
-	}
-	if(*str!='e' && *str!='E')
-		return nan("");
-	if(!*++str) return nan("");
-	if(*str=='-' || *str=='+')
-		negative=(*str++=='-'? -1:1);
-	if(!*str) return nan("");
-	num_pow=0;
-	for(;*str;++str)
-	{
-		if('0'<=*str && *str<='9')
-			num_pow=num_pow*10+(*str-'0');
-		else
-			return nan("");
-	}
-	return ret*std::pow(10,negative*num_pow);
-}
-double str2num(const char* str)
-{
-	bool is_negative=false;
-	double ret_num=0;
-	if(*str=='-' || *str=='+')
-		is_negative=(*str++=='-');
-	if(!*str)
-		return nan("");
-	if(str[0]=='0' && str[1]=='x')
-		ret_num=hex_to_double(str+2);
-	else if(str[0]=='0' && str[1]=='o')
-		ret_num=oct_to_double(str+2);
-	else
-		ret_num=dec_to_double(str);
-	return is_negative?-ret_num:ret_num;
-}
-
-/*
-	trans_number_to_string:
-	convert number to string
-*/
-std::string num2str(double number)
-{
-	std::ostringstream ss;
-	ss<<number;
-	return ss.str();
-}
-#include "nasal_lexer.h"
-#include "nasal_ast.h"
-#include "nasal_parse.h"
-#include "nasal_import.h"
-#include "nasal_gc.h"
-#include "nasal_builtin.h"
-#include "nasal_codegen.h"
-#include "nasal_vm.h"
-
-#endif

nasal_ast.h

@@ -1,142 +0,0 @@
-#ifndef __NASAL_AST_H__
-#define __NASAL_AST_H__
-
-enum ast_node
-{
-    ast_null=0,
-    ast_root,ast_block,
-    ast_nil,ast_num,ast_str,ast_id,ast_func,ast_hash,ast_vec,
-    ast_hashmember,ast_call,ast_callh,ast_callv,ast_callf,ast_subvec,
-    ast_args,ast_default_arg,ast_dynamic_id,
-    ast_and,ast_or,
-    ast_equal,ast_addeq,ast_subeq,ast_multeq,ast_diveq,ast_lnkeq,
-    ast_cmpeq,ast_neq,
-    ast_less,ast_leq,
-    ast_grt,ast_geq,
-    ast_add,ast_sub,ast_mult,ast_div,ast_link,
-    ast_neg,ast_not,
-    ast_trino,
-    ast_for,ast_forindex,ast_foreach,ast_while,ast_new_iter,
-    ast_conditional,ast_if,ast_elsif,ast_else,
-    ast_multi_id,ast_multi_scalar,
-    ast_def,ast_multi_assign,
-    ast_continue,ast_break,ast_ret
-};
-
-const char* ast_name[]=
-{
-    "null",
-    "root","block",
-    "nil","num","str","id","func","hash","vec",
-    "hashmember","call","callh","callv","callf","subvec",
-    "args","deflt_arg","dyn_id",
-    "and","or",
-    "=","+=","-=","*=","/=","~=",
-    "==","!=",
-    "<","<=",
-    ">",">=",
-    "+","-","*","/","~",
-    "unary-","unary!",
-    "trino",
-    "for","forindex","foreach","while","iter",
-    "conditional","if","elsif","else",
-    "multi_id","multi_scalar",
-    "def","multi_assign",
-    "continue","break","return"
-};
-
-class nasal_ast
-{
-private:
-    int         line;
-    int         type;
-    double      num;
-    std::string str;
-    std::vector<nasal_ast> children;
-public:
-    nasal_ast(){line=0;type=ast_null;}
-    nasal_ast(int l,int t){line=l;type=t;}
-    nasal_ast(const nasal_ast&);
-    nasal_ast(nasal_ast&&);
-    nasal_ast& operator=(const nasal_ast&);
-    nasal_ast& operator=(nasal_ast&&);
-    void   print_ast(int);
-    void   clear();
-    void   add_child(nasal_ast&& ast){children.push_back(std::move(ast));}
-    void   set_line(int l){line=l;}
-    void   set_type(int t){type=t;}
-    void   set_str(std::string& s){str=s;}
-    void   set_num(double n){num=n;}
-    int    get_line(){return line;}
-    int    get_type(){return type;}
-    double get_num(){return num;}
-    std::string& get_str(){return str;}
-    std::vector<nasal_ast>& get_children(){return children;}
-};
-
-nasal_ast::nasal_ast(const nasal_ast& tmp)
-{
-    line=tmp.line;
-    type=tmp.type;
-    str =tmp.str;
-    num =tmp.num;
-    children=tmp.children;
-    return;
-}
-
-nasal_ast::nasal_ast(nasal_ast&& tmp)
-{
-    line=tmp.line;
-    type=tmp.type;
-    str.swap(tmp.str);
-    num =tmp.num;
-    children.swap(tmp.children);
-    return;
-}
-
-nasal_ast& nasal_ast::operator=(const nasal_ast& tmp)
-{
-    line=tmp.line;
-    type=tmp.type;
-    str=tmp.str;
-    num=tmp.num;
-    children=tmp.children;
-    return *this;
-}
-
-nasal_ast& nasal_ast::operator=(nasal_ast&& tmp)
-{
-    line=tmp.line;
-    type=tmp.type;
-    str.swap(tmp.str);
-    num=tmp.num;
-    children.swap(tmp.children);
-    return *this;
-}
-
-void nasal_ast::clear()
-{
-    line=0;
-    str="";
-    num=0;
-    type=ast_null;
-    children.clear();
-    return;
-}
-
-void nasal_ast::print_ast(int depth)
-{
-    for(int i=0;i<depth;++i)
-        std::cout<<"|  ";
-    std::cout<<ast_name[type];
-    if(type==ast_str || type==ast_id || type==ast_default_arg || type==ast_dynamic_id || type==ast_callh)
-        std::cout<<":"<<str;
-    else if(type==ast_num)
-        std::cout<<":"<<num;
-    std::cout<<'\n';
-    for(auto& i:children)
-        i.print_ast(depth+1);
-    return;
-}
-
-#endif

nasal_builtin.h

@@ -1,846 +0,0 @@
-#ifndef __NASAL_BUILTIN_H__
-#define __NASAL_BUILTIN_H__
-/*
-    builtin functions must be called inside a outer function like this:
-    var print=func(elements...)
-    {
-        __builtin_std_cout(elements);
-        return nil;
-    }
-    builtin function __builtin_std_cout is wrapped up by print
-*/
-
-// declaration of builtin functions
-// to add new builtin function,declare it here and write the definition below
-
-nasal_val* builtin_print(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_append(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_setsize(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_system(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_input(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_sleep(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_fin(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_fout(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_split(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_rand(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_id(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_int(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_num(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_pop(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_str(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_size(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_xor(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_and(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_or(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_nand(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_not(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_sin(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_cos(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_tan(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_exp(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_ln(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_sqrt(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_atan2(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_time(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_contains(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_delete(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_keys(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_import(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_die(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_type(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_substr(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_streq(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_left(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_right(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_cmp(std::vector<nasal_val*>&,nasal_gc&);
-nasal_val* builtin_chr(std::vector<nasal_val*>&,nasal_gc&);
-
-void builtin_err(const char* func_name,std::string info)
-{
-    std::cout<<">> [vm] "<<func_name<<": "<<info<<".\n";
-    return;
-}
-
-// register builtin function's name and it's address here in this table below
-// this table must end with {"",nullptr}
-struct FUNC_TABLE
-{
-    const char* name;
-    nasal_val* (*func)(std::vector<nasal_val*>&,nasal_gc&);
-} builtin_func[]=
-{
-    {"__builtin_print",   builtin_print   },
-    {"__builtin_append",  builtin_append  },
-    {"__builtin_setsize", builtin_setsize },
-    {"__builtin_system",  builtin_system  },
-    {"__builtin_input",   builtin_input   },
-    {"__builtin_sleep",   builtin_sleep   },
-    {"__builtin_fin",     builtin_fin     },
-    {"__builtin_fout",    builtin_fout    },
-    {"__builtin_split",   builtin_split   },
-    {"__builtin_rand",    builtin_rand    },
-    {"__builtin_id",      builtin_id      },
-    {"__builtin_int",     builtin_int     },
-    {"__builtin_num",     builtin_num     },
-    {"__builtin_pop",     builtin_pop     },
-    {"__builtin_str",     builtin_str     },
-    {"__builtin_size",    builtin_size    },
-    {"__builtin_xor",     builtin_xor     },
-    {"__builtin_and",     builtin_and     },
-    {"__builtin_or",      builtin_or      },
-    {"__builtin_nand",    builtin_nand    },
-    {"__builtin_not",     builtin_not     },
-    {"__builtin_sin",     builtin_sin     },
-    {"__builtin_cos",     builtin_cos     },
-    {"__builtin_tan",     builtin_tan     },
-    {"__builtin_exp",     builtin_exp     },
-    {"__builtin_ln",      builtin_ln      },
-    {"__builtin_sqrt",    builtin_sqrt    },
-    {"__builtin_atan2",   builtin_atan2   },
-    {"__builtin_time",    builtin_time    },
-    {"__builtin_contains",builtin_contains},
-    {"__builtin_delete",  builtin_delete  },
-    {"__builtin_keys",    builtin_keys    },
-    {"__builtin_import",  builtin_import  },
-    {"__builtin_die",     builtin_die     },
-    {"__builtin_type",    builtin_type    },
-    {"__builtin_substr",  builtin_substr  },
-    {"__builtin_streq",   builtin_streq   },
-    {"__builtin_left",    builtin_left    },
-    {"__builtin_right",   builtin_right   },
-    {"__builtin_cmp",     builtin_cmp     },
-    {"__builtin_chr",     builtin_chr     },
-    {nullptr,             nullptr         }
-};
-
-nasal_val* builtin_print(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    // get arguments
-    // local_scope[0] is reserved for 'me'
-    nasal_val* vec_addr=local_scope[1];
-    // main process
-    for(auto i:vec_addr->ptr.vec->elems)
-        switch(i->type)
-        {
-            case vm_nil:  std::cout<<"nil";            break;
-            case vm_num:  std::cout<<i->ptr.num;       break;
-            case vm_str:  std::cout<<*i->ptr.str;      break;
-            case vm_vec:  i->ptr.vec->print();         break;
-            case vm_hash: i->ptr.hash->print();        break;
-            case vm_func: std::cout<<"func(...){...}"; break;
-        }
-    // generate return value
-    return gc.nil_addr;
-}
-nasal_val* builtin_append(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* vec_addr=local_scope[1];
-    nasal_val* elem_addr=local_scope[2];
-    if(vec_addr->type!=vm_vec)
-    {
-        builtin_err("append","\"vector\" must be vector");
-        return nullptr;
-    }
-    std::vector<nasal_val*>& ref_vec=vec_addr->ptr.vec->elems;
-    for(auto i:elem_addr->ptr.vec->elems)
-        ref_vec.push_back(i);
-    return gc.nil_addr;
-}
-nasal_val* builtin_setsize(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* vec_addr=local_scope[1];
-    nasal_val* size_addr=local_scope[2];
-    if(vec_addr->type!=vm_vec)
-    {
-        builtin_err("setsize","\"vector\" must be vector");
-        return nullptr;
-    }
-    if(size_addr->type!=vm_num)
-    {
-        builtin_err("setsize","\"size\" is not a number");
-        return nullptr;
-    }
-    int num=size_addr->ptr.num;
-    if(num<0)
-    {
-        builtin_err("setsize","\"size\" must be greater than -1");
-        return nullptr;
-    }
-    vec_addr->ptr.vec->elems.resize(num,gc.nil_addr);
-    return gc.nil_addr;
-}
-
-nasal_val* builtin_system(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    nasal_val* str_addr=local_scope[1];
-    if(str_addr->type!=vm_str)
-    {
-        builtin_err("system","\"str\" must be string");
-        return nullptr;
-    }
-    ret_addr->ptr.num=(double)system(str_addr->ptr.str->data());
-    return ret_addr;
-}
-
-nasal_val* builtin_input(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* ret_addr=gc.gc_alloc(vm_str);
-    std::cin>>*ret_addr->ptr.str;
-    return ret_addr;
-}
-
-nasal_val* builtin_sleep(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("sleep","\"duration\" must be number");
-        return nullptr;
-    }
-    // sleep in unistd.h will make this progress sleep sleep_time seconds.
-    sleep((unsigned int)val_addr->ptr.num);
-    return gc.nil_addr;
-}
-
-nasal_val* builtin_fin(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_str)
-    {
-        builtin_err("io.fin","\"filename\" must be string");
-        return nullptr;
-    }
-    std::string&  filename=*val_addr->ptr.str;
-    std::ifstream fin(filename);
-    nasal_val* ret_addr=gc.gc_alloc(vm_str);
-    *ret_addr->ptr.str="";
-    if(!fin.fail())
-        while(!fin.eof())
-        {
-            char c=fin.get();
-            if(fin.eof())
-                break;
-            ret_addr->ptr.str->push_back(c);
-        }
-    else
-        builtin_err("io.fin","cannot open \""+filename+"\"");
-    fin.close();
-    return ret_addr;
-}
-
-nasal_val* builtin_fout(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    nasal_val* str_addr=local_scope[2];
-    if(val_addr->type!=vm_str)
-    {
-        builtin_err("io.fout","\"filename\" must be string");
-        return nullptr;
-    }
-    if(str_addr->type!=vm_str)
-    {
-        builtin_err("io.fout","\"str\" must be string");
-        return nullptr;
-    }
-    std::ofstream fout(*val_addr->ptr.str);
-    if(fout.fail())
-    {
-        builtin_err("io.fout","cannot open \""+*val_addr->ptr.str+"\"");
-        return nullptr;
-    }
-    fout<<*str_addr->ptr.str;
-    fout.close();
-    return gc.nil_addr;
-}
-
-nasal_val* builtin_split(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* delimeter_val_addr=local_scope[1];
-    nasal_val* string_val_addr=local_scope[2];
-    if(delimeter_val_addr->type!=vm_str)
-    {
-        builtin_err("split","\"delimeter\" must be string");
-        return nullptr;
-    }
-    if(string_val_addr->type!=vm_str)
-    {
-        builtin_err("split","\"string\" must be string");
-        return nullptr;
-    }
-    std::string delimeter=*delimeter_val_addr->ptr.str;
-    std::string source=*string_val_addr->ptr.str;
-    int delimeter_len=delimeter.length();
-    int source_len=source.length();
-    nasal_val* ret_addr=gc.builtin_alloc(vm_vec);
-    std::vector<nasal_val*>& ref_vec=ret_addr->ptr.vec->elems;
-    std::string tmp="";
-
-    if(!delimeter_len)
-    {
-        for(int i=0;i<source_len;++i)
-        {
-            nasal_val* str_addr=gc.builtin_alloc(vm_str);
-            *str_addr->ptr.str=source[i];
-            ref_vec.push_back(str_addr);
-        }
-        return ret_addr;
-    }
-    
-    for(int i=0;i<source_len;++i)
-    {
-        bool check_delimeter=false;
-        if(source[i]==delimeter[0])
-            for(int j=0;j<delimeter_len;++j)
-            {
-                if(i+j>=source_len || source[i+j]!=delimeter[j])
-                    break;
-                if(j==delimeter_len-1)
-                    check_delimeter=true;
-            }
-        if(check_delimeter)
-        {
-            if(tmp.length())
-            {
-                nasal_val* str_addr=gc.builtin_alloc(vm_str);
-                *str_addr->ptr.str=tmp;
-                ref_vec.push_back(str_addr);
-                tmp="";
-            }
-            i+=delimeter_len-1;
-        }
-        else
-            tmp+=source[i];
-    }
-    if(tmp.length())
-    {
-        nasal_val* str_addr=gc.builtin_alloc(vm_str);
-        *str_addr->ptr.str=tmp;
-        ref_vec.push_back(str_addr);
-        tmp="";
-    }
-    return ret_addr;
-}
-nasal_val* builtin_rand(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num && val_addr->type!=vm_nil)
-    {
-        builtin_err("rand","\"seed\" must be nil or number");
-        return nullptr;
-    }
-    if(val_addr->type==vm_num)
-    {
-        srand((unsigned int)val_addr->ptr.num);
-        return gc.nil_addr;
-    }
-    double num=0;
-    for(int i=0;i<5;++i)
-        num=(num+rand())*(1.0/(RAND_MAX+1.0));
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=num;
-    return ret_addr;
-}
-nasal_val* builtin_id(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    nasal_val* ret_addr=gc.gc_alloc(vm_str);
-    char buf[32];
-    sprintf(buf,"0x%p",val_addr);
-    *ret_addr->ptr.str=buf;
-    return ret_addr;
-}
-nasal_val* builtin_int(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("int","\"value\" must be number");
-        return nullptr;
-    }
-    int number=(int)val_addr->ptr.num;
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=(double)number;
-    return ret_addr;
-}
-nasal_val* builtin_num(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_str)
-    {
-        builtin_err("num","\"value\" must be string");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=val_addr->to_number();
-    return ret_addr;
-}
-nasal_val* builtin_pop(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_vec)
-    {
-        builtin_err("pop","\"vector\" must be vector");
-        return nullptr;
-    }
-    if(val_addr->ptr.vec->elems.size())
-    {
-        nasal_val* tmp=val_addr->ptr.vec->elems.back();
-        val_addr->ptr.vec->elems.pop_back();
-        return tmp;
-    }
-    return gc.nil_addr;
-}
-nasal_val* builtin_str(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("str","\"number\" must be number");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_str);
-    *ret_addr->ptr.str=val_addr->to_string();
-    return ret_addr;
-}
-nasal_val* builtin_size(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    switch(val_addr->type)
-    {
-        case vm_nil:  ret_addr->ptr.num=0;                               break;
-        case vm_num:  ret_addr->ptr.num=val_addr->ptr.num;               break;
-        case vm_func: ret_addr->ptr.num=0;                               break;
-        case vm_str:  ret_addr->ptr.num=val_addr->ptr.str->length();     break;
-        case vm_vec:  ret_addr->ptr.num=val_addr->ptr.vec->elems.size(); break;
-        case vm_hash: ret_addr->ptr.num=val_addr->ptr.hash->elems.size();break;
-    }
-    return ret_addr;
-}
-nasal_val* builtin_xor(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* a_addr=local_scope[1];
-    nasal_val* b_addr=local_scope[2];
-    if(a_addr->type!=vm_num)
-    {
-        builtin_err("xor","\"a\" must be number");
-        return nullptr;
-    }
-    if(b_addr->type!=vm_num)
-    {
-        builtin_err("xor","\"b\" must be number");
-        return nullptr;
-    }
-    int number_a=(int)a_addr->ptr.num;
-    int number_b=(int)b_addr->ptr.num;
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=(number_a^number_b);
-    return ret_addr;
-}
-nasal_val* builtin_and(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* a_addr=local_scope[1];
-    nasal_val* b_addr=local_scope[2];
-    if(a_addr->type!=vm_num)
-    {
-        builtin_err("and","\"a\" must be number");
-        return nullptr;
-    }
-    if(b_addr->type!=vm_num)
-    {
-        builtin_err("and","\"b\" must be number");
-        return nullptr;
-    }
-    int number_a=(int)a_addr->ptr.num;
-    int number_b=(int)b_addr->ptr.num;
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=(number_a&number_b);
-    return ret_addr;
-}
-nasal_val* builtin_or(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* a_addr=local_scope[1];
-    nasal_val* b_addr=local_scope[2];
-    if(a_addr->type!=vm_num)
-    {
-        builtin_err("or","\"a\" must be number");
-        return nullptr;
-    }
-    if(b_addr->type!=vm_num)
-    {
-        builtin_err("or","\"b\" must be number");
-        return nullptr;
-    }
-    int number_a=(int)a_addr->ptr.num;
-    int number_b=(int)b_addr->ptr.num;
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=(number_a|number_b);
-    return ret_addr;
-}
-nasal_val* builtin_nand(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* a_addr=local_scope[1];
-    nasal_val* b_addr=local_scope[2];
-    if(a_addr->type!=vm_num)
-    {
-        builtin_err("nand","\"a\" must be number");
-        return nullptr;
-    }
-    if(b_addr->type!=vm_num)
-    {
-        builtin_err("nand","\"b\" must be number");
-        return nullptr;
-    }
-    int number_a=(int)a_addr->ptr.num;
-    int number_b=(int)b_addr->ptr.num;
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=(~(number_a&number_b));
-    return ret_addr;
-}
-nasal_val* builtin_not(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* a_addr=local_scope[1];
-    if(a_addr->type!=vm_num)
-    {
-        builtin_err("not","\"a\" must be number");
-        return nullptr;
-    }
-    int number=(int)a_addr->ptr.num;
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=(~number);
-    return ret_addr;
-}
-nasal_val* builtin_sin(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("sin","\"x\" must be number");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=sin(val_addr->ptr.num);
-    return ret_addr;
-}
-nasal_val* builtin_cos(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("cos","\"x\" must be number");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=cos(val_addr->ptr.num);
-    return ret_addr;
-}
-nasal_val* builtin_tan(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("tan","\"x\" must be number");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=tan(val_addr->ptr.num);
-    return ret_addr;
-}
-nasal_val* builtin_exp(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("exp","\"x\" must be number");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=exp(val_addr->ptr.num);
-    return ret_addr;
-}
-nasal_val* builtin_ln(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("ln","\"x\" must be number");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=(log(val_addr->ptr.num)/log(2.7182818284590452354));
-    return ret_addr;
-}
-nasal_val* builtin_sqrt(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("sqrt","\"x\" must be number");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=sqrt(val_addr->ptr.num);
-    return ret_addr;
-}
-nasal_val* builtin_atan2(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* x_val_addr=local_scope[1];
-    nasal_val* y_val_addr=local_scope[2];
-    if(x_val_addr->type!=vm_num)
-    {
-        builtin_err("atan2","\"x\" must be number");
-        return nullptr;
-    }
-    if(y_val_addr->type!=vm_num)
-    {
-        builtin_err("atan2","\"y\" must be number");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=atan2(y_val_addr->ptr.num,x_val_addr->ptr.num);
-    return ret_addr;
-}
-nasal_val* builtin_time(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    if(val_addr->type!=vm_num)
-    {
-        builtin_err("time","\"begin_time\" must be number");
-        return nullptr;
-    }
-    time_t begin_time=(time_t)val_addr->ptr.num;
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=time(&begin_time);
-    return ret_addr;
-}
-nasal_val* builtin_contains(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* hash_addr=local_scope[1];
-    nasal_val* key_addr=local_scope[2];
-    if(hash_addr->type!=vm_hash)
-    {
-        builtin_err("contains","\"hash\" must be hash");
-        return nullptr;
-    }
-    if(key_addr->type!=vm_str)
-    {
-        builtin_err("contains","\"key\" must be string");
-        return nullptr;
-    }
-    return hash_addr->ptr.hash->elems.count(*key_addr->ptr.str)?gc.one_addr:gc.zero_addr;
-}
-nasal_val* builtin_delete(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* hash_addr=local_scope[1];
-    nasal_val* key_addr=local_scope[2];
-    if(hash_addr->type!=vm_hash)
-    {
-        builtin_err("delete","\"hash\" must be hash");
-        return nullptr;
-    }
-    if(key_addr->type!=vm_str)
-    {
-        builtin_err("delete","\"key\" must be string");
-        return nullptr;
-    }
-    if(hash_addr->ptr.hash->elems.count(*key_addr->ptr.str))
-        hash_addr->ptr.hash->elems.erase(*key_addr->ptr.str);
-    return gc.nil_addr;
-}
-nasal_val* builtin_keys(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* hash_addr=local_scope[1];
-    if(hash_addr->type!=vm_hash)
-    {
-        builtin_err("keys","\"hash\" must be hash");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.builtin_alloc(vm_vec);
-    std::vector<nasal_val*>& ref_vec=ret_addr->ptr.vec->elems;
-    for(auto iter:hash_addr->ptr.hash->elems)
-    {
-        nasal_val* str_addr=gc.builtin_alloc(vm_str);
-        *str_addr->ptr.str=iter.first;
-        ref_vec.push_back(str_addr);
-    }
-    return ret_addr;
-}
-nasal_val* builtin_import(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    // this function is used in preprocessing.
-    // this function will return nothing when running.
-    builtin_err("import","must use this function in global scope");
-    return nullptr;
-}
-nasal_val* builtin_die(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* str_addr=local_scope[1];
-    if(str_addr->type!=vm_str)
-    {
-        builtin_err("die","\"str\" must be string");
-        return nullptr;
-    }
-    std::cout<<">> [vm] error: "<<*str_addr->ptr.str<<'\n';
-    return nullptr;
-}
-nasal_val* builtin_type(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* val_addr=local_scope[1];
-    nasal_val* ret_addr=gc.gc_alloc(vm_str);
-    switch(val_addr->type)
-    {
-        case vm_nil:  *ret_addr->ptr.str="nil";      break;
-        case vm_num:  *ret_addr->ptr.str="number";   break;
-        case vm_str:  *ret_addr->ptr.str="string";   break;
-        case vm_vec:  *ret_addr->ptr.str="vector";   break;
-        case vm_hash: *ret_addr->ptr.str="hash";     break;
-        case vm_func: *ret_addr->ptr.str="function"; break;
-    }
-    return ret_addr;
-}
-nasal_val* builtin_substr(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* str_addr=local_scope[1];
-    nasal_val* beg_addr=local_scope[2];
-    nasal_val* len_addr=local_scope[3];
-    if(str_addr->type!=vm_str)
-    {
-        builtin_err("substr","\"str\" must be string");
-        return nullptr;
-    }
-    if(beg_addr->type!=vm_num)
-    {
-        builtin_err("substr","\"begin\" must be number");
-        return nullptr;
-    }
-    if(len_addr->type!=vm_num)
-    {
-        builtin_err("substr","\"length\" must be number");
-        return nullptr;
-    }
-    std::string& str=*str_addr->ptr.str;
-    int beg=(int)beg_addr->ptr.num;
-    int len=(int)len_addr->ptr.num;
-    if(beg>=str.length() || beg+len>=str.length())
-    {
-        builtin_err("susbtr","index out of range");
-        return nullptr;
-    }
-    if(len<0)
-        len=0;
-    nasal_val* ret_addr=gc.gc_alloc(vm_str);
-    *ret_addr->ptr.str=str.substr(beg,len);
-    return ret_addr;
-}
-nasal_val* builtin_streq(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* a_addr=local_scope[1];
-    nasal_val* b_addr=local_scope[2];
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=(a_addr->type!=vm_str || b_addr->type!=vm_str)?0:(*a_addr->ptr.str==*b_addr->ptr.str);
-    return ret_addr;
-}
-nasal_val* builtin_left(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* str_addr=local_scope[1];
-    nasal_val* len_addr=local_scope[2];
-    if(str_addr->type!=vm_str)
-    {
-        builtin_err("left","\"string\" must be string");
-        return nullptr;
-    }
-    if(len_addr->type!=vm_num)
-    {
-        builtin_err("left","\"length\" must be number");
-        return nullptr;
-    }
-    std::string& str=*str_addr->ptr.str;
-    int len=(int)len_addr->ptr.num;
-    if(len<0)
-        len=0;
-    nasal_val* ret_addr=gc.gc_alloc(vm_str);
-    *ret_addr->ptr.str=str.substr(0, len);
-    return ret_addr;
-}
-nasal_val* builtin_right(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* str_addr=local_scope[1];
-    nasal_val* len_addr=local_scope[2];
-    if(str_addr->type!=vm_str)
-    {
-        builtin_err("right","\"string\" must be string");
-        return nullptr;
-    }
-    if(len_addr->type!=vm_num)
-    {
-        builtin_err("right","\"length\" must be number");
-        return nullptr;
-    } 
-    std::string& str=*str_addr->ptr.str;
-    int len=(int)len_addr->ptr.num;
-    int srclen=str.length();
-    if(len>srclen)
-        len=srclen;
-    if(len<0)
-        len=0;
-    nasal_val* ret_addr=gc.gc_alloc(vm_str);
-    *ret_addr->ptr.str=str.substr(srclen-len, srclen);
-    return ret_addr;
-}
-nasal_val* builtin_cmp(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    nasal_val* a_addr=local_scope[1];
-    nasal_val* b_addr=local_scope[2];
-    if(a_addr->type!=vm_str)
-    {
-        builtin_err("cmp","\"a\" must be string");
-        return nullptr;
-    }
-    if(b_addr->type!=vm_str)
-    {
-        builtin_err("cmp","\"b\" must be string");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_num);
-    ret_addr->ptr.num=strcmp(a_addr->ptr.str->data(),b_addr->ptr.str->data());
-    return ret_addr;
-}
-nasal_val* builtin_chr(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
-{
-    const char* extend[]={
-        "€"," ","‚","ƒ","„","…","†","‡",
-        "ˆ","‰","Š","‹","Œ"," ","Ž"," ",
-        " ","‘","’","“","”","•","–","—",
-        "˜","™","š","›","œ"," ","ž","Ÿ",
-        " ","¡","¢","£","¤","¥","¦","§",
-        "¨","©","ª","«","¬"," ","®","¯",
-        "°","±","²","³","´","µ","¶","·",
-        "¸","¹","º","»","¼","½","¾","¿",
-        "À","Á","Â","Ã","Ä","Å","Æ","Ç",
-        "È","É","Ê","Ë","Ì","Í","Î","Ï",
-        "Ð","Ñ","Ò","Ó","Ô","Õ","Ö","×",
-        "Ø","Ù","Ú","Û","Ü","Ý","Þ","ß",
-        "à","á","â","ã","ä","å","æ","ç",
-        "è","é","ê","ë","ì","í","î","ï",
-        "ð","ñ","ò","ó","ô","õ","ö","÷",
-        "ø","ù","ú","û","ü","ý","þ","ÿ"
-    };
-    nasal_val* code_addr=local_scope[1];
-    if(code_addr->type!=vm_num)
-    {
-        builtin_err("chr","\"code\" must be number");
-        return nullptr;
-    }
-    nasal_val* ret_addr=gc.gc_alloc(vm_str);
-    int num=code_addr->ptr.num;
-    if(0<=num && num<128)
-        *ret_addr->ptr.str=(char)num;
-    else if(128<=num && num<256)
-        *ret_addr->ptr.str=extend[num-128];
-    else
-        *ret_addr->ptr.str=" ";
-    return ret_addr;
-}
-
-#endif

nasal_gc.h

@@ -1,412 +0,0 @@
-#ifndef __NASAL_GC_H__
-#define __NASAL_GC_H__
-
-enum nasal_type
-{
-    vm_nil=0,
-    vm_num,
-    vm_str,
-    vm_func,
-    vm_vec,
-    vm_hash,
-    vm_type_size
-};
-
-// change parameters here to make your own efficient gc
-// better set bigger number on vm_num and vm_vec
-const int increment[vm_type_size]=
-{
-    0,    // vm_nil,in fact it is not in use
-    65536,// vm_num
-    256,  // vm_str
-    16,   // vm_func
-    2048, // vm_vec
-    8     // vm_hash
-};
-
-struct nasal_val;//declaration of nasal_val
-
-struct nasal_vec// 24 bytes
-{
-    std::vector<nasal_val*> elems;
-
-    void        print();
-    nasal_val*  get_val(int);
-    nasal_val** get_mem(int);
-};
-
-struct nasal_hash// 56 bytes
-{
-    std::unordered_map<std::string,nasal_val*> elems;
-
-    void        print();
-    nasal_val*  get_val(std::string&);
-    nasal_val** get_mem(std::string&);
-};
-
-struct nasal_func// 120 bytes
-{
-    int32_t  dynpara;// dynamic parameter name index in hash
-    uint32_t offset; // arguments will be loaded into local scope from this offset 
-    uint32_t entry;  // pc will set to entry-1 to call this function
-    std::vector<nasal_val*> default_para;// default value(nasal_val*)
-    std::unordered_map<std::string,int> key_table;// parameter name hash
-    std::vector<nasal_val*> closure;// closure will be loaded to gc.local.back() as the local scope
-
-    nasal_func();
-    void clear();
-};
-
-struct nasal_val// 16 bytes
-{
-#define GC_UNCOLLECTED 0   
-#define GC_COLLECTED   1
-#define GC_FOUND       2
-    uint8_t mark;
-    uint16_t type;
-    union 
-    {
-        double       num;
-        std::string* str;
-        nasal_vec*   vec;
-        nasal_hash*  hash;
-        nasal_func*  func;
-    }ptr;
-
-    nasal_val(int);
-    ~nasal_val();
-    double to_number();
-    std::string to_string();
-};
-
-/*functions of nasal_vec*/
-nasal_val* nasal_vec::get_val(int index)
-{
-    int vec_size=elems.size();
-    if(index<-vec_size || index>=vec_size)
-        return nullptr;
-    return elems[index>=0?index:index+vec_size];
-}
-nasal_val** nasal_vec::get_mem(int index)
-{
-    int vec_size=elems.size();
-    if(index<-vec_size || index>=vec_size)
-        return nullptr;
-    return &elems[index>=0?index:index+vec_size];
-}
-void nasal_vec::print()
-{
-    std::cout<<'[';  
-    for(auto i:elems)
-    {
-        switch(i->type)
-        {
-            case vm_nil:  std::cout<<"nil";            break;
-            case vm_num:  std::cout<<i->ptr.num;       break;
-            case vm_str:  std::cout<<*i->ptr.str;      break;
-            case vm_vec:  i->ptr.vec->print();         break;
-            case vm_hash: i->ptr.hash->print();        break;
-            case vm_func: std::cout<<"func(...){...}"; break;
-        }
-        std::cout<<',';
-    }
-    std::cout<<']';
-    return;
-}
-
-/*functions of nasal_hash*/
-nasal_val* nasal_hash::get_val(std::string& key)
-{
-    nasal_val* ret_addr=nullptr;
-    if(elems.count(key))
-        return elems[key];
-    else if(elems.count("parents"))
-    {
-        nasal_val* val_addr=elems["parents"];
-        if(val_addr->type==vm_vec)
-            for(auto i:val_addr->ptr.vec->elems)
-            {
-                if(i->type==vm_hash)
-                    ret_addr=i->ptr.hash->get_val(key);
-                if(ret_addr)
-                    return ret_addr;
-            }
-    }
-    return nullptr;
-}
-nasal_val** nasal_hash::get_mem(std::string& key)
-{
-    nasal_val** mem_addr=nullptr;
-    if(elems.count(key))
-        return &elems[key];
-    else if(elems.count("parents"))
-    {
-        nasal_val* val_addr=elems["parents"];
-        if(val_addr->type==vm_vec)
-            for(auto i:val_addr->ptr.vec->elems)
-            {
-                if(i->type==vm_hash)
-                    mem_addr=i->ptr.hash->get_mem(key);
-                if(mem_addr)
-                    return mem_addr;
-            }
-    }
-    return nullptr;
-}
-void nasal_hash::print()
-{
-    std::cout<<'{';
-    for(auto& i:elems)
-    {
-        std::cout<<i.first<<':';
-        nasal_val* tmp=i.second;
-        switch(tmp->type)
-        {
-            case vm_nil:  std::cout<<"nil";            break;
-            case vm_num:  std::cout<<tmp->ptr.num;     break;
-            case vm_str:  std::cout<<*tmp->ptr.str;    break;
-            case vm_vec:  tmp->ptr.vec->print();       break;
-            case vm_hash: tmp->ptr.hash->print();      break;
-            case vm_func: std::cout<<"func(...){...}"; break;
-        }
-        std::cout<<',';
-    }
-    std::cout<<'}';
-    return;
-}
-
-/*functions of nasal_func*/
-nasal_func::nasal_func()
-{
-    dynpara=-1;
-    return;
-}
-void nasal_func::clear()
-{
-    dynpara=-1;
-    default_para.clear();
-    key_table.clear();
-    closure.clear();
-    return;
-}
-
-/*functions of nasal_val*/
-nasal_val::nasal_val(int val_type)
-{
-    mark=GC_COLLECTED;
-    type=val_type;
-    switch(type)
-    {
-        case vm_num:  ptr.num=0;               break;
-        case vm_str:  ptr.str=new std::string; break;
-        case vm_vec:  ptr.vec=new nasal_vec;   break;
-        case vm_hash: ptr.hash=new nasal_hash; break;
-        case vm_func: ptr.func=new nasal_func; break;
-    }
-    return;
-}
-nasal_val::~nasal_val()
-{
-    switch(type)
-    {
-        case vm_str:  delete ptr.str;  break;
-        case vm_vec:  delete ptr.vec;  break;
-        case vm_hash: delete ptr.hash; break;
-        case vm_func: delete ptr.func; break;
-    }
-    type=vm_nil;
-    return;
-}
-double nasal_val::to_number()
-{
-    if(type==vm_str)
-        return str2num(ptr.str->c_str());
-    return ptr.num;
-}
-std::string nasal_val::to_string()
-{
-    if(type==vm_str)
-        return *ptr.str;
-    else if(type==vm_num)
-        return num2str(ptr.num);
-    return "";
-}
-
-struct nasal_gc
-{
-#define STACK_MAX_DEPTH (65536)
-    nasal_val*              zero_addr;               // reserved address of nasal_val,type vm_num, 0
-    nasal_val*              one_addr;                // reserved address of nasal_val,type vm_num, 1
-    nasal_val*              nil_addr;                // reserved address of nasal_val,type vm_nil
-    nasal_val*              val_stack[STACK_MAX_DEPTH+16];// 16 reserved to avoid stack overflow
-    nasal_val**             stack_top;               // stack top
-    std::vector<nasal_val*> num_addrs;               // reserved address for const vm_num
-    std::vector<nasal_val*> str_addrs;               // reserved address for const vm_str
-    std::vector<nasal_val*> slice_stack;             // slice stack for vec[val,val,val:val]
-    std::vector<nasal_val*> memory;                  // gc memory
-    std::queue <nasal_val*> free_list[vm_type_size]; // gc free list
-    std::vector<nasal_val*> global;
-    std::list<std::vector<nasal_val*>> local;
-    void                    mark();
-    void                    sweep();
-    void                    gc_init(std::vector<double>&,std::vector<std::string>&);
-    void                    gc_clear();
-    nasal_val*              gc_alloc(int);
-    nasal_val*              builtin_alloc(int);
-};
-
-/* gc functions */
-void nasal_gc::mark()
-{
-    std::queue<nasal_val*> bfs;
-    for(auto i:global)
-        bfs.push(i);
-    for(auto& i:local)
-        for(auto j:i)
-            bfs.push(j);
-    for(auto i:slice_stack)
-        bfs.push(i);
-    for(nasal_val** i=val_stack;i<=stack_top;++i)
-        bfs.push(*i);
-    while(!bfs.empty())
-    {
-        nasal_val* tmp=bfs.front();
-        bfs.pop();
-        if(tmp->mark) continue;
-        tmp->mark=GC_FOUND;
-        if(tmp->type==vm_vec)
-            for(auto i:tmp->ptr.vec->elems)
-                bfs.push(i);
-        else if(tmp->type==vm_hash)
-            for(auto& i:tmp->ptr.hash->elems)
-                bfs.push(i.second);
-        else if(tmp->type==vm_func)
-        {
-            for(auto i:tmp->ptr.func->closure)
-                bfs.push(i);
-            for(auto i:tmp->ptr.func->default_para)
-                if(i)
-                    bfs.push(i);
-        }
-    }
-    return;
-}
-void nasal_gc::sweep()
-{
-    for(auto i:memory)
-    {
-        if(i->mark==GC_UNCOLLECTED)
-        {
-            switch(i->type)
-            {
-                case vm_str: i->ptr.str->clear();       break;
-                case vm_vec: i->ptr.vec->elems.clear(); break;
-                case vm_hash:i->ptr.hash->elems.clear();break;
-                case vm_func:i->ptr.func->clear();      break;
-            }
-            free_list[i->type].push(i);
-            i->mark=GC_COLLECTED;
-        }
-        else if(i->mark==GC_FOUND)
-            i->mark=GC_UNCOLLECTED;
-    }
-    return;
-}
-void nasal_gc::gc_init(std::vector<double>& nums,std::vector<std::string>& strs)
-{
-    for(int i=vm_num;i<vm_type_size;++i)
-        for(int j=0;j<increment[i];++j)
-        {
-            nasal_val* tmp=new nasal_val(i);
-            memory.push_back(tmp);
-            free_list[i].push(tmp);
-        }
-
-    stack_top=val_stack; // set stack_top to val_stack
-
-    zero_addr=new nasal_val(vm_num); // init constant 0
-    zero_addr->ptr.num=0;
-
-    one_addr=new nasal_val(vm_num); // init constant 1
-    one_addr->ptr.num=1;
-
-    nil_addr=new nasal_val(vm_nil); // init nil
-
-    *val_stack=nil_addr; // the first space will not store any values,but gc checks
-    // init constant numbers
-    num_addrs.resize(nums.size());
-    for(int i=0;i<nums.size();++i)
-    {
-        num_addrs[i]=new nasal_val(vm_num);
-        num_addrs[i]->ptr.num=nums[i];
-    }
-    // init constant strings
-    str_addrs.resize(strs.size());
-    for(int i=0;i<strs.size();++i)
-    {
-        str_addrs[i]=new nasal_val(vm_str);
-        *str_addrs[i]->ptr.str=strs[i];
-    }
-    return;
-}
-void nasal_gc::gc_clear()
-{
-    for(auto i:memory)
-        delete i;
-    memory.clear();
-    for(int i=0;i<vm_type_size;++i)
-        while(!free_list[i].empty())
-            free_list[i].pop();
-    global.clear();
-    local.clear();
-    slice_stack.clear();
-
-    delete nil_addr;
-    delete one_addr;
-    delete zero_addr;
-    for(auto i:num_addrs)
-        delete i;
-    num_addrs.clear();
-    for(auto i:str_addrs)
-        delete i;
-    str_addrs.clear();
-    return;
-}
-nasal_val* nasal_gc::gc_alloc(int type)
-{
-    if(free_list[type].empty())
-    {
-        mark();
-        sweep();
-    }
-    if(free_list[type].empty())
-        for(int i=0;i<increment[type];++i)
-        {
-            nasal_val* tmp=new nasal_val(type);
-            memory.push_back(tmp);
-            free_list[type].push(tmp);
-        }
-    nasal_val* ret=free_list[type].front();
-    ret->mark=GC_UNCOLLECTED;
-    free_list[type].pop();
-    return ret;
-}
-nasal_val* nasal_gc::builtin_alloc(int type)
-{
-    // when running a builtin function,alloc will run more than one time
-    // this may cause mark-sweep in gc_alloc
-    // and the value got before will be collected,this is a fatal error
-    // so use builtin_alloc in builtin functions if this function uses alloc more then one time
-    if(free_list[type].empty())
-        for(int i=0;i<increment[type];++i)
-        {
-            nasal_val* tmp=new nasal_val(type);
-            memory.push_back(tmp);
-            free_list[type].push(tmp);
-        }
-    nasal_val* ret=free_list[type].front();
-    ret->mark=GC_UNCOLLECTED;
-    free_list[type].pop();
-    return ret;
-}
-#endif

nasal_import.h

@@ -1,129 +0,0 @@
-#ifndef __NASAL_IMPORT_H__
-#define __NASAL_IMPORT_H__
-
-class nasal_import
-{
-private:
-    int error;
-    nasal_lexer import_lex;
-    nasal_parse import_par;
-    nasal_ast   import_ast;
-    std::vector<std::string> filename_table;
-    void die(std::string&,const char*);
-    bool check_import(nasal_ast&);
-    bool check_exist(std::string&);
-    void linker(nasal_ast&,nasal_ast&&);
-    nasal_ast file_import(nasal_ast&);
-    nasal_ast load(nasal_ast&);
-public:
-    int  get_error(){return error;}
-    void link(nasal_ast&);
-    nasal_ast& get_root(){return import_ast;}
-};
-
-void nasal_import::die(std::string& filename,const char* error_stage)
-{
-    ++error;
-    std::cout<<">> [import] in <\""<<filename<<"\">: error(s) occurred in "<<error_stage<<".\n";
-    return;
-}
-
-bool nasal_import::check_import(nasal_ast& node)
-{
-/*
-only this kind of node can be recognized as 'import':
-    call
-        id:import
-        call_func
-            string:'filename'
-*/
-    if(node.get_type()!=ast_call)
-        return false;
-    std::vector<nasal_ast>& ref_vec=node.get_children();
-    if(ref_vec.size()!=2)
-        return false;
-    if(ref_vec[0].get_str()!="import")
-        return false;
-    if(ref_vec[1].get_type()!=ast_callf)
-        return false;
-    if(ref_vec[1].get_children().size()!=1 || ref_vec[1].get_children()[0].get_type()!=ast_str)
-        return false;
-    return true;
-}
-
-bool nasal_import::check_exist(std::string& file)
-{
-    // avoid importing the same file
-    for(auto& fname:filename_table)
-        if(file==fname)
-            return true;
-    filename_table.push_back(file);
-    return false;
-}
-
-void nasal_import::linker(nasal_ast& root,nasal_ast&& add_root)
-{
-    // add children of add_root to the back of root
-    for(auto& i:add_root.get_children())
-        root.add_child(std::move(i));
-    return;
-}
-
-nasal_ast nasal_import::file_import(nasal_ast& node)
-{
-    // initializing
-    nasal_ast tmp(0,ast_root);
-
-    // get filename and set node to ast_null
-    std::string filename=node.get_children()[1].get_children()[0].get_str();
-    node.clear();
-
-    // avoid infinite loading loop
-    if(check_exist(filename))
-        return tmp;
-    
-    // start importing...
-    import_lex.openfile(filename);
-    import_lex.scanner();
-    if(import_lex.get_error())
-    {
-        die(filename,"lexer");
-        return tmp;
-    }
-    import_par.set_toklist(import_lex.get_token_list());
-    import_lex.get_token_list().clear();
-    import_par.main_process();
-    if(import_par.get_error())
-    {
-        die(filename,"parser");
-        return tmp;
-    }
-    tmp=std::move(import_par.get_root());
-    import_par.get_root().clear();
-    // check if tmp has 'import'
-    return load(tmp);
-}
-
-nasal_ast nasal_import::load(nasal_ast& root)
-{
-    nasal_ast new_root(0,ast_root);
-    for(auto& i:root.get_children())
-        if(check_import(i))
-            linker(new_root,file_import(i));
-    // add root to the back of new_root
-    linker(new_root,std::move(root));
-    return new_root;
-}
-
-void nasal_import::link(nasal_ast& root)
-{
-    // initializing
-    error=0;
-    filename_table.clear();
-    import_ast.clear();
-    // scan root and import files,then generate a new ast and return to import_ast
-    import_ast=load(root);
-    return;
-}
-
-#endif

nasal_lexer.h

@@ -1,371 +0,0 @@
-#ifndef __NASAL_LEXER_H__
-#define __NASAL_LEXER_H__
-
-#define IS_IDENTIFIER(c)      ((c=='_')||('a'<=c && c<='z')||('A'<=c&&c<='Z'))
-#define IS_HEX_NUMBER(c)      (('0'<=c&&c<='9')||('a'<=c&&c<='f')||('A'<=c && c<='F'))
-#define IS_OCT_NUMEBR(c)      ('0'<=c&&c<='7')
-#define IS_DIGIT(c)           ('0'<=c&&c<='9')
-#define IS_STRING(c)          (c=='\''||c=='\"'||c=='`')
-// single operators have only one character
-#define IS_SINGLE_OPERATOR(c) (c=='('||c==')'||c=='['||c==']'||c=='{'||c=='}'||c==','||c==';'||c=='|'||c==':'||\
-							   c=='?'||c=='`'||c=='&'||c=='@'||c=='%'||c=='$'||c=='^'||c=='\\')
-// calculation operators may have two chars, for example: += -= *= /= ~= != == >= <=
-#define IS_CALC_OPERATOR(c)   (c=='='||c=='+'||c=='-'||c=='*'||c=='!'||c=='/'||c=='<'||c=='>'||c=='~')
-#define IS_NOTE(c)            (c=='#')
-
-enum token_type
-{
-    tok_null=0,
-    tok_num,tok_str,tok_id,
-    tok_for,tok_forindex,tok_foreach,tok_while,
-    tok_var,tok_func,tok_break,tok_continue,
-    tok_ret,tok_if,tok_elsif,tok_else,tok_nil,
-    tok_lcurve,tok_rcurve,
-    tok_lbracket,tok_rbracket,
-    tok_lbrace,tok_rbrace,
-    tok_semi,tok_and,tok_or,tok_comma,tok_dot,tok_ellipsis,tok_quesmark,
-    tok_colon,tok_add,tok_sub,tok_mult,tok_div,tok_link,tok_not,
-    tok_eq,
-    tok_addeq,tok_subeq,tok_multeq,tok_diveq,tok_lnkeq,
-    tok_cmpeq,tok_neq,tok_less,tok_leq,tok_grt,tok_geq,
-	tok_eof
-};
-
-struct
-{
-    const char* str;
-    int tok_type;
-}token_table[]=
-{
-    {"for"     ,tok_for      },
-    {"forindex",tok_forindex },
-    {"foreach" ,tok_foreach  },
-    {"while"   ,tok_while    },
-    {"var"     ,tok_var      },
-    {"func"    ,tok_func     },
-    {"break"   ,tok_break    },
-    {"continue",tok_continue },
-    {"return"  ,tok_ret      },
-    {"if"      ,tok_if       },
-    {"elsif"   ,tok_elsif    },
-    {"else"    ,tok_else     },
-    {"nil"     ,tok_nil      },
-    {"("       ,tok_lcurve   },
-    {")"       ,tok_rcurve   },
-    {"["       ,tok_lbracket },
-    {"]"       ,tok_rbracket },
-    {"{"       ,tok_lbrace   },
-    {"}"       ,tok_rbrace   },
-    {";"       ,tok_semi     },
-    {"and"     ,tok_and      },
-    {"or"      ,tok_or       },
-    {","       ,tok_comma    },
-    {"."       ,tok_dot      },
-    {"..."     ,tok_ellipsis },
-    {"?"       ,tok_quesmark },
-    {":"       ,tok_colon    },
-    {"+"       ,tok_add      },
-    {"-"       ,tok_sub      },
-    {"*"       ,tok_mult     },
-    {"/"       ,tok_div      },
-    {"~"       ,tok_link     },
-    {"!"       ,tok_not      },
-	{"="       ,tok_eq       },
-    {"+="      ,tok_addeq    },
-    {"-="      ,tok_subeq    },
-    {"*="      ,tok_multeq   },
-    {"/="      ,tok_diveq    },
-    {"~="      ,tok_lnkeq    },
-    {"=="      ,tok_cmpeq    },
-    {"!="      ,tok_neq      },
-    {"<"       ,tok_less     },
-	{"<="      ,tok_leq      },
-    {">"       ,tok_grt      },
-    {">="      ,tok_geq      },
-	{nullptr   ,-1           }
-};
-
-struct token
-{
-    int line;
-    int type;
-    std::string str;
-	token(int l=0,int t=tok_null,std::string s=""){line=l;type=t;str=s;return;}
-};
-
-class nasal_lexer
-{
-private:
-    int error;
-	int res_size;
-	int line;
-	int ptr;
-	std::string line_code;
-	std::vector<char> res;
-    std::vector<token> token_list;
-	int  get_tok_type(std::string&);
-	void die(const char*);
-	std::string id_gen();
-    std::string num_gen();
-    std::string str_gen();
-public:
-	void openfile(std::string&);
-    void scanner();
-    void print_token();
-    int  get_error(){return error;}
-	std::vector<token>& get_token_list(){return token_list;}
-};
-
-void nasal_lexer::openfile(std::string& filename)
-{
-	error=0;
-	res.clear();
-    std::ifstream fin(filename,std::ios::binary);
-    if(fin.fail())
-    {
-		++error;
-        std::cout<<">> [lexer] cannot open file \""<<filename<<"\".\n";
-		fin.close();
-        return;
-    }
-    while(!fin.eof())
-    {
-        char c=fin.get();
-        if(fin.eof())
-            break;
-        res.push_back(c);
-    }
-    fin.close();
-    return;
-}
-
-int nasal_lexer::get_tok_type(std::string& tk_str)
-{
-	for(int i=0;token_table[i].str;++i)
-		if(tk_str==token_table[i].str)
-			return token_table[i].tok_type;
-	return tok_null;
-}
-
-void nasal_lexer::die(const char* error_info)
-{
-	++error;
-	std::cout<<">> [lexer] line "<<line<<" column "<<line_code.length()<<": \n"<<line_code<<"\n";
-	for(auto i:line_code)
-		std::cout<<(i=='\t'?'\t':' ');
-	std::cout<<"^"<<error_info<<'\n';
-	return;
-}
-
-std::string nasal_lexer::id_gen()
-{
-	std::string token_str="";
-	while(ptr<res_size && (IS_IDENTIFIER(res[ptr])||IS_DIGIT(res[ptr])))
-		token_str+=res[ptr++];
-	line_code+=token_str;
-	return token_str;
-	// after running this process, ptr will point to the next token's beginning character
-}
-
-std::string nasal_lexer::num_gen()
-{
-	// generate hex number
-	if(ptr+1<res_size && res[ptr]=='0' && res[ptr+1]=='x')
-	{
-		std::string token_str="0x";
-		ptr+=2;
-		while(ptr<res_size && IS_HEX_NUMBER(res[ptr]))
-			token_str+=res[ptr++];
-		line_code+=token_str;
-		if(token_str=="0x")
-			die("incorrect number.");
-		return token_str;
-	}
-	// generate oct number
-	else if(ptr+1<res_size && res[ptr]=='0' && res[ptr+1]=='o')
-	{
-		std::string token_str="0o";
-		ptr+=2;
-		while(ptr<res_size && IS_OCT_NUMEBR(res[ptr]))
-			token_str+=res[ptr++];
-		line_code+=token_str;
-		if(token_str=="0o")
-			die("incorrect number.");
-		return token_str;
-	}
-	// generate dec number
-	// dec number -> [0~9][0~9]*(.[0~9]*)(e|E(+|-)0|[1~9][0~9]*)
-	std::string token_str="";
-	while(ptr<res_size && IS_DIGIT(res[ptr]))
-		token_str+=res[ptr++];
-	if(ptr<res_size && res[ptr]=='.')
-	{
-		token_str+=res[ptr++];
-		while(ptr<res_size && IS_DIGIT(res[ptr]))
-			token_str+=res[ptr++];
-		// "xxxx." is not a correct number
-		if(token_str.back()=='.')
-		{
-			line_code+=token_str;
-			die("incorrect number.");
-			return "0";
-		}
-	}
-	if(ptr<res_size && (res[ptr]=='e' || res[ptr]=='E'))
-	{
-		token_str+=res[ptr++];
-		if(ptr<res_size && (res[ptr]=='-' || res[ptr]=='+'))
-			token_str+=res[ptr++];
-		while(ptr<res_size && IS_DIGIT(res[ptr]))
-			token_str+=res[ptr++];
-		// "xxxe(-|+)" is not a correct number
-		if(token_str.back()=='e' || token_str.back()=='E' || token_str.back()=='-' || token_str.back()=='+')
-		{
-			line_code+=token_str;
-			die("incorrect number.");
-			return "0";
-		}
-	}
-	line_code+=token_str;
-	return token_str;
-}
-
-std::string nasal_lexer::str_gen()
-{
-	std::string token_str="";
-	char str_begin=res[ptr];
-	line_code+=str_begin;
-	while(++ptr<res_size && res[ptr]!=str_begin)
-	{
-		line_code+=res[ptr];
-		if(res[ptr]=='\n')
-		{
-			line_code="";
-			++line;
-		}
-		if(res[ptr]=='\\' && ptr+1<res_size)
-		{
-			line_code+=res[++ptr];
-			switch(res[ptr])
-			{
-				case 'a': token_str.push_back('\a');break;
-				case 'b': token_str.push_back('\b');break;
-				case 'f': token_str.push_back('\f');break;
-				case 'n': token_str.push_back('\n');break;
-				case 'r': token_str.push_back('\r');break;
-				case 't': token_str.push_back('\t');break;
-				case 'v': token_str.push_back('\v');break;
-				case '?': token_str.push_back('\?');break;
-				case '0': token_str.push_back('\0');break;
-				case '\\':token_str.push_back('\\');break;
-				case '\'':token_str.push_back('\'');break;
-				case '\"':token_str.push_back('\"');break;
-				default:  token_str.push_back(res[ptr]);break;
-			}
-			continue;
-		}
-		token_str+=res[ptr];
-	}
-	// check if this string ends with a " or '
-	if(ptr++>=res_size)
-		die("get EOF when generating string.");
-	if(str_begin=='`' && token_str.length()!=1)
-		die("\'`\' is used for string that includes one character.");
-	return token_str;
-}
-
-void nasal_lexer::scanner()
-{
-    token_list.clear();
-    line=1;
-	ptr=0;
-	line_code="";
-	res_size=res.size();
-
-	std::string token_str;
-	while(ptr<res_size)
-	{
-		while(ptr<res_size && (res[ptr]==' ' || res[ptr]=='\n' || res[ptr]=='\t' || res[ptr]=='\r' || res[ptr]<0))
-		{
-			// these characters will be ignored, and '\n' will cause ++line
-			line_code+=res[ptr];
-			if(res[ptr++]=='\n')
-			{
-				++line;
-				line_code="";
-			}
-		}
-		if(ptr>=res_size) break;
-		if(IS_IDENTIFIER(res[ptr]))
-		{
-			token_str=id_gen();
-			token new_token(line,get_tok_type(token_str),token_str);
-            if(!new_token.type)
-                new_token.type=tok_id;
-			token_list.push_back(new_token);
-		}
-		else if(IS_DIGIT(res[ptr]))
-		{
-			token_str=num_gen();
-			token_list.push_back({line,tok_num,token_str});
-		}
-		else if(IS_STRING(res[ptr]))
-		{
-			token_str=str_gen();
-			token_list.push_back({line,tok_str,token_str});
-		}
-		else if(IS_SINGLE_OPERATOR(res[ptr]))
-		{
-			token_str=res[ptr];
-			line_code+=res[ptr];
-			int type=get_tok_type(token_str);
-			if(!type)
-				die("incorrect operator.");
-			token_list.push_back({line,type,token_str});
-			++ptr;
-		}
-        else if(res[ptr]=='.')
-        {
-            if(ptr+2<res_size && res[ptr+1]=='.' && res[ptr+2]=='.')
-            {
-                token_str="...";
-                ptr+=3;
-            }
-            else
-            {
-                token_str=".";
-                ++ptr;
-            }
-			line_code+=token_str;
-			token_list.push_back({line,get_tok_type(token_str),token_str});
-        }
-		else if(IS_CALC_OPERATOR(res[ptr]))
-		{
-			// get calculation operator
-			token_str=res[ptr++];
-			if(ptr<res_size && res[ptr]=='=')
-				token_str+=res[ptr++];
-			line_code+=token_str;
-			token_list.push_back({line,get_tok_type(token_str),token_str});
-		}
-		else if(IS_NOTE(res[ptr]))// avoid note, after this process ptr will point to a '\n', so next loop line counter+1
-			while(++ptr<res_size && res[ptr]!='\n');
-		else
-		{
-			line_code+=res[ptr++];
-			die("unknown character.");
-		}
-	}
-	token_list.push_back({line,tok_eof,""});
-	res.clear();
-	return;
-}
-
-void nasal_lexer::print_token()
-{
-    for(auto tok:token_list)
-        std::cout<<"("<<tok.line<<" | "<<tok.str<<")\n";
-    return;
-}
-
-#endif

nasal_vm.h

@@ -1,850 +0,0 @@
-#ifndef __NASAL_VM_H__
-#define __NASAL_VM_H__
-
-class nasal_vm
-{
-private:
-    /* reference from nasal_gc */
-    nasal_val**&             stack_top;// stack top
-    /* values of nasal_vm */
-    uint32_t                 pc;       // program counter
-    bool                     loop_mark;// when mark is false,break the main loop
-    std::stack<int>          ret;      // ptr stack stores address for function to return
-    std::stack<int>          counter;  // iterator stack for forindex/foreach
-    std::vector<std::string> str_table;// symbols used in process
-    std::vector<void (nasal_vm::*)()>
-                             exec_code;//function pointer
-    std::vector<uint32_t>    imm;      // immediate number
-    nasal_val**              mem_addr; // used for mem_call
-    nasal_gc                 gc;       // garbage collector
-    
-    void die(std::string);
-    bool condition(nasal_val*);
-    void opr_nop();
-    void opr_intg();
-    void opr_intl();
-    void opr_offset();
-    void opr_loadg();
-    void opr_loadl();
-    void opr_pnum();
-    void opr_pone();
-    void opr_pzero();
-    void opr_pnil();
-    void opr_pstr();
-    void opr_newv();
-    void opr_newh();
-    void opr_newf();
-    void opr_happ();
-    void opr_para();
-    void opr_defpara();
-    void opr_dynpara();
-    void opr_unot();
-    void opr_usub();
-    void opr_add();
-    void opr_sub();
-    void opr_mul();
-    void opr_div();
-    void opr_lnk();
-    void opr_addeq();
-    void opr_subeq();
-    void opr_muleq();
-    void opr_diveq();
-    void opr_lnkeq();
-    void opr_meq();
-    void opr_eq();
-    void opr_neq();
-    void opr_less();
-    void opr_leq();
-    void opr_grt();
-    void opr_geq();
-    void opr_pop();
-    void opr_jmp();
-    void opr_jt();
-    void opr_jf();
-    void opr_counter();
-    void opr_cntpop();
-    void opr_findex();
-    void opr_feach();
-    void opr_callg();
-    void opr_calll();
-    void opr_callv();
-    void opr_callvi();
-    void opr_callh();
-    void opr_callfv();
-    void opr_callfh();
-    void opr_callb();
-    void opr_slcbegin();
-    void opr_slcend();
-    void opr_slc();
-    void opr_slc2();
-    void opr_mcallg();
-    void opr_mcalll();
-    void opr_mcallv();
-    void opr_mcallh();
-    void opr_ret();
-public:
-    nasal_vm():stack_top(gc.stack_top){};
-    void init(
-        std::vector<std::string>&,
-        std::vector<double>&,
-        std::vector<opcode>&);
-    void clear();
-    void run();
-};
-
-void nasal_vm::init(
-    std::vector<std::string>& strs,
-    std::vector<double>&      nums,
-    std::vector<opcode>&      exec)
-{
-    gc.gc_init(nums,strs);
-    gc.val_stack[STACK_MAX_DEPTH-1]=nullptr;
-    str_table=strs; // get constant strings & symbols
-    void (nasal_vm::*opr_table[])()=
-    {
-        &nasal_vm::opr_nop,
-        &nasal_vm::opr_intg,
-        &nasal_vm::opr_intl,
-        &nasal_vm::opr_offset,
-        &nasal_vm::opr_loadg,
-        &nasal_vm::opr_loadl,
-        &nasal_vm::opr_pnum,
-        &nasal_vm::opr_pone,
-        &nasal_vm::opr_pzero,
-        &nasal_vm::opr_pnil,
-        &nasal_vm::opr_pstr,
-        &nasal_vm::opr_newv,
-        &nasal_vm::opr_newh,
-        &nasal_vm::opr_newf,
-        &nasal_vm::opr_happ,
-        &nasal_vm::opr_para,
-        &nasal_vm::opr_defpara,
-        &nasal_vm::opr_dynpara,
-        &nasal_vm::opr_unot,
-        &nasal_vm::opr_usub,
-        &nasal_vm::opr_add,
-        &nasal_vm::opr_sub,
-        &nasal_vm::opr_mul,
-        &nasal_vm::opr_div,
-        &nasal_vm::opr_lnk,
-        &nasal_vm::opr_addeq,
-        &nasal_vm::opr_subeq,
-        &nasal_vm::opr_muleq,
-        &nasal_vm::opr_diveq,
-        &nasal_vm::opr_lnkeq,
-        &nasal_vm::opr_meq,
-        &nasal_vm::opr_eq,
-        &nasal_vm::opr_neq,
-        &nasal_vm::opr_less,
-        &nasal_vm::opr_leq,
-        &nasal_vm::opr_grt,
-        &nasal_vm::opr_geq,
-        &nasal_vm::opr_pop,
-        &nasal_vm::opr_jmp,
-        &nasal_vm::opr_jt,
-        &nasal_vm::opr_jf,
-        &nasal_vm::opr_counter,
-        &nasal_vm::opr_cntpop,
-        &nasal_vm::opr_findex,
-        &nasal_vm::opr_feach,
-        &nasal_vm::opr_callg,
-        &nasal_vm::opr_calll,
-        &nasal_vm::opr_callv,
-        &nasal_vm::opr_callvi,
-        &nasal_vm::opr_callh,
-        &nasal_vm::opr_callfv,
-        &nasal_vm::opr_callfh,
-        &nasal_vm::opr_callb,
-        &nasal_vm::opr_slcbegin,
-        &nasal_vm::opr_slcend,
-        &nasal_vm::opr_slc,
-        &nasal_vm::opr_slc2,
-        &nasal_vm::opr_mcallg,
-        &nasal_vm::opr_mcalll,
-        &nasal_vm::opr_mcallv,
-        &nasal_vm::opr_mcallh,
-        &nasal_vm::opr_ret
-    };
-    for(auto& i:exec)
-    {
-        exec_code.push_back(opr_table[i.op]);
-        imm.push_back(i.num);
-    }
-    loop_mark=true; // set loop mark to true
-    return;
-}
-void nasal_vm::clear()
-{
-    gc.gc_clear();
-    while(!ret.empty())
-        ret.pop();
-    while(!counter.empty())
-        counter.pop();
-    str_table.clear();
-    exec_code.clear();
-    return;
-}
-void nasal_vm::die(std::string str)
-{
-    printf(">> [vm] 0x%.8x: %s\n",pc,str.c_str());
-    loop_mark=false;
-    return;
-}
-bool nasal_vm::condition(nasal_val* val_addr)
-{
-    if(val_addr->type==vm_num)
-        return val_addr->ptr.num;
-    else if(val_addr->type==vm_str)
-    {
-        std::string& str=*val_addr->ptr.str;
-        double num=str2num(str.c_str());
-        if(std::isnan(num))
-            return str.empty();
-        return num;
-    }
-    return false;
-}
-void nasal_vm::opr_nop()
-{
-    loop_mark=false;
-    return;
-}
-void nasal_vm::opr_intg()
-{
-    gc.global.resize(imm[pc],gc.nil_addr);
-    return;
-}
-void nasal_vm::opr_intl()
-{
-    stack_top[0]->ptr.func->closure.resize(imm[pc],gc.nil_addr);
-    return;
-}
-void nasal_vm::opr_offset()
-{
-    stack_top[0]->ptr.func->offset=imm[pc];
-    return;
-}
-void nasal_vm::opr_loadg()
-{
-    gc.global[imm[pc]]=(stack_top--)[0];
-    return;
-}
-void nasal_vm::opr_loadl()
-{
-    gc.local.back()[imm[pc]]=(stack_top--)[0];
-    return;
-}
-void nasal_vm::opr_pnum()
-{
-    (++stack_top)[0]=gc.num_addrs[imm[pc]];
-    return;
-}
-void nasal_vm::opr_pone()
-{
-    (++stack_top)[0]=gc.one_addr;
-    return;
-}
-void nasal_vm::opr_pzero()
-{
-    (++stack_top)[0]=gc.zero_addr;
-    return;
-}
-void nasal_vm::opr_pnil()
-{
-    (++stack_top)[0]=gc.nil_addr;
-    return;
-}
-void nasal_vm::opr_pstr()
-{
-    (++stack_top)[0]=gc.str_addrs[imm[pc]];
-    return;
-}
-void nasal_vm::opr_newv()
-{
-    nasal_val*  vec_addr=gc.gc_alloc(vm_vec);
-    nasal_val** begin=stack_top-imm[pc]+1;
-    auto& vec=vec_addr->ptr.vec->elems;// stack_top-imm[pc] stores the vector
-    vec.resize(imm[pc]);
-    for(int i=0;i<imm[pc];++i)
-        vec[i]=begin[i];
-    begin[0]=vec_addr;
-    stack_top=begin;
-    return;
-}
-void nasal_vm::opr_newh()
-{
-    (++stack_top)[0]=gc.gc_alloc(vm_hash);
-    return;
-}
-void nasal_vm::opr_newf()
-{
-    nasal_val* val=gc.gc_alloc(vm_func);
-    val->ptr.func->entry=imm[pc];
-    if(gc.local.empty())
-        val->ptr.func->closure.push_back(gc.nil_addr);// me
-    else
-        val->ptr.func->closure=gc.local.back();// local contains 'me'
-    (++stack_top)[0]=val;
-    return;
-}
-void nasal_vm::opr_happ()
-{
-    nasal_val* val=stack_top[0];
-    (--stack_top)[0]->ptr.hash->elems[str_table[imm[pc]]]=val;
-    return;
-}
-void nasal_vm::opr_para()
-{
-    nasal_func* func=stack_top[0]->ptr.func;
-    int size=func->key_table.size();
-    func->key_table[str_table[imm[pc]]]=size;
-    func->default_para.push_back(nullptr);
-    return;
-}
-void nasal_vm::opr_defpara()
-{
-    nasal_val* def_val=stack_top[0];
-    nasal_func* func=(--stack_top)[0]->ptr.func;
-    int size=func->key_table.size();
-    func->key_table[str_table[imm[pc]]]=size;
-    func->default_para.push_back(def_val);
-    return;
-}
-void nasal_vm::opr_dynpara()
-{
-    stack_top[0]->ptr.func->dynpara=imm[pc];
-    return;
-}
-void nasal_vm::opr_unot()
-{
-    nasal_val* val=stack_top[0];
-    int type=val->type;
-    if(type==vm_nil)
-        stack_top[0]=gc.one_addr;
-    else if(type==vm_num)
-        stack_top[0]=val->ptr.num?gc.zero_addr:gc.one_addr;
-    else if(type==vm_str)
-    {
-        double num=str2num(val->ptr.str->c_str());
-        if(std::isnan(num))
-            stack_top[0]=val->ptr.str->empty()?gc.one_addr:gc.zero_addr;
-        else
-            stack_top[0]=num?gc.zero_addr:gc.one_addr;
-    }
-    else
-        die("unot: incorrect value type");
-    return;
-}
-void nasal_vm::opr_usub()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_num);
-    new_val->ptr.num=-stack_top[0]->to_number();
-    stack_top[0]=new_val;
-    return;
-}
-void nasal_vm::opr_add()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_num);
-    new_val->ptr.num=stack_top[-1]->to_number()+stack_top[0]->to_number();
-    (--stack_top)[0]=new_val;
-    return;
-}
-void nasal_vm::opr_sub()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_num);
-    new_val->ptr.num=stack_top[-1]->to_number()-stack_top[0]->to_number();
-    (--stack_top)[0]=new_val;
-    return;
-}
-void nasal_vm::opr_mul()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_num);
-    new_val->ptr.num=stack_top[-1]->to_number()*stack_top[0]->to_number();
-    (--stack_top)[0]=new_val;
-    return;
-}
-void nasal_vm::opr_div()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_num);
-    new_val->ptr.num=stack_top[-1]->to_number()/stack_top[0]->to_number();
-    (--stack_top)[0]=new_val;
-    return;
-}
-void nasal_vm::opr_lnk()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_str);
-    *new_val->ptr.str=stack_top[-1]->to_string()+stack_top[0]->to_string();
-    (--stack_top)[0]=new_val;
-    return;
-}
-void nasal_vm::opr_addeq()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_num);
-    new_val->ptr.num=mem_addr[0]->to_number()+stack_top[-1]->to_number();
-    (--stack_top)[0]=mem_addr[0]=new_val;
-    return;
-}
-void nasal_vm::opr_subeq()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_num);
-    new_val->ptr.num=mem_addr[0]->to_number()-stack_top[-1]->to_number();
-    (--stack_top)[0]=mem_addr[0]=new_val;
-    return;
-}
-void nasal_vm::opr_muleq()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_num);
-    new_val->ptr.num=mem_addr[0]->to_number()*stack_top[-1]->to_number();
-    (--stack_top)[0]=mem_addr[0]=new_val;
-    return;
-}
-void nasal_vm::opr_diveq()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_num);
-    new_val->ptr.num=mem_addr[0]->to_number()/stack_top[-1]->to_number();
-    (--stack_top)[0]=mem_addr[0]=new_val;
-    return;
-}
-void nasal_vm::opr_lnkeq()
-{
-    nasal_val* new_val=gc.gc_alloc(vm_str);
-    *new_val->ptr.str=mem_addr[0]->to_string()+stack_top[-1]->to_string();
-    (--stack_top)[0]=mem_addr[0]=new_val;
-    return;
-}
-void nasal_vm::opr_meq()
-{
-    mem_addr[0]=(--stack_top)[0];
-    return;
-}
-void nasal_vm::opr_eq()
-{
-    nasal_val* val2=stack_top[0];
-    nasal_val* val1=(--stack_top)[0];
-    int a_type=val1->type;
-    int b_type=val2->type;
-    if(a_type==vm_nil && b_type==vm_nil)
-        stack_top[0]=gc.one_addr;
-    else if(a_type==vm_str && b_type==vm_str)
-        stack_top[0]=(*val1->ptr.str==*val2->ptr.str)?gc.one_addr:gc.zero_addr;
-    else if(a_type==vm_num || b_type==vm_num)
-        stack_top[0]=(val1->to_number()==val2->to_number())?gc.one_addr:gc.zero_addr;
-    else
-        stack_top[0]=(val1==val2)?gc.one_addr:gc.zero_addr;
-    return;
-}
-void nasal_vm::opr_neq()
-{
-    nasal_val* val2=stack_top[0];
-    nasal_val* val1=(--stack_top)[0];
-    int a_type=val1->type;
-    int b_type=val2->type;
-    if(a_type==vm_nil && b_type==vm_nil)
-        stack_top[0]=gc.zero_addr;
-    else if(a_type==vm_str && b_type==vm_str)
-        stack_top[0]=(*val1->ptr.str!=*val2->ptr.str)?gc.one_addr:gc.zero_addr;
-    else if(a_type==vm_num || b_type==vm_num)
-        stack_top[0]=(val1->to_number()!=val2->to_number())?gc.one_addr:gc.zero_addr;
-    else
-        stack_top[0]=(val1!=val2)?gc.one_addr:gc.zero_addr;
-    return;
-}
-void nasal_vm::opr_less()
-{
-    --stack_top;
-    stack_top[0]=(stack_top[0]->to_number()<stack_top[1]->to_number())?gc.one_addr:gc.zero_addr;
-    return;
-}
-void nasal_vm::opr_leq()
-{
-    --stack_top;
-    stack_top[0]=(stack_top[0]->to_number()<=stack_top[1]->to_number())?gc.one_addr:gc.zero_addr;
-    return;
-}
-void nasal_vm::opr_grt()
-{
-    --stack_top;
-    stack_top[0]=(stack_top[0]->to_number()>stack_top[1]->to_number())?gc.one_addr:gc.zero_addr;
-    return;
-}
-void nasal_vm::opr_geq()
-{
-    --stack_top;
-    stack_top[0]=(stack_top[0]->to_number()>=stack_top[1]->to_number())?gc.one_addr:gc.zero_addr;
-    return;
-}
-void nasal_vm::opr_pop()
-{
-    --stack_top;
-    return;
-}
-void nasal_vm::opr_jmp()
-{
-    pc=imm[pc]-1;
-    return;
-}
-void nasal_vm::opr_jt()
-{
-    if(condition(stack_top[0]))
-        pc=imm[pc]-1;
-    return;
-}
-void nasal_vm::opr_jf()
-{
-    if(!condition(stack_top[0]))
-        pc=imm[pc]-1;
-    --stack_top;
-    return;
-}
-void nasal_vm::opr_counter()
-{
-    counter.push(-1);
-    if(stack_top[0]->type!=vm_vec)
-        die("cnt: must use vector in forindex/foreach");
-    return;
-}
-void nasal_vm::opr_cntpop()
-{
-    counter.pop();
-    return;
-}
-void nasal_vm::opr_findex()
-{
-    if(++counter.top()>=stack_top[0]->ptr.vec->elems.size())
-    {
-        pc=imm[pc]-1;
-        return;
-    }
-    (++stack_top)[0]=gc.gc_alloc(vm_num);
-    stack_top[0]->ptr.num=counter.top();
-    return;
-}
-void nasal_vm::opr_feach()
-{
-    std::vector<nasal_val*>& ref=stack_top[0]->ptr.vec->elems;
-    if(++counter.top()>=ref.size())
-    {
-        pc=imm[pc]-1;
-        return;
-    }
-    (++stack_top)[0]=ref[counter.top()];
-    return;
-}
-void nasal_vm::opr_callg()
-{
-    (++stack_top)[0]=gc.global[imm[pc]];
-    return;
-}
-void nasal_vm::opr_calll()
-{
-    (++stack_top)[0]=gc.local.back()[imm[pc]];
-    return;
-}
-void nasal_vm::opr_callv()
-{
-    nasal_val* val=stack_top[0];
-    nasal_val* vec_addr=(--stack_top)[0];
-    int type=vec_addr->type;
-    if(type==vm_vec)
-    {
-        stack_top[0]=vec_addr->ptr.vec->get_val(val->to_number());
-        if(!stack_top[0])
-            die("callv: index out of range:"+num2str(val->to_number()));
-    }
-    else if(type==vm_hash)
-    {
-        if(val->type!=vm_str)
-        {
-            die("callv: must use string as the key");
-            return;
-        }
-        stack_top[0]=vec_addr->ptr.hash->get_val(*val->ptr.str);
-        if(!stack_top[0])
-        {
-            die("callv: cannot find member \""+*val->ptr.str+"\" of this hash");
-            return;
-        }
-        if(stack_top[0]->type==vm_func)
-            stack_top[0]->ptr.func->closure[0]=val;// me
-    }
-    else if(type==vm_str)
-    {
-        std::string& str=*vec_addr->ptr.str;
-        int num=val->to_number();
-        int str_size=str.length();
-        if(num<-str_size || num>=str_size)
-        {
-            die("callv: index out of range:"+num2str(val->to_number()));
-            return;
-        }
-        stack_top[0]=gc.gc_alloc(vm_num);
-        stack_top[0]->ptr.num=(str[num>=0? num:num+str_size]);
-    }
-    else
-        die("callv: must call a vector/hash/string");
-    return;
-}
-void nasal_vm::opr_callvi()
-{
-    nasal_val* val=stack_top[0];
-    if(val->type!=vm_vec)
-    {
-        die("callvi: multi-definition/multi-assignment must use a vector");
-        return;
-    }
-    // cannot use operator[],because this may cause overflow
-    (++stack_top)[0]=val->ptr.vec->get_val(imm[pc]);
-    if(!stack_top[0])
-        die("callvi: index out of range:"+num2str(imm[pc]));
-    return;
-}
-void nasal_vm::opr_callh()
-{
-    nasal_val* val=stack_top[0];
-    if(val->type!=vm_hash)
-    {
-        die("callh: must call a hash");
-        return;
-    }
-    stack_top[0]=val->ptr.hash->get_val(str_table[imm[pc]]);
-    if(!stack_top[0])
-    {
-        die("callh: member \""+str_table[imm[pc]]+"\" does not exist");
-        return;
-    }
-    if(stack_top[0]->type==vm_func)
-        stack_top[0]->ptr.func->closure[0]=val;// me
-    return;
-}
-void nasal_vm::opr_callfv()
-{
-    // get parameter list and function value
-    int args_size=imm[pc];
-    nasal_val** vec=stack_top-args_size+1;
-    nasal_val* func_addr=vec[-1];
-    if(func_addr->type!=vm_func)
-    {
-        die("callfv: must call a function");
-        return;
-    }
-    // push new local scope
-    auto& ref_func=*func_addr->ptr.func;
-    gc.local.push_back(ref_func.closure);
-    // load parameters
-    auto& ref_default=ref_func.default_para;
-    auto& ref_closure=gc.local.back();
-
-    int offset=ref_func.offset;
-    int para_size=ref_func.key_table.size();
-    // load arguments
-    if(args_size<para_size && !ref_default[args_size])
-    {
-        // if the first default value is not nullptr,then values after it are not nullptr
-        die("callfv: lack argument(s)");
-        return;
-    }
-    // if args_size>para_size,for 0 to args_size will cause corruption
-    for(int i=0;i<para_size;++i)
-        ref_closure[i+offset]=(i<args_size)?vec[i]:ref_default[i];
-    // load dynamic argument if args_size>=para_size
-    if(ref_func.dynpara>=0)
-    {
-        nasal_val* vec_addr=gc.gc_alloc(vm_vec);
-        for(int i=para_size;i<args_size;++i)
-            vec_addr->ptr.vec->elems.push_back(vec[i]);
-        ref_closure[para_size+offset]=vec_addr;
-    }
-    
-    stack_top-=args_size;// pop arguments
-    ret.push(pc);
-    pc=ref_func.entry-1;
-    return;
-}
-void nasal_vm::opr_callfh()
-{
-    // get parameter list and function value
-    auto& ref_hash=stack_top[0]->ptr.hash->elems;
-    nasal_val* func_addr=stack_top[-1];
-    if(func_addr->type!=vm_func)
-    {
-        die("callfh: must call a function");
-        return;
-    }
-    // push new local scope
-    auto& ref_func=*func_addr->ptr.func;
-    gc.local.push_back(ref_func.closure);
-    // load parameters
-    auto& ref_default=ref_func.default_para;
-    auto& ref_closure=gc.local.back();
-
-    if(ref_func.dynpara>=0)
-    {
-        die("callfh: special call cannot use dynamic argument");
-        return;
-    }
-    int offset=ref_func.offset;
-    for(auto& i:ref_func.key_table)
-    {
-        if(ref_hash.count(i.first))
-            ref_closure[i.second+offset]=ref_hash[i.first];
-        else if(ref_default[i.second])
-            ref_closure[i.second+offset]=ref_default[i.second];
-        else
-        {
-            die("callfh: lack argument(s): \""+i.first+"\"");
-            return;
-        }
-    }
-
-    --stack_top;// pop hash
-    ret.push(pc);
-    pc=ref_func.entry-1;
-    return;
-}
-void nasal_vm::opr_callb()
-{
-    loop_mark=(++stack_top)[0]=(*builtin_func[imm[pc]].func)(gc.local.back(),gc);
-    return;
-}
-void nasal_vm::opr_slcbegin()
-{
-    gc.slice_stack.push_back(gc.gc_alloc(vm_vec));
-    if(stack_top[0]->type!=vm_vec)
-        die("slcbegin: must slice a vector");
-    return;
-}
-void nasal_vm::opr_slcend()
-{
-    stack_top[0]=gc.slice_stack.back();
-    gc.slice_stack.pop_back();
-    return;
-}
-void nasal_vm::opr_slc()
-{
-    nasal_val* val=(stack_top--)[0];
-    nasal_val* res=stack_top[0]->ptr.vec->get_val(val->to_number());
-    if(!res)
-        die("slc: index out of range:"+num2str(val->to_number()));
-    gc.slice_stack.back()->ptr.vec->elems.push_back(res);
-    return;
-}
-void nasal_vm::opr_slc2()
-{
-    nasal_val* val2=(stack_top--)[0];
-    nasal_val* val1=(stack_top--)[0];
-    std::vector<nasal_val*>& ref=stack_top[0]->ptr.vec->elems;
-    std::vector<nasal_val*>& aim=gc.slice_stack.back()->ptr.vec->elems;
-
-    int type1=val1->type,type2=val2->type;
-    int num1=val1->to_number();
-    int num2=val2->to_number();
-    int ref_size=ref.size();
-    if(type1==vm_nil && type2==vm_nil)
-    {
-        num1=0;
-        num2=ref_size-1;
-    }
-    else if(type1==vm_nil && type2!=vm_nil)
-        num1=num2<0? -ref_size:0;
-    else if(type1!=vm_nil && type2==vm_nil)
-        num2=num1<0? -1:ref_size-1;
-
-    if(num1>=num2)
-    {
-        die("slc2: begin index must be less than end index");
-        return;
-    }
-    else if(num1<-ref_size || num1>=ref_size)
-    {
-        die("slc2: begin index out of range: "+num2str(num1));
-        return;
-    }
-    else if(num2<-ref_size || num2>=ref_size)
-    {
-        die("slc2: end index out of range: "+num2str(num2));
-        return;
-    }
-    for(int i=num1;i<=num2;++i)
-        aim.push_back(i>=0?ref[i]:ref[i+ref_size]);
-    return;
-}
-void nasal_vm::opr_mcallg()
-{
-    mem_addr=&gc.global[imm[pc]];
-    (++stack_top)[0]=mem_addr[0];
-    return;
-}
-void nasal_vm::opr_mcalll()
-{
-    mem_addr=&gc.local.back()[imm[pc]];
-    (++stack_top)[0]=mem_addr[0];
-    return;
-}
-void nasal_vm::opr_mcallv()
-{
-    nasal_val* val=stack_top[0];
-    nasal_val* vec_addr=(--stack_top)[0];
-    int type=vec_addr->type;
-    if(type==vm_vec)
-    {
-        mem_addr=vec_addr->ptr.vec->get_mem(val->to_number());
-        if(!mem_addr)
-            die("mcallv: index out of range:"+num2str(val->to_number()));
-    }
-    else if(type==vm_hash)
-    {
-        if(val->type!=vm_str)
-        {
-            die("mcallv: must use string as the key");
-            return;
-        }
-        nasal_hash& ref=*vec_addr->ptr.hash;
-        std::string& str=*val->ptr.str;
-        mem_addr=ref.get_mem(str);
-        if(!mem_addr)
-        {
-            ref.elems[str]=gc.nil_addr;
-            mem_addr=ref.get_mem(str);
-        }
-    }
-    else
-        die("mcallv: cannot get memory space in other types");
-    return;
-}
-void nasal_vm::opr_mcallh()
-{
-    nasal_val* hash_addr=stack_top[0];
-    if(hash_addr->type!=vm_hash)
-    {
-        die("mcallh: must call a hash");
-        return;
-    }
-    nasal_hash& ref=*hash_addr->ptr.hash;
-    std::string& str=str_table[imm[pc]];
-    mem_addr=ref.get_mem(str);
-    if(!mem_addr) // create a new key
-    {
-        ref.elems[str]=gc.nil_addr;
-        mem_addr=ref.get_mem(str);
-    }
-    return;
-}
-void nasal_vm::opr_ret()
-{
-    gc.local.pop_back();// delete local scope
-    pc=ret.top();ret.pop();// fetch pc
-    (--stack_top)[0]->ptr.func->closure[0]=gc.nil_addr;// set 'me' to nil
-    stack_top[0]=stack_top[1];// rewrite nasal_func with returned value
-    return;
-}
-void nasal_vm::run()
-{
-    clock_t begin_time=clock();
-    for(pc=0;loop_mark&&!gc.val_stack[STACK_MAX_DEPTH-1];++pc)
-        (this->*exec_code[pc])();
-    if(gc.val_stack[STACK_MAX_DEPTH-1])
-        die("stack overflow");
-    std::cout<<">> [vm] process exited after "<<((double)(clock()-begin_time))/CLOCKS_PER_SEC<<"s.\n";
-    return;
-}
-#endif

props.nas

@@ -1,152 +0,0 @@
-import("lib.nas");
-
-var props=
-{
-    globals:nil,
-    Node:nil,
-    getNode:func(path,index)
-    {
-        path=split('/',path);
-        var tmp=me.globals;
-        var path_size=size(path);
-        for(var i=0;i<path_size-1;i+=1)
-            tmp=tmp.val[path[i]];
-        if(path_size>0)
-        {
-            if(contains(tmp.val,path[i]~'['~index~']'))
-                return tmp.val[path[i]~'['~index~']'];
-            else
-                return tmp.val[path[i]];
-        }
-        return tmp;
-    }
-};
-
-props.Node=
-{
-    new:func(values=nil)
-    {
-        var result={
-            parents:[props.Node],
-            val:{},
-            type:'GHOST',
-            parent:nil
-        };
-        if(typeof(values)=="hash")
-            result.val=values;
-        return result;
-    },
-    addChild:func(name)
-    {
-        if(!contains(me.val,name))
-        {
-            me.val[name]=props.Node.new();
-            me.val[name].parent=me;
-            return 1;
-        }
-        return 0;
-    },
-    addChildren:func(name,cnt=0)
-    {
-        for(var i=0;i<cnt;i+=1)
-        {
-            var label=name~'['~i~']';
-            me.val[label]=props.Node.new();
-            me.val[label].parent=me;
-        }
-        return;
-    },
-    setValue:func(path,val)
-    {
-        path=split('/',path);
-        var tmp=me;
-        foreach(var label;path)
-            tmp=tmp.val[label];
-        tmp.val=val;
-        if(typeof(val)=='string')
-        {
-            if(val=='true' or val=='false')
-                tmp.type='BOOL';
-            else
-                tmp.type='STRING';
-        }
-        elsif(typeof(val)=='number')
-            tmp.type='DOUBLE';
-        return;
-    },
-    setIntValue:func(num)
-    {
-        me.val=num;
-        me.type='INT';
-        return;
-    },
-    setBoolValue:func(state)
-    {
-        me.val=state;
-        me.type='BOOL';
-        return;
-    },
-    setDoubleValue:func(num)
-    {
-        me.val=num;
-        me.type='DOUBLE';
-        return;
-    },
-    getValue:func(){return me.val;},
-    getName:func()
-    {
-        var val=me.parent.val;
-        var key=keys(val);
-        foreach(var k;key)
-            if(val[k]==me)
-                return k;
-        return '';
-    },
-    getParent:func()
-    {
-        return me.parent;
-    },
-    getPath:func()
-    {
-        if(me.parent==nil) return '';
-        return me.parent.getPath()~'/'~me.getName();
-    },
-    equals:func(node){return me==node;},
-    debug:func(s='')
-    {
-        if(typeof(me.val)=='hash')
-        {
-            var key=keys(me.val);
-            println('{');
-            foreach(var k;key)
-            {
-                print(s~'  ',k,':');
-                me.val[k].debug(s~'  ');
-            }
-            println(s,'}');
-        }
-        else
-            println(me.val,' (',me.type,')');
-        return;
-    }
-};
-
-props.globals=props.Node.new();
-var c=['aircraft','ai','models','position','orientation','controls','sim'];
-foreach(var i;c)
-    props.getNode('/',1).addChild(i);
-props.getNode('/ai',1).addChildren('ai',4);
-props.getNode('/aircraft',1).setValue('/','IDG MD-11');
-for(var i=0;i<4;i+=1)
-    props.getNode('/ai/ai['~i~']',1).setBoolValue('true');
-props.getNode('/models',1).addChildren('building',4);
-for(var i=0;i<4;i+=1)
-    props.getNode('/models/building['~i~']',1).setIntValue(i);
-props.getNode('/',1).addChild('test');
-props.getNode('/test',1).addChildren('in',4);
-props.getNode('/test/in',0).setValue('/','true');
-props.getNode('/test/in',1).setValue('/','false');
-props.getNode('/test/in',2).setValue('/','welcome aboard,need help? use help->tutorial');
-props.getNode('/test/in',3).setValue('/',2147483648);
-props.globals.debug();
-println(props.getNode('/test/in',3).getPath());

src/ast/ast.cpp

@@ -0,0 +1,386 @@
+#include "ast.h"
+#include "ast_visitor.h"
+
+namespace nasal {
+
+void expr::accept(ast_visitor* visitor) {
+    visitor->visit_expr(this);
+}
+
+use_stmt::~use_stmt() {
+    for (auto i : path) {
+        delete i;
+    }
+}
+
+void use_stmt::accept(ast_visitor* visitor) {
+    visitor->visit_use_stmt(this);
+}
+
+void call::accept(ast_visitor* visitor) {
+    visitor->visit_call(this);
+}
+
+void null_expr::accept(ast_visitor* visitor) {
+    visitor->visit_null_expr(this);
+}
+
+void nil_expr::accept(ast_visitor* visitor) {
+    visitor->visit_nil_expr(this);
+}
+
+void number_literal::accept(ast_visitor* visitor) {
+    visitor->visit_number_literal(this);
+}
+
+void string_literal::accept(ast_visitor* visitor) {
+    visitor->visit_string_literal(this);
+}
+
+void identifier::accept(ast_visitor* visitor) {
+    visitor->visit_identifier(this);
+}
+
+void bool_literal::accept(ast_visitor* visitor) {
+    visitor->visit_bool_literal(this);
+}
+
+vector_expr::~vector_expr() {
+    for (auto i : elements) {
+        delete i;
+    }
+}
+
+void vector_expr::accept(ast_visitor* visitor) {
+    visitor->visit_vector_expr(this);
+}
+
+hash_expr::~hash_expr() {
+    for (auto i : members) {
+        delete i;
+    }
+}
+
+void hash_expr::accept(ast_visitor* visitor) {
+    visitor->visit_hash_expr(this);
+}
+
+hash_pair::~hash_pair() {
+    if (value) {
+        delete value;
+    }
+}
+
+void hash_pair::accept(ast_visitor* visitor) {
+    visitor->visit_hash_pair(this);
+}
+
+function::~function() {
+    for (auto i : parameter_list) {
+        delete i;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void function::accept(ast_visitor* visitor) {
+    visitor->visit_function(this);
+}
+
+code_block::~code_block() {
+    for (auto i : expressions) {
+        delete i;
+    }
+}
+
+void code_block::accept(ast_visitor* visitor) {
+    visitor->visit_code_block(this);
+}
+
+parameter::~parameter() {
+    if (default_value) {
+        delete default_value;
+    }
+}
+
+void parameter::accept(ast_visitor* visitor) {
+    visitor->visit_parameter(this);
+}
+
+ternary_operator::~ternary_operator() {
+    if (condition) {
+        delete condition;
+    }
+    if (left) {
+        delete left;
+    }
+    if (right) {
+        delete right;
+    }
+}
+
+void ternary_operator::accept(ast_visitor* visitor) {
+    visitor->visit_ternary_operator(this);
+}
+
+binary_operator::~binary_operator() {
+    if (left) {
+        delete left;
+    }
+    if (right) {
+        delete right;
+    }
+    if (optimized_const_number) {
+        delete optimized_const_number;
+    }
+    if (optimized_const_string) {
+        delete optimized_const_string;
+    }
+}
+
+void binary_operator::accept(ast_visitor* visitor) {
+    visitor->visit_binary_operator(this);
+}
+
+unary_operator::~unary_operator() {
+    if (value) {
+        delete value;
+    }
+    if (optimized_number) {
+        delete optimized_number;
+    }
+}
+
+void unary_operator::accept(ast_visitor* visitor) {
+    visitor->visit_unary_operator(this);
+}
+
+call_expr::~call_expr() {
+    if (first) {
+        delete first;
+    }
+    for (auto i : calls) {
+        delete i;
+    }
+}
+
+void call_expr::accept(ast_visitor* visitor) {
+    visitor->visit_call_expr(this);
+}
+
+void call_hash::accept(ast_visitor* visitor) {
+    visitor->visit_call_hash(this);
+}
+
+void null_access::accept(ast_visitor* visitor) {
+    visitor->visit_null_access(this);
+}
+
+call_vector::~call_vector() {
+    for (auto i : calls) {
+        delete i;
+    }
+}
+
+void call_vector::accept(ast_visitor* visitor) {
+    visitor->visit_call_vector(this);
+}
+
+call_function::~call_function() {
+    for (auto i : args) {
+        delete i;
+    }
+}
+
+void call_function::accept(ast_visitor* visitor) {
+    visitor->visit_call_function(this);
+}
+
+slice_vector::~slice_vector() {
+    if (begin) {
+        delete begin;
+    }
+    if (end) {
+        delete end;
+    }
+}
+
+void slice_vector::accept(ast_visitor* visitor) {
+    visitor->visit_slice_vector(this);
+}
+
+definition_expr::~definition_expr() {
+    if (variable_name) {
+        delete variable_name;
+    }
+    if (variables) {
+        delete variables;
+    }
+    if (tuple) {
+        delete tuple;
+    }
+    if (value) {
+        delete value;
+    }
+}
+
+void definition_expr::accept(ast_visitor* visitor) {
+    visitor->visit_definition_expr(this);
+}
+
+assignment_expr::~assignment_expr() {
+    if (left) {
+        delete left;
+    }
+    if (right) {
+        delete right;
+    }
+}
+
+void assignment_expr::accept(ast_visitor* visitor) {
+    visitor->visit_assignment_expr(this);
+}
+
+multi_identifier::~multi_identifier() {
+    for (auto i : variables) {
+        delete i;
+    }
+}
+
+void multi_identifier::accept(ast_visitor* visitor) {
+    visitor->visit_multi_identifier(this);
+}
+
+tuple_expr::~tuple_expr() {
+    for (auto i : elements) {
+        delete i;
+    }
+}
+
+void tuple_expr::accept(ast_visitor* visitor) {
+    visitor->visit_tuple_expr(this);
+}
+
+multi_assign::~multi_assign() {
+    if (tuple) {
+        delete tuple;
+    }
+    if (value) {
+        delete value;
+    }
+}
+
+void multi_assign::accept(ast_visitor* visitor) {
+    visitor->visit_multi_assign(this);
+}
+
+while_expr::~while_expr() {
+    if (condition) {
+        delete condition;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void while_expr::accept(ast_visitor* visitor) {
+    visitor->visit_while_expr(this);
+}
+
+for_expr::~for_expr() {
+    if (initializing) {
+        delete initializing;
+    }
+    if (condition) {
+        delete condition;
+    }
+    if (step) {
+        delete step;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void for_expr::accept(ast_visitor* visitor) {
+    visitor->visit_for_expr(this);
+}
+
+iter_expr::~iter_expr() {
+    if (name) {
+        delete name;
+    }
+    if (call) {
+        delete call;
+    }
+}
+
+void iter_expr::accept(ast_visitor* visitor) {
+    visitor->visit_iter_expr(this);
+}
+
+forei_expr::~forei_expr() {
+    if (iterator) {
+        delete iterator;
+    }
+    if (vector_node) {
+        delete vector_node;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void forei_expr::accept(ast_visitor* visitor) {
+    visitor->visit_forei_expr(this);
+}
+
+condition_expr::~condition_expr() {
+    if (if_stmt) {
+        delete if_stmt;
+    }
+    for (auto i : elsif_stmt) {
+        delete i;
+    }
+    if (else_stmt) {
+        delete else_stmt;
+    }
+}
+
+void condition_expr::accept(ast_visitor* visitor) {
+    visitor->visit_condition_expr(this);
+}
+
+if_expr::~if_expr() {
+    if (condition) {
+        delete condition;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void if_expr::accept(ast_visitor* visitor) {
+    visitor->visit_if_expr(this);
+}
+
+void continue_expr::accept(ast_visitor* visitor) {
+    visitor->visit_continue_expr(this);
+}
+
+void break_expr::accept(ast_visitor* visitor) {
+    visitor->visit_break_expr(this);
+}
+
+return_expr::~return_expr() {
+    if (value) {
+        delete value;
+    }
+}
+
+void return_expr::accept(ast_visitor* visitor) {
+    visitor->visit_return_expr(this);
+}
+
+}

src/ast/ast.h

@@ -0,0 +1,711 @@
+#pragma once
+
+#include "nasal.h"
+#include "nasal_err.h"
+
+#include <vector>
+#include <unordered_map>
+
+namespace nasal {
+
+enum class expr_type {
+    ast_null = 0,    // null node
+    ast_use,         // use statement
+    ast_block,       // code block 
+    ast_nil,         // nil keyword
+    ast_num,         // number, basic value type
+    ast_str,         // string, basic value type
+    ast_id,          // identifier
+    ast_bool,        // bools
+    ast_func,        // func keyword
+    ast_hash,        // hash, basic value type
+    ast_vec,         // vector, basic value type
+    ast_pair,        // pair of key and value in hashmap
+    ast_call,        // mark a sub-tree of calling an identifier
+    ast_callh,       // id.name
+    ast_null_access, // id?.name
+    ast_callv,       // id[index]
+    ast_callf,       // id()
+    ast_subvec,      // id[index:index]
+    ast_param,       // function parameter
+    ast_ternary,     // ternary operator
+    ast_binary,      // binary operator
+    ast_unary,       // unary operator
+    ast_for,         // for keyword
+    ast_forei,       // foreach or forindex loop
+    ast_while,       // while
+    ast_iter,        // iterator, used in forindex/foreach
+    ast_cond,        // mark a sub-tree of conditional expression
+    ast_if,          // if keyword
+    ast_multi_id,    // multi identifiers sub-tree
+    ast_tuple,       // tuple, stores multiple scalars
+    ast_def,         // definition
+    ast_assign,      // assignment
+    ast_multi_assign,// multiple assignment
+    ast_continue,    // continue keyword, only used in loop
+    ast_break,       // break keyword, only used in loop
+    ast_ret          // return keyword, only used in function block
+};
+
+class ast_visitor;
+class identifier;
+class hash_pair;
+class parameter;
+class slice_vector;
+class multi_identifier;
+class code_block;
+class if_expr;
+class tuple_expr;
+
+class expr {
+protected:
+    span nd_loc;
+    expr_type nd_type;
+
+public:
+    expr(const span& location, expr_type node_type):
+        nd_loc(location), nd_type(node_type) {}
+    virtual ~expr() = default;
+    void set_begin(u64 line, u64 column) {
+        nd_loc.begin_line = line;
+        nd_loc.begin_column = column;
+    }
+    const auto& get_location() const { return nd_loc; }
+    const auto get_line() const { return nd_loc.begin_line; }
+    auto get_type() const { return nd_type; }
+    void update_location(const span& location) {
+        nd_loc.end_line = location.end_line;
+        nd_loc.end_column = location.end_column;
+    }
+    virtual void accept(ast_visitor*);
+};
+
+class use_stmt: public expr {
+private:
+    std::vector<identifier*> path;
+
+public:
+    use_stmt(const span& location):
+        expr(location, expr_type::ast_use) {}
+    ~use_stmt() override;
+    void accept(ast_visitor*) override;
+    void add_path(identifier* node) {path.push_back(node);}
+    const auto& get_path() const {return path;}
+};
+
+class call: public expr {
+public:
+    call(const span& location, expr_type node_type):
+        expr(location, node_type) {}
+    virtual ~call() = default;
+    virtual void accept(ast_visitor*);
+};
+
+class null_expr: public expr {
+public:
+    null_expr(const span& location):
+        expr(location, expr_type::ast_null) {}
+    ~null_expr() override = default;
+    void accept(ast_visitor*) override;
+};
+
+class nil_expr: public expr {
+public:
+    nil_expr(const span& location):
+        expr(location, expr_type::ast_nil) {}
+    ~nil_expr() override = default;
+    void accept(ast_visitor*) override;
+};
+
+class number_literal: public expr {
+private:
+    f64 number;
+    std::string raw_text;
+
+public:
+    number_literal(const span& location, const f64 num, const std::string& raw):
+        expr(location, expr_type::ast_num), number(num), raw_text(raw) {}
+    ~number_literal() override = default;
+    f64 get_number() const { return number; }
+    const std::string& get_raw_text() const { return raw_text; }
+    void accept(ast_visitor*) override;
+};
+
+class string_literal: public expr {
+private:
+    std::string content;
+
+public:
+    string_literal(const span& location, const std::string& str):
+        expr(location, expr_type::ast_str), content(str) {}
+    ~string_literal() override = default;
+    const std::string& get_content() const {return content;}
+    void accept(ast_visitor*) override;
+};
+
+class identifier: public expr {
+private:
+    std::string name;
+
+public:
+    identifier(const span& location, const std::string& str):
+        expr(location, expr_type::ast_id), name(str) {}
+    ~identifier() override = default;
+    const std::string& get_name() const {return name;}
+    void accept(ast_visitor*) override;
+};
+
+class bool_literal: public expr {
+private:
+    bool flag;
+
+public:
+    bool_literal(const span& location, const bool bool_flag):
+        expr(location, expr_type::ast_bool), flag(bool_flag) {}
+    ~bool_literal() override = default;
+    bool get_flag() const {return flag;}
+    void accept(ast_visitor*) override;
+};
+
+class vector_expr: public expr {
+private:
+    std::vector<expr*> elements;
+
+public:
+    vector_expr(const span& location):
+        expr(location, expr_type::ast_vec) {}
+    ~vector_expr() override;
+    void add_element(expr* node) {elements.push_back(node);}
+    std::vector<expr*>& get_elements() {return elements;}
+    void accept(ast_visitor*) override;
+};
+
+class hash_expr: public expr {
+private:
+    std::vector<hash_pair*> members;
+
+public:
+    hash_expr(const span& location):
+        expr(location, expr_type::ast_hash) {}
+    ~hash_expr() override;
+    void add_member(hash_pair* node) {members.push_back(node);}
+    std::vector<hash_pair*>& get_members() {return members;}
+    void accept(ast_visitor*) override;
+};
+
+class hash_pair: public expr {
+private:
+    std::string name;
+    expr* value;
+
+public:
+    hash_pair(const span& location):
+        expr(location, expr_type::ast_pair),
+        value(nullptr) {}
+    ~hash_pair() override;
+    void set_name(const std::string& field_name) {name = field_name;}
+    void set_value(expr* node) {value = node;}
+    const std::string& get_name() const {return name;}
+    expr* get_value() {return value;}
+    void accept(ast_visitor*) override;
+};
+
+class function: public expr {
+private:
+    std::vector<parameter*> parameter_list;
+    code_block* block;
+
+public:
+    function(const span& location):
+        expr(location, expr_type::ast_func),
+        block(nullptr) {}
+    ~function() override;
+    void add_parameter(parameter* node) {parameter_list.push_back(node);}
+    void set_code_block(code_block* node) {block = node;}
+    std::vector<parameter*>& get_parameter_list() {return parameter_list;}
+    code_block* get_code_block() {return block;}
+    void accept(ast_visitor*) override;
+};
+
+class code_block: public expr {
+private:
+    std::vector<expr*> expressions;
+
+public:
+    code_block(const span& location):
+        expr(location, expr_type::ast_block) {}
+    ~code_block() override;
+    void add_expression(expr* node) {expressions.push_back(node);}
+    std::vector<expr*>& get_expressions() {return expressions;}
+    void accept(ast_visitor*) override;
+};
+
+class parameter: public expr {
+public:
+    enum class kind {
+        normal_parameter,
+        default_parameter,
+        dynamic_parameter
+    };
+
+private:
+    kind type;
+    std::string name;
+    expr* default_value;
+
+public:
+    parameter(const span& location):
+        expr(location, expr_type::ast_param),
+        name(""), default_value(nullptr) {}
+    ~parameter() override;
+    void set_parameter_type(kind pt) {type = pt;}
+    void set_parameter_name(const std::string& pname) {name = pname;}
+    void set_default_value(expr* node) {default_value = node;}
+    auto get_parameter_type() {return type;}
+    const auto& get_parameter_name() const {return name;}
+    auto get_default_value() {return default_value;}
+    void accept(ast_visitor*) override;
+};
+
+class ternary_operator: public expr {
+private:
+    expr* condition;
+    expr* left;
+    expr* right;
+
+public:
+    ternary_operator(const span& location):
+        expr(location, expr_type::ast_ternary),
+        condition(nullptr), left(nullptr), right(nullptr) {}
+    ~ternary_operator() override;
+    void set_condition(expr* node) {condition = node;}
+    void set_left(expr* node) {left = node;}
+    void set_right(expr* node) {right = node;}
+    expr* get_condition() {return condition;}
+    expr* get_left() {return left;}
+    expr* get_right() {return right;}
+    void accept(ast_visitor*) override;
+};
+
+class binary_operator: public expr {
+public:
+    enum class kind {
+        add,
+        sub,
+        mult,
+        div,
+        concat,
+        cmpeq,
+        cmpneq,
+        less,
+        leq,
+        grt,
+        geq,
+        bitwise_or,
+        bitwise_xor,
+        bitwise_and,
+        condition_and,
+        condition_or,
+        null_chain
+    };
+
+private:
+    kind type;
+    expr* left;
+    expr* right;
+    number_literal* optimized_const_number;
+    string_literal* optimized_const_string;
+
+public:
+    binary_operator(const span& location):
+        expr(location, expr_type::ast_binary),
+        left(nullptr), right(nullptr),
+        optimized_const_number(nullptr),
+        optimized_const_string(nullptr) {}
+    ~binary_operator() override;
+    void set_operator_type(kind operator_type) {type = operator_type;}
+    void set_left(expr* node) {left = node;}
+    void set_right(expr* node) {right = node;}
+    void set_optimized_number(number_literal* node) {optimized_const_number = node;}
+    void set_optimized_string(string_literal* node) {optimized_const_string = node;}
+    auto get_operator_type() const {return type;}
+    auto get_left() {return left;}
+    auto get_right() {return right;}
+    auto get_optimized_number() {return optimized_const_number;}
+    auto get_optimized_string() {return optimized_const_string;}
+    void accept(ast_visitor*) override;
+};
+
+class unary_operator: public expr {
+public:
+    enum class kind {
+        negative,
+        logical_not,
+        bitwise_not
+    };
+
+private:
+    kind type;
+    expr* value;
+    number_literal* optimized_number;
+
+public:
+    unary_operator(const span& location):
+        expr(location, expr_type::ast_unary),
+        value(nullptr), optimized_number(nullptr) {}
+    ~unary_operator() override;
+    void set_operator_type(kind operator_type) {type = operator_type;}
+    void set_value(expr* node) {value = node;}
+    void set_optimized_number(number_literal* node) {optimized_number = node;}
+    auto get_operator_type() const {return type;}
+    auto get_value() {return value;}
+    auto get_optimized_number() {return optimized_number;}
+    void accept(ast_visitor*) override;
+};
+
+class call_expr: public expr {
+private:
+    expr* first;
+    std::vector<call*> calls;
+
+public:
+    call_expr(const span& location):
+        expr(location, expr_type::ast_call),
+        first(nullptr) {}
+    ~call_expr() override;
+    void set_first(expr* node) {first = node;}
+    void add_call(call* node) {calls.push_back(node);}
+    expr* get_first() {return first;}
+    auto& get_calls() {return calls;}
+    void accept(ast_visitor*) override;
+};
+
+class call_hash: public call {
+private:
+    std::string field;
+
+public:
+    call_hash(const span& location, const std::string& name):
+        call(location, expr_type::ast_callh),
+        field(name) {}
+    ~call_hash() override = default;
+    const std::string& get_field() const {return field;}
+    void accept(ast_visitor*) override;
+};
+
+class null_access: public call {
+private:
+    std::string field;
+
+public:
+    null_access(const span& location, const std::string& name):
+        call(location, expr_type::ast_null_access),
+        field(name) {}
+    ~null_access() override = default;
+    const std::string& get_field() const {return field;}
+    void accept(ast_visitor*) override;
+};
+
+class call_vector: public call {
+private:
+    std::vector<slice_vector*> calls;
+
+public:
+    call_vector(const span& location):
+        call(location, expr_type::ast_callv) {}
+    ~call_vector() override;
+    void add_slice(slice_vector* node) {calls.push_back(node);}
+    std::vector<slice_vector*>& get_slices() {return calls;}
+    void accept(ast_visitor*) override;
+};
+
+class call_function: public call {
+private:
+    std::vector<expr*> args;
+
+public:
+    call_function(const span& location):
+        call(location, expr_type::ast_callf) {}
+    ~call_function() override;
+    void add_argument(expr* node) {args.push_back(node);}
+    std::vector<expr*>& get_argument() {return args;}
+    void accept(ast_visitor*) override;
+};
+
+class slice_vector: public expr {
+private:
+    expr* begin;
+    expr* end;
+
+public:
+    slice_vector(const span& location):
+        expr(location, expr_type::ast_subvec),
+        begin(nullptr), end(nullptr) {}
+    ~slice_vector() override;
+    void set_begin(expr* node) {begin = node;}
+    void set_end(expr* node) {end = node;}
+    expr* get_begin() {return begin;}
+    expr* get_end() {return end;}
+    void accept(ast_visitor*) override;
+};
+
+class definition_expr: public expr {
+private:
+    identifier* variable_name;
+    multi_identifier* variables;
+    tuple_expr* tuple;
+    expr* value;
+
+public:
+    definition_expr(const span& location):
+        expr(location, expr_type::ast_def),
+        variable_name(nullptr), variables(nullptr),
+        tuple(nullptr), value(nullptr) {}
+    ~definition_expr() override;
+    void set_identifier(identifier* node) {variable_name = node;}
+    void set_multi_define(multi_identifier* node) {variables = node;}
+    void set_tuple(tuple_expr* node) {tuple = node;}
+    void set_value(expr* node) {value = node;}
+    identifier* get_variable_name() {return variable_name;}
+    multi_identifier* get_variables() {return variables;}
+    tuple_expr* get_tuple() {return tuple;}
+    expr* get_value() {return value;}
+    void accept(ast_visitor*) override;
+};
+
+class assignment_expr: public expr {
+public:
+    enum class kind {
+        equal,
+        add_equal,
+        sub_equal,
+        mult_equal,
+        div_equal,
+        concat_equal,
+        bitwise_and_equal,
+        bitwise_or_equal,
+        bitwise_xor_equal
+    };
+
+private:
+    kind type;
+    expr* left;
+    expr* right;
+
+public:
+    assignment_expr(const span& location):
+        expr(location, expr_type::ast_assign),
+        left(nullptr), right(nullptr) {}
+    ~assignment_expr() override;
+    void set_assignment_type(kind operator_type) {type = operator_type;}
+    void set_left(expr* node) {left = node;}
+    void set_right(expr* node) {right = node;}
+    auto get_assignment_type() const {return type;}
+    auto get_left() {return left;}
+    auto get_right() {return right;}
+    void accept(ast_visitor*) override;
+};
+
+class multi_identifier: public expr {
+private:
+    std::vector<identifier*> variables;
+
+public:
+    multi_identifier(const span& location):
+        expr(location, expr_type::ast_multi_id) {}
+    ~multi_identifier() override;
+    void add_var(identifier* node) {variables.push_back(node);}
+    std::vector<identifier*>& get_variables() {return variables;}
+    void accept(ast_visitor*) override;
+};
+
+class tuple_expr: public expr {
+private:
+    std::vector<expr*> elements;
+
+public:
+    tuple_expr(const span& location):
+        expr(location, expr_type::ast_tuple) {}
+    ~tuple_expr() override;
+    void add_element(expr* node) {elements.push_back(node);}
+    std::vector<expr*>& get_elements() {return elements;}
+    void accept(ast_visitor*) override;
+};
+
+class multi_assign: public expr {
+private:
+    tuple_expr* tuple;
+    expr* value;
+
+public:
+    multi_assign(const span& location):
+        expr(location, expr_type::ast_multi_assign),
+        tuple(nullptr), value(nullptr) {}
+    ~multi_assign() override;
+    void set_tuple(tuple_expr* node) {tuple = node;}
+    void set_value(expr* node) {value = node;}
+    tuple_expr* get_tuple() {return tuple;}
+    expr* get_value() {return value;}
+    void accept(ast_visitor*) override;
+};
+
+class while_expr: public expr {
+private:
+    expr* condition;
+    code_block* block;
+
+public:
+    while_expr(const span& location):
+        expr(location, expr_type::ast_while),
+        condition(nullptr), block(nullptr) {}
+    ~while_expr() override;
+    void set_condition(expr* node) {condition = node;}
+    void set_code_block (code_block* node) {block = node;}
+    expr* get_condition() {return condition;}
+    code_block* get_code_block() {return block;}
+    void accept(ast_visitor*) override;
+};
+
+class for_expr: public expr {
+private:
+    expr* initializing;
+    expr* condition;
+    expr* step;
+    code_block* block;
+
+public:
+    for_expr(const span& location):
+        expr(location, expr_type::ast_for),
+        initializing(nullptr), condition(nullptr),
+        step(nullptr), block(nullptr) {}
+    ~for_expr() override;
+    void set_initial(expr* node) {initializing = node;}
+    void set_condition(expr* node) {condition = node;}
+    void set_step(expr* node) {step = node;}
+    void set_code_block(code_block* node) {block = node;}
+    expr* get_initial() {return initializing;}
+    expr* get_condition() {return condition;}
+    expr* get_step() {return step;}
+    code_block* get_code_block() {return block;}
+    void accept(ast_visitor*) override;
+};
+
+class iter_expr: public expr {
+private:
+    bool is_iterator_definition;
+    identifier* name;
+    call_expr* call;
+
+public:
+    iter_expr(const span& location):
+        expr(location, expr_type::ast_iter),
+        is_iterator_definition(false),
+        name(nullptr), call(nullptr) {}
+    ~iter_expr() override;
+    void set_name(identifier* node) {name = node;}
+    void set_call(call_expr* node) {call = node;}
+    void set_is_definition(bool flag) {is_iterator_definition = flag;}
+    identifier* get_name() {return name;}
+    call_expr* get_call() {return call;}
+    bool is_definition() const {return is_iterator_definition;}
+    void accept(ast_visitor*) override;
+};
+
+class forei_expr: public expr {
+public:
+    enum class kind {
+        foreach,
+        forindex
+    };
+
+private:
+    kind type;
+    iter_expr* iterator;
+    expr* vector_node;
+    code_block* block;
+
+public:
+    forei_expr(const span& location):
+        expr(location, expr_type::ast_forei),
+        type(kind::foreach), iterator(nullptr),
+        vector_node(nullptr), block(nullptr) {}
+    ~forei_expr() override;
+    void set_loop_type(kind ft) {type = ft;}
+    void set_iterator(iter_expr* node) {iterator = node;}
+    void set_value(expr* node) {vector_node = node;}
+    void set_code_block(code_block* node) {block = node;}
+    auto get_loop_type() const {return type;}
+    auto get_iterator() {return iterator;}
+    auto get_value() {return vector_node;}
+    auto get_code_block() {return block;}
+    void accept(ast_visitor*) override;
+};
+
+class condition_expr: public expr {
+private:
+    if_expr* if_stmt;
+    std::vector<if_expr*> elsif_stmt;
+    if_expr* else_stmt;
+
+public:
+    condition_expr(const span& location):
+        expr(location, expr_type::ast_cond),
+        if_stmt(nullptr), else_stmt(nullptr) {}
+    ~condition_expr() override;
+    void set_if_statement(if_expr* node) {if_stmt = node;}
+    void add_elsif_statement(if_expr* node) {elsif_stmt.push_back(node);}
+    void set_else_statement(if_expr* node) {else_stmt = node;}
+    if_expr* get_if_statement() {return if_stmt;}
+    std::vector<if_expr*>& get_elsif_stataments() {return elsif_stmt;}
+    if_expr* get_else_statement() {return else_stmt;}
+    void accept(ast_visitor*) override;
+};
+
+class if_expr: public expr {
+private:
+    expr* condition;
+    code_block* block;
+
+public:
+    if_expr(const span& location):
+        expr(location, expr_type::ast_if),
+        condition(nullptr), block(nullptr) {}
+    ~if_expr() override;
+    void set_condition(expr* node) {condition = node;}
+    void set_code_block(code_block* node) {block = node;}
+    expr* get_condition() {return condition;}
+    code_block* get_code_block() {return block;}
+    void accept(ast_visitor*) override;
+};
+
+class continue_expr: public expr {
+public:
+    continue_expr(const span& location):
+        expr(location, expr_type::ast_continue) {}
+    ~continue_expr() override = default;
+    void accept(ast_visitor*) override;
+};
+
+class break_expr: public expr {
+public:
+    break_expr(const span& location):
+        expr(location, expr_type::ast_break) {}
+    ~break_expr() = default;
+    void accept(ast_visitor*) override;
+};
+
+class return_expr: public expr {
+private:
+    expr* value;
+
+public:
+    return_expr(const span& location):
+        expr(location, expr_type::ast_ret),
+        value(nullptr) {}
+    ~return_expr() override;
+    void set_value(expr* node) {value = node;}
+    expr* get_value() {return value;}
+    void accept(ast_visitor*) override;
+};
+
+}

src/ast/ast_dumper.cpp

@@ -0,0 +1,518 @@
+#include "ast_dumper.h"
+#include "util/util.h"
+
+#include <iostream>
+
+namespace nasal {
+
+bool ast_dumper::visit_use_stmt(use_stmt* node) {
+    dump_indent();
+    std::cout << "use" << format_location(node);
+    push_indent();
+    for (auto i : node->get_path()) {
+        if (i==node->get_path().back()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_null_expr(null_expr* node) {
+    dump_indent();
+    std::cout << "null" << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_nil_expr(nil_expr* node) {
+    dump_indent();
+    std::cout << "nil" << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_number_literal(number_literal* node) {
+    dump_indent();
+    std::cout << "number " << node->get_number();
+    std::cout << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_string_literal(string_literal* node) {
+    dump_indent();
+    std::cout << "string \"" << util::rawstr(node->get_content()) << "\"";
+    std::cout << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_identifier(identifier* node) {
+    dump_indent();
+    std::cout << "identifier " << node->get_name();
+    std::cout << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_bool_literal(bool_literal* node) {
+    dump_indent();
+    std::cout << "bool " << node->get_flag();
+    std::cout << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_vector_expr(vector_expr* node) {
+    dump_indent();
+    std::cout << "vector";
+    std::cout << format_location(node);
+    push_indent();
+    for (auto i : node->get_elements()) {
+        if (i==node->get_elements().back()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_hash_expr(hash_expr* node) {
+    dump_indent();
+    std::cout << "hash";
+    std::cout << format_location(node);
+    push_indent();
+    for (auto i : node->get_members()) {
+        if (i==node->get_members().back()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_hash_pair(hash_pair* node) {
+    dump_indent();
+    std::cout << "pair " << node->get_name();
+    std::cout << format_location(node);
+    if (node->get_value()) {
+        push_indent();
+        set_last();
+        node->get_value()->accept(this);
+        pop_indent();
+    }
+    return true;
+}
+
+bool ast_dumper::visit_function(function* node) {
+    dump_indent();
+    std::cout << "function";
+    std::cout << format_location(node);
+    push_indent();
+    for (auto i : node->get_parameter_list()) {
+        i->accept(this);
+    }
+    set_last();
+    node->get_code_block()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_code_block(code_block* node) {
+    dump_indent();
+    std::cout << "block";
+    std::cout << format_location(node);
+    push_indent();
+    for (auto i : node->get_expressions()) {
+        if (i==node->get_expressions().back()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_parameter(parameter* node) {
+    dump_indent();
+    std::cout << "parameter ";
+    switch(node->get_parameter_type()) {
+        case parameter::kind::normal_parameter: std::cout << "[normal]"; break;
+        case parameter::kind::dynamic_parameter: std::cout << "[dynamic]"; break;
+        case parameter::kind::default_parameter: std::cout << "[default]"; break;
+    }
+    std::cout << " " << node->get_parameter_name();
+    std::cout << format_location(node);
+    if (node->get_default_value()) {
+        push_indent();
+        set_last();
+        node->get_default_value()->accept(this);
+        pop_indent();
+    }
+    return true;
+}
+
+bool ast_dumper::visit_ternary_operator(ternary_operator* node) {
+    dump_indent();
+    std::cout << "ternary_operator";
+    std::cout << format_location(node);
+    push_indent();
+    node->get_condition()->accept(this);
+    node->get_left()->accept(this);
+    set_last();
+    node->get_right()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_binary_operator(binary_operator* node) {
+    if (node->get_optimized_number()) {
+        node->get_optimized_number()->accept(this);
+        return true;
+    }
+    if (node->get_optimized_string()) {
+        node->get_optimized_string()->accept(this);
+        return true;
+    }
+    dump_indent();
+    std::cout << "binary_operator \"";
+    switch(node->get_operator_type()) {
+        case binary_operator::kind::add: std::cout << "+"; break;
+        case binary_operator::kind::sub: std::cout << "-"; break;
+        case binary_operator::kind::mult: std::cout << "*"; break;
+        case binary_operator::kind::div: std::cout << "/"; break;
+        case binary_operator::kind::concat: std::cout << "~"; break;
+        case binary_operator::kind::bitwise_and: std::cout << "&"; break;
+        case binary_operator::kind::bitwise_or: std::cout << "|"; break;
+        case binary_operator::kind::bitwise_xor: std::cout << "^"; break;
+        case binary_operator::kind::cmpeq: std::cout << "=="; break;
+        case binary_operator::kind::cmpneq: std::cout << "!="; break;
+        case binary_operator::kind::grt: std::cout << ">"; break;
+        case binary_operator::kind::geq: std::cout << ">="; break;
+        case binary_operator::kind::less: std::cout << "<"; break;
+        case binary_operator::kind::leq: std::cout << "<="; break;
+        case binary_operator::kind::condition_and: std::cout << "and"; break;
+        case binary_operator::kind::condition_or: std::cout << "or"; break;
+        case binary_operator::kind::null_chain: std::cout << "??"; break;
+    }
+    std::cout << "\"" << format_location(node);
+    push_indent();
+    node->get_left()->accept(this);
+    set_last();
+    node->get_right()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_unary_operator(unary_operator* node) {
+    if (node->get_optimized_number()) {
+        node->get_optimized_number()->accept(this);
+        return true;
+    }
+    dump_indent();
+    std::cout << "unary_operator \"";
+    switch(node->get_operator_type()) {
+        case unary_operator::kind::negative: std::cout << "-"; break;
+        case unary_operator::kind::logical_not: std::cout << "!"; break;
+        case unary_operator::kind::bitwise_not: std::cout << "~"; break;
+    }
+    std::cout << "\"" << format_location(node);
+    push_indent();
+    set_last();
+    node->get_value()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_call_expr(call_expr* node) {
+    dump_indent();
+    std::cout << "call_expr";
+    std::cout << format_location(node);
+    push_indent();
+    if (!node->get_calls().size()) {
+        set_last();
+    }
+    node->get_first()->accept(this);
+    for (auto i : node->get_calls()) {
+        if (i==node->get_calls().back()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_call_hash(call_hash* node) {
+    dump_indent();
+    std::cout << "call_hash " << node->get_field();
+    std::cout << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_null_access(null_access* node) {
+    dump_indent();
+    std::cout << "null_access " << node->get_field();
+    std::cout << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_call_vector(call_vector* node) {
+    dump_indent();
+    std::cout << "call_vector";
+    std::cout << format_location(node);
+    push_indent();
+    for (auto i : node->get_slices()) {
+        if (i==node->get_slices().back()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_call_function(call_function* node) {
+    dump_indent();
+    std::cout << "call_function";
+    std::cout << format_location(node);
+    push_indent();
+    for (auto i : node->get_argument()) {
+        if (i==node->get_argument().back()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_slice_vector(slice_vector* node) {
+    dump_indent();
+    std::cout << "slice";
+    std::cout << format_location(node);
+    push_indent();
+    if (!node->get_end()) {
+        set_last();
+    }
+    node->get_begin()->accept(this);
+    if (node->get_end()) {
+        set_last();
+        node->get_end()->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_definition_expr(definition_expr* node) {
+    dump_indent();
+    std::cout << "definition";
+    std::cout << format_location(node);
+    push_indent();
+    if (node->get_variable_name()) {
+        node->get_variable_name()->accept(this);
+    } else {
+        node->get_variables()->accept(this);
+    }
+    set_last();
+    if (node->get_tuple()) {
+        node->get_tuple()->accept(this);
+    } else {
+        node->get_value()->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_assignment_expr(assignment_expr* node) {
+    dump_indent();
+    std::cout << "assignment ";
+    switch(node->get_assignment_type()) {
+        case assignment_expr::kind::add_equal: std::cout << "+="; break;
+        case assignment_expr::kind::sub_equal: std::cout << "-="; break;
+        case assignment_expr::kind::mult_equal: std::cout << "*="; break;
+        case assignment_expr::kind::div_equal: std::cout << "/="; break;
+        case assignment_expr::kind::concat_equal: std::cout << "~="; break;
+        case assignment_expr::kind::equal: std::cout << "="; break;
+        case assignment_expr::kind::bitwise_and_equal: std::cout << "&="; break;
+        case assignment_expr::kind::bitwise_or_equal: std::cout << "|="; break;
+        case assignment_expr::kind::bitwise_xor_equal: std::cout << "^="; break;
+    }
+    std::cout << format_location(node);
+    push_indent();
+    node->get_left()->accept(this);
+    set_last();
+    node->get_right()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_multi_identifier(multi_identifier* node) {
+    dump_indent();
+    std::cout << "multiple_identifier";
+    std::cout << format_location(node);
+    push_indent();
+    for (auto i : node->get_variables()) {
+        if (i==node->get_variables().back()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_tuple_expr(tuple_expr* node) {
+    dump_indent();
+    std::cout << "tuple";
+    std::cout << format_location(node);
+    push_indent();
+    for (auto i : node->get_elements()) {
+        if (i==node->get_elements().back()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_multi_assign(multi_assign* node) {
+    dump_indent();
+    std::cout << "multiple_assignment";
+    std::cout << format_location(node);
+    push_indent();
+    node->get_tuple()->accept(this);
+    set_last();
+    node->get_value()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_while_expr(while_expr* node) {
+    dump_indent();
+    std::cout << "while";
+    std::cout << format_location(node);
+    push_indent();
+    node->get_condition()->accept(this);
+    set_last();
+    node->get_code_block()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_for_expr(for_expr* node) {
+    dump_indent();
+    std::cout << "for";
+    std::cout << format_location(node);
+    push_indent();
+    node->get_initial()->accept(this);
+    node->get_condition()->accept(this);
+    node->get_step()->accept(this);
+    set_last();
+    node->get_code_block()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_iter_expr(iter_expr* node) {
+    dump_indent();
+    if (node->is_definition()) {
+        std::cout << "iterator_definition";
+    } else {
+        std::cout << "iterator";
+    }
+    std::cout << format_location(node);
+    push_indent();
+    set_last();
+    if (node->get_name()) {
+        node->get_name()->accept(this);
+    } else {
+        node->get_call()->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_forei_expr(forei_expr* node) {
+    dump_indent();
+    if (node->get_loop_type()==forei_expr::kind::foreach) {
+        std::cout << "foreach";
+    } else {
+        std::cout << "forindex";
+    }
+    std::cout << format_location(node);
+    push_indent();
+    node->get_iterator()->accept(this);
+    node->get_value()->accept(this);
+    set_last();
+    node->get_code_block()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_condition_expr(condition_expr* node) {
+    dump_indent();
+    std::cout << "condition";
+    std::cout << format_location(node);
+    push_indent();
+    if (!node->get_elsif_stataments().size() &&
+        !node->get_else_statement()) {
+        set_last();
+    }
+    node->get_if_statement()->accept(this);
+    for (auto i : node->get_elsif_stataments()) {
+        if (i==node->get_elsif_stataments().back() &&
+            !node->get_else_statement()) {
+            set_last();
+        }
+        i->accept(this);
+    }
+    if (node->get_else_statement()) {
+        set_last();
+        node->get_else_statement()->accept(this);
+    }
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_if_expr(if_expr* node) {
+    dump_indent();
+    std::cout << "if";
+    std::cout << format_location(node);
+    push_indent();
+    if (node->get_condition()) {
+        node->get_condition()->accept(this);
+    }
+    set_last();
+    node->get_code_block()->accept(this);
+    pop_indent();
+    return true;
+}
+
+bool ast_dumper::visit_continue_expr(continue_expr* node) {
+    dump_indent();
+    std::cout << "continue";
+    std::cout << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_break_expr(break_expr* node) {
+    dump_indent();
+    std::cout << "break";
+    std::cout << format_location(node);
+    return true;
+}
+
+bool ast_dumper::visit_return_expr(return_expr* node) {
+    dump_indent();
+    std::cout << "return";
+    std::cout << format_location(node);
+    if (node->get_value()) {
+        push_indent();
+        set_last();
+        node->get_value()->accept(this);
+        pop_indent();
+    }
+    return true;
+}
+
+}

src/ast/ast_dumper.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include "ast_visitor.h"
+#include "util/util.h"
+
+#include <iostream>
+#include <cstring>
+#include <sstream>
+#include <vector>
+
+namespace nasal {
+
+class ast_dumper: public ast_visitor {
+private:
+    std::vector<std::string> indent;
+
+private:
+    void push_indent() {
+        if (indent.size()) {
+            if (indent.back()=="├──") {
+                indent.back() = "│  ";
+            } else if (indent.back()=="╰──") {
+                indent.back() = "   ";
+            }
+        }
+        indent.push_back("├──");
+    }
+
+    void pop_indent() {
+        indent.pop_back();
+    }
+
+    void set_last() {
+        indent.back() = "╰──";
+    }
+
+    void dump_indent() {
+        if (indent.size() && indent.back()=="│  ") {
+            indent.back() = "├──";
+        }
+        for (const auto& i : indent) {
+            std::cout << i;
+        }
+    }
+
+    std::string format_location(expr* node) {
+        std::stringstream ss;
+        ss << " ⇒ [";
+        node->get_location().dump_begin(ss);
+        ss << "]\n";
+        return ss.str();
+    }
+
+public:
+    bool visit_use_stmt(use_stmt*) override;
+    bool visit_null_expr(null_expr*) override;
+    bool visit_nil_expr(nil_expr*) override;
+    bool visit_number_literal(number_literal*) override;
+    bool visit_string_literal(string_literal*) override;
+    bool visit_identifier(identifier*) override;
+    bool visit_bool_literal(bool_literal*) override;
+    bool visit_vector_expr(vector_expr*) override;
+    bool visit_hash_expr(hash_expr*) override;
+    bool visit_hash_pair(hash_pair*) override;
+    bool visit_function(function*) override;
+    bool visit_code_block(code_block*) override;
+    bool visit_parameter(parameter*) override;
+    bool visit_ternary_operator(ternary_operator*) override;
+    bool visit_binary_operator(binary_operator*) override;
+    bool visit_unary_operator(unary_operator*) override;
+    bool visit_call_expr(call_expr*) override;
+    bool visit_call_hash(call_hash*) override;
+    bool visit_null_access(null_access*) override;
+    bool visit_call_vector(call_vector*) override;
+    bool visit_call_function(call_function*) override;
+    bool visit_slice_vector(slice_vector*) override;
+    bool visit_definition_expr(definition_expr*) override;
+    bool visit_assignment_expr(assignment_expr*) override;
+    bool visit_multi_identifier(multi_identifier*) override;
+    bool visit_tuple_expr(tuple_expr*) override;
+    bool visit_multi_assign(multi_assign*) override;
+    bool visit_while_expr(while_expr*) override;
+    bool visit_for_expr(for_expr*) override;
+    bool visit_iter_expr(iter_expr*) override;
+    bool visit_forei_expr(forei_expr*) override;
+    bool visit_condition_expr(condition_expr*) override;
+    bool visit_if_expr(if_expr*) override;
+    bool visit_continue_expr(continue_expr*) override;
+    bool visit_break_expr(break_expr*) override;
+    bool visit_return_expr(return_expr*) override;
+
+public:
+    void dump(code_block* root) {
+        util::windows_code_page_manager wm;
+        wm.set_utf8_output();
+        root->accept(this);
+        wm.restore_code_page();
+    }
+};
+
+}

src/ast/ast_format.cpp

@@ -0,0 +1,427 @@
+#include "ast_format.h"
+#include "util/util.h"
+
+#include <iostream>
+
+namespace nasal {
+
+bool ast_format::visit_use_stmt(use_stmt* node) {
+    dump_formating_node_info(node, "use statement");
+    out << "use ";
+    for (auto i : node->get_path()) {
+        i->accept(this);
+        if (i != node->get_path().back()) {
+            out << ".";
+        }
+    }
+    return true;
+}
+
+bool ast_format::visit_null_expr(null_expr* node) {
+    dump_formating_node_info(node, "null expression");
+    return true;
+}
+
+bool ast_format::visit_nil_expr(nil_expr* node) {
+    dump_formating_node_info(node, "nil expression");
+    out << "nil";
+    return true;
+}
+
+bool ast_format::visit_number_literal(number_literal* node) {
+    dump_formating_node_info(node, "number expression");
+    out << node->get_raw_text();
+    return true;
+}
+
+bool ast_format::visit_string_literal(string_literal* node) {
+    dump_formating_node_info(node, "string expression");
+    out << "\"" << util::rawstr(node->get_content()) << "\"";
+    return true;
+}
+
+bool ast_format::visit_identifier(identifier* node) {
+    dump_formating_node_info(node, "identifier");
+    out << node->get_name();
+    return true;
+}
+
+bool ast_format::visit_bool_literal(bool_literal* node) {
+    dump_formating_node_info(node, "bool expression");
+    out << (node->get_flag()? "true" : "false");
+    return true;
+}
+
+bool ast_format::visit_vector_expr(vector_expr* node) {
+    dump_formating_node_info(node, "vector expression");
+    out << "[";
+    for (auto i : node->get_elements()) {
+        i->accept(this);
+        if (i != node->get_elements().back()) {
+            out << ", ";
+        }
+    }
+    out << "]";
+    return true;
+}
+
+bool ast_format::visit_hash_expr(hash_expr* node) {
+    dump_formating_node_info(node, "hash expression");
+    out << "{";
+    for (auto i : node->get_members()) {
+        i->accept(this);
+        if (i != node->get_members().back()) {
+            out << ", ";
+        }
+    }
+    out << "}";
+    return true;
+}
+
+bool ast_format::visit_hash_pair(hash_pair* node) {
+    dump_formating_node_info(node, "hash pair");
+    bool contain_not_identifier = false;
+    for (auto c : node->get_name()) {
+        if (!(std::isdigit(c) || std::isalpha(c) || c == '_')) {
+            contain_not_identifier = true;
+        }
+    }
+    if (contain_not_identifier) {
+        out << "\"" << node->get_name() << "\"";
+    } else {
+        out << node->get_name();
+    }
+    if (node->get_value()) {
+        out << " : ";
+        node->get_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_format::visit_function(function* node) {
+    dump_formating_node_info(node, "function");
+    out << "func(";
+    for (auto i : node->get_parameter_list()) {
+        i->accept(this);
+        if (i != node->get_parameter_list().back()) {
+            out << ", ";
+        }
+    }
+    out << ") ";
+    if (node->get_code_block()->get_expressions().empty()) {
+        out << "{}";
+        return true;
+    }
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_format::visit_code_block(code_block* node) {
+    dump_formating_node_info(node, "code block");
+    out << "{\n";
+    push_indent();
+    for (auto i : node->get_expressions()) {
+        dump_indent();
+        i->accept(this);
+        if (need_dump_semi(i)) {
+            out << ";\n";
+        } else {
+            out << "\n";
+        }
+    }
+    pop_indent();
+    dump_indent();
+    out << "}";
+    return true;
+}
+
+bool ast_format::visit_parameter(parameter* node) {
+    dump_formating_node_info(node, "parameter");
+    out << node->get_parameter_name();
+    switch (node->get_parameter_type()) {
+        case parameter::kind::normal_parameter: break;
+        case parameter::kind::dynamic_parameter: out << "..."; break;
+        case parameter::kind::default_parameter: out << " = "; break;
+    }
+    if (node->get_default_value()) {
+        node->get_default_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_format::visit_ternary_operator(ternary_operator* node) {
+    dump_formating_node_info(node, "ternary operator");
+    out << "(";
+    node->get_condition()->accept(this);
+    out << " ? ";
+    node->get_left()->accept(this);
+    out << " : ";
+    node->get_right()->accept(this);
+    out << ")";
+    return true;
+}
+
+bool ast_format::visit_binary_operator(binary_operator* node) {
+    dump_formating_node_info(node, "binary operator");
+    out << "(";
+    node->get_left()->accept(this);
+    switch(node->get_operator_type()) {
+        case binary_operator::kind::add: out << " + "; break;
+        case binary_operator::kind::sub: out << " - "; break;
+        case binary_operator::kind::mult: out << " * "; break;
+        case binary_operator::kind::div: out << " / "; break;
+        case binary_operator::kind::concat: out << " ~ "; break;
+        case binary_operator::kind::bitwise_and: out << " & "; break;
+        case binary_operator::kind::bitwise_or: out << " | "; break;
+        case binary_operator::kind::bitwise_xor: out << " ^ "; break;
+        case binary_operator::kind::cmpeq: out << " == "; break;
+        case binary_operator::kind::cmpneq: out << " != "; break;
+        case binary_operator::kind::grt: out << " > "; break;
+        case binary_operator::kind::geq: out << " >= "; break;
+        case binary_operator::kind::less: out << " < "; break;
+        case binary_operator::kind::leq: out << " <= "; break;
+        case binary_operator::kind::condition_and: out << " and "; break;
+        case binary_operator::kind::condition_or: out << " or "; break;
+        case binary_operator::kind::null_chain: out << " ?? "; break;
+    }
+    node->get_right()->accept(this);
+    out << ")";
+    return true;
+}
+
+bool ast_format::visit_unary_operator(unary_operator* node) {
+    dump_formating_node_info(node, "unary operator");
+    switch(node->get_operator_type()) {
+        case unary_operator::kind::negative: out << "-"; break;
+        case unary_operator::kind::logical_not: out << "!"; break;
+        case unary_operator::kind::bitwise_not: out << "~"; break;
+    }
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_format::visit_call_expr(call_expr* node) {
+    dump_formating_node_info(node, "call expression");
+    node->get_first()->accept(this);
+    for (auto i : node->get_calls()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_format::visit_call_hash(call_hash* node) {
+    dump_formating_node_info(node, "call hash");
+    out << "." << node->get_field();
+    return true;
+}
+
+bool ast_format::visit_null_access(null_access* node) {
+    dump_formating_node_info(node, "null access operator(?.)");
+    out << "?." << node->get_field();
+    return true;
+}
+
+bool ast_format::visit_call_vector(call_vector* node) {
+    dump_formating_node_info(node, "call vector");
+    out << "[";
+    for (auto i : node->get_slices()) {
+        i->accept(this);
+        if (i != node->get_slices().back()) {
+            out << ", ";
+        }
+    }
+    out << "]";
+    return true;
+}
+
+bool ast_format::visit_call_function(call_function* node) {
+    dump_formating_node_info(node, "call function");
+    out << "(";
+    for (auto i : node->get_argument()) {
+        i->accept(this);
+        if (i != node->get_argument().back()) {
+            out << ", ";
+        }
+    }
+    out << ")";
+    return true;
+}
+
+bool ast_format::visit_slice_vector(slice_vector* node) {
+    dump_formating_node_info(node, "slice vector");
+    node->get_begin()->accept(this);
+    if (node->get_end()) {
+        out << " : ";
+        node->get_end()->accept(this);
+    }
+    return true;
+}
+
+bool ast_format::visit_definition_expr(definition_expr* node) {
+    dump_formating_node_info(node, "definition");
+    out << "var ";
+    if (node->get_variable_name()) {
+        node->get_variable_name()->accept(this);
+    } else {
+        node->get_variables()->accept(this);
+    }
+    out << " = ";
+    if (node->get_tuple()) {
+        node->get_tuple()->accept(this);
+    } else {
+        node->get_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_format::visit_assignment_expr(assignment_expr* node) {
+    dump_formating_node_info(node, "assignment");
+    node->get_left()->accept(this);
+    switch(node->get_assignment_type()) {
+        case assignment_expr::kind::add_equal: out << " += "; break;
+        case assignment_expr::kind::sub_equal: out << " -= "; break;
+        case assignment_expr::kind::mult_equal: out << " *= "; break;
+        case assignment_expr::kind::div_equal: out << " /= "; break;
+        case assignment_expr::kind::concat_equal: out << " ~= "; break;
+        case assignment_expr::kind::equal: out << " = "; break;
+        case assignment_expr::kind::bitwise_and_equal: out << " &= "; break;
+        case assignment_expr::kind::bitwise_or_equal: out << " |= "; break;
+        case assignment_expr::kind::bitwise_xor_equal: out << " ^= "; break;
+    }
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_format::visit_multi_identifier(multi_identifier* node) {
+    dump_formating_node_info(node, "multi identifier");
+    out << "(";
+    for (auto i : node->get_variables()) {
+        i->accept(this);
+        if (i != node->get_variables().back()) {
+            out << ", ";
+        }
+    }
+    out << ")";
+    return true;
+}
+
+bool ast_format::visit_tuple_expr(tuple_expr* node) {
+    dump_formating_node_info(node, "tuple expression");
+    out << "(";
+    for (auto i : node->get_elements()) {
+        i->accept(this);
+        if (i != node->get_elements().back()) {
+            out << ", ";
+        }
+    }
+    out << ")";
+    return true;
+}
+
+bool ast_format::visit_multi_assign(multi_assign* node) {
+    dump_formating_node_info(node, "multi assign");
+    node->get_tuple()->accept(this);
+    out << " = ";
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_format::visit_while_expr(while_expr* node) {
+    dump_formating_node_info(node, "while statement");
+    out << "while (";
+    node->get_condition()->accept(this);
+    out << ") ";
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_format::visit_for_expr(for_expr* node) {
+    dump_formating_node_info(node, "for statement");
+    out << "for (";
+    node->get_initial()->accept(this);
+    out << "; ";
+    node->get_condition()->accept(this);
+    out << "; ";
+    node->get_step()->accept(this);
+    out << ") ";
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_format::visit_iter_expr(iter_expr* node) {
+    dump_formating_node_info(node, "iteration expression");
+    if (node->is_definition()) {
+        out << "var ";
+    }
+    if (node->get_name()) {
+        node->get_name()->accept(this);
+    } else {
+        node->get_call()->accept(this);
+    }
+    return true;
+}
+
+bool ast_format::visit_forei_expr(forei_expr* node) {
+    dump_formating_node_info(node, "forindex/foreach statement");
+    if (node->get_loop_type()==forei_expr::kind::foreach) {
+        out << "foreach ";
+    } else {
+        out << "forindex ";
+    }
+    out << "(";
+    node->get_iterator()->accept(this);
+    out << "; ";
+    node->get_value()->accept(this);
+    out << ") ";
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_format::visit_condition_expr(condition_expr* node) {
+    dump_formating_node_info(node, "condition statement");
+    out << "if ";
+    node->get_if_statement()->accept(this);
+    for (auto i : node->get_elsif_stataments()) {
+        out << " elsif ";
+        i->accept(this);
+    }
+    if (node->get_else_statement()) {
+        out << " else ";
+        node->get_else_statement()->accept(this);
+    }
+    return true;
+}
+
+bool ast_format::visit_if_expr(if_expr* node) {
+    dump_formating_node_info(node, "if statement");
+    if (node->get_condition()) {
+        out << "(";
+        node->get_condition()->accept(this);
+        out << ") ";
+    }
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_format::visit_continue_expr(continue_expr* node) {
+    dump_formating_node_info(node, "continue statement");
+    out << "continue";
+    return true;
+}
+
+bool ast_format::visit_break_expr(break_expr* node) {
+    dump_formating_node_info(node, "break statement");
+    out << "break";
+    return true;
+}
+
+bool ast_format::visit_return_expr(return_expr* node) {
+    dump_formating_node_info(node, "return statement");
+    out << "return ";
+    if (node->get_value()) {
+        node->get_value()->accept(this);
+    }
+    return true;
+}
+
+}

src/ast/ast_format.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include "ast_visitor.h"
+
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+#include <cstring>
+#include <sstream>
+#include <vector>
+
+namespace nasal {
+
+class ast_format: public ast_visitor {
+private:
+    std::ofstream out;
+    std::vector<std::string> indent;
+
+private:
+    void push_indent() {
+        indent.push_back("  ");
+    }
+    void pop_indent() {
+        if (indent.size()) {
+            indent.pop_back();
+        }
+    }
+    void dump_indent() {
+        for (const auto& i : indent) {
+            out << i;
+        }
+    }
+    void dump_formating_node_info(expr* n, const char* name) {
+        std::cout << "  formating " << name << " @ 0x";
+        std::cout << std::hex << n << std::dec << "\n";
+    }
+    bool need_dump_semi(expr* n) {
+        switch (n->get_type()) {
+            case expr_type::ast_use:
+            case expr_type::ast_null:
+            case expr_type::ast_nil:
+            case expr_type::ast_num:
+            case expr_type::ast_str:
+            case expr_type::ast_bool:
+            case expr_type::ast_vec:
+            case expr_type::ast_hash:
+            case expr_type::ast_call:
+            case expr_type::ast_multi_assign:
+            case expr_type::ast_unary:
+            case expr_type::ast_binary:
+            case expr_type::ast_ternary: return true;
+            case expr_type::ast_def: {
+                auto dn = reinterpret_cast<definition_expr*>(n);
+                if (dn->get_value() &&
+                    dn->get_value()->get_type() == expr_type::ast_func) {
+                    return false;
+                }
+                return true;
+            }
+            case expr_type::ast_assign: {
+                auto dn = reinterpret_cast<assignment_expr*>(n);
+                if (dn->get_right() &&
+                    dn->get_right()->get_type() == expr_type::ast_func) {
+                    return false;
+                }
+                return true;
+            }
+            case expr_type::ast_ret: {
+                auto dn = reinterpret_cast<return_expr*>(n);
+                if (dn->get_value() &&
+                    dn->get_value()->get_type() == expr_type::ast_func) {
+                    return false;
+                }
+                return true;
+            }
+            default: break;
+        }
+
+        return false;
+    }
+
+public:
+    bool visit_use_stmt(use_stmt*) override;
+    bool visit_null_expr(null_expr*) override;
+    bool visit_nil_expr(nil_expr*) override;
+    bool visit_number_literal(number_literal*) override;
+    bool visit_string_literal(string_literal*) override;
+    bool visit_identifier(identifier*) override;
+    bool visit_bool_literal(bool_literal*) override;
+    bool visit_vector_expr(vector_expr*) override;
+    bool visit_hash_expr(hash_expr*) override;
+    bool visit_hash_pair(hash_pair*) override;
+    bool visit_function(function*) override;
+    bool visit_code_block(code_block*) override;
+    bool visit_parameter(parameter*) override;
+    bool visit_ternary_operator(ternary_operator*) override;
+    bool visit_binary_operator(binary_operator*) override;
+    bool visit_unary_operator(unary_operator*) override;
+    bool visit_call_expr(call_expr*) override;
+    bool visit_call_hash(call_hash*) override;
+    bool visit_null_access(null_access*) override;
+    bool visit_call_vector(call_vector*) override;
+    bool visit_call_function(call_function*) override;
+    bool visit_slice_vector(slice_vector*) override;
+    bool visit_definition_expr(definition_expr*) override;
+    bool visit_assignment_expr(assignment_expr*) override;
+    bool visit_multi_identifier(multi_identifier*) override;
+    bool visit_tuple_expr(tuple_expr*) override;
+    bool visit_multi_assign(multi_assign*) override;
+    bool visit_while_expr(while_expr*) override;
+    bool visit_for_expr(for_expr*) override;
+    bool visit_iter_expr(iter_expr*) override;
+    bool visit_forei_expr(forei_expr*) override;
+    bool visit_condition_expr(condition_expr*) override;
+    bool visit_if_expr(if_expr*) override;
+    bool visit_continue_expr(continue_expr*) override;
+    bool visit_break_expr(break_expr*) override;
+    bool visit_return_expr(return_expr*) override;
+
+public:
+    ast_format(const std::string output_file): out(output_file) {
+        if (out.fail()) {
+            throw std::runtime_error("can't open file: " + output_file);
+        }
+    }
+
+    void do_format(code_block* root) {
+        std::cout << "nasal-format is not stable right now, ";
+        std::cout << "take care of source code!\n";
+        dump_formating_node_info(root, "program root");
+        bool is_use_statement = true;
+        for (auto i : root->get_expressions()) {
+            if (is_use_statement && i->get_type() != expr_type::ast_use) {
+                is_use_statement = false;
+                out << "\n";
+            }
+
+            i->accept(this);
+            if (need_dump_semi(i)) {
+                out << ";\n";
+            } else {
+                out << "\n";
+            }
+        }
+    }
+};
+
+}

src/ast/ast_visitor.cpp

@@ -0,0 +1,249 @@
+#include "ast_visitor.h"
+
+namespace nasal {
+
+bool ast_visitor::visit_expr(expr* node) {
+    node->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_use_stmt(use_stmt* node) {
+    for (auto i : node->get_path()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_call(call* node) {
+    node->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_null_expr(null_expr* node) {
+    return true;
+}
+
+bool ast_visitor::visit_nil_expr(nil_expr* node) {
+    return true;
+}
+
+bool ast_visitor::visit_number_literal(number_literal* node) {
+    return true;
+}
+
+bool ast_visitor::visit_string_literal(string_literal* node) {
+    return true;
+}
+
+bool ast_visitor::visit_identifier(identifier* node) {
+    return true;
+}
+
+bool ast_visitor::visit_bool_literal(bool_literal* node) {
+    return true;
+}
+
+bool ast_visitor::visit_vector_expr(vector_expr* node) {
+    for (auto i : node->get_elements()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_hash_expr(hash_expr* node) {
+    for (auto i : node->get_members()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_hash_pair(hash_pair* node) {
+    if (node->get_value()) {
+        node->get_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_function(function* node) {
+    for (auto i : node->get_parameter_list()) {
+        i->accept(this);
+    }
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_code_block(code_block* node) {
+    for (auto i : node->get_expressions()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_parameter(parameter* node) {
+    if (node->get_default_value()) {
+        node->get_default_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_ternary_operator(ternary_operator* node) {
+    node->get_condition()->accept(this);
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_binary_operator(binary_operator* node) {
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_unary_operator(unary_operator* node) {
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_call_expr(call_expr* node) {
+    node->get_first()->accept(this);
+    for (auto i : node->get_calls()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_call_hash(call_hash* node) {
+    return true;
+}
+
+bool ast_visitor::visit_null_access(null_access* node) {
+    return true;
+}
+
+bool ast_visitor::visit_call_vector(call_vector* node) {
+    for (auto i : node->get_slices()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_call_function(call_function* node) {
+    for (auto i : node->get_argument()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_slice_vector(slice_vector* node) {
+    node->get_begin()->accept(this);
+    if (node->get_end()) {
+        node->get_end()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_definition_expr(definition_expr* node) {
+    if (node->get_variable_name()) {
+        node->get_variable_name()->accept(this);
+    } else {
+        node->get_variables()->accept(this);
+    }
+    if (node->get_tuple()) {
+        node->get_tuple()->accept(this);
+    } else {
+        node->get_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_assignment_expr(assignment_expr* node) {
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_multi_identifier(multi_identifier* node) {
+    for (auto i : node->get_variables()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_tuple_expr(tuple_expr* node) {
+    for (auto i : node->get_elements()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_multi_assign(multi_assign* node) {
+    node->get_tuple()->accept(this);
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_while_expr(while_expr* node) {
+    node->get_condition()->accept(this);
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_for_expr(for_expr* node) {
+    node->get_initial()->accept(this);
+    node->get_condition()->accept(this);
+    node->get_step()->accept(this);
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_iter_expr(iter_expr* node) {
+    if (node->get_name()) {
+        node->get_name()->accept(this);
+    } else {
+        node->get_call()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_forei_expr(forei_expr* node) {
+    node->get_iterator()->accept(this);
+    node->get_value()->accept(this);
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_condition_expr(condition_expr* node) {
+    node->get_if_statement()->accept(this);
+    for (auto i : node->get_elsif_stataments()) {
+        i->accept(this);
+    }
+    if (node->get_else_statement()) {
+        node->get_else_statement()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_if_expr(if_expr* node) {
+    if (node->get_condition()) {
+        node->get_condition()->accept(this);
+    }
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_continue_expr(continue_expr* node) {
+    return true;
+}
+
+bool ast_visitor::visit_break_expr(break_expr* node) {
+    return true;
+}
+
+bool ast_visitor::visit_return_expr(return_expr* node) {
+    if (node->get_value()) {
+        node->get_value()->accept(this);
+    }
+    return true;
+}
+
+}

src/ast/ast_visitor.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "ast.h"
+
+namespace nasal {
+
+class ast_visitor {
+public:
+    virtual bool visit_expr(expr*);
+    virtual bool visit_use_stmt(use_stmt*);
+    virtual bool visit_call(call*);
+    virtual bool visit_null_expr(null_expr*);
+    virtual bool visit_nil_expr(nil_expr*);
+    virtual bool visit_number_literal(number_literal*);
+    virtual bool visit_string_literal(string_literal*);
+    virtual bool visit_identifier(identifier*);
+    virtual bool visit_bool_literal(bool_literal*);
+    virtual bool visit_vector_expr(vector_expr*);
+    virtual bool visit_hash_expr(hash_expr*);
+    virtual bool visit_hash_pair(hash_pair*);
+    virtual bool visit_function(function*);
+    virtual bool visit_code_block(code_block*);
+    virtual bool visit_parameter(parameter*);
+    virtual bool visit_ternary_operator(ternary_operator*);
+    virtual bool visit_binary_operator(binary_operator*);
+    virtual bool visit_unary_operator(unary_operator*);
+    virtual bool visit_call_expr(call_expr*);
+    virtual bool visit_call_hash(call_hash*);
+    virtual bool visit_null_access(null_access*);
+    virtual bool visit_call_vector(call_vector*);
+    virtual bool visit_call_function(call_function*);
+    virtual bool visit_slice_vector(slice_vector*);
+    virtual bool visit_definition_expr(definition_expr*);
+    virtual bool visit_assignment_expr(assignment_expr*);
+    virtual bool visit_multi_identifier(multi_identifier*);
+    virtual bool visit_tuple_expr(tuple_expr*);
+    virtual bool visit_multi_assign(multi_assign*);
+    virtual bool visit_while_expr(while_expr*);
+    virtual bool visit_for_expr(for_expr*);
+    virtual bool visit_iter_expr(iter_expr*);
+    virtual bool visit_forei_expr(forei_expr*);
+    virtual bool visit_condition_expr(condition_expr*);
+    virtual bool visit_if_expr(if_expr*);
+    virtual bool visit_continue_expr(continue_expr*);
+    virtual bool visit_break_expr(break_expr*);
+    virtual bool visit_return_expr(return_expr*);
+};
+
+}

src/cli/cli.cpp

@@ -0,0 +1,139 @@
+#include "nasal.h"
+#include "cli/cli.h"
+#include "util/util.h"
+#include "nasal_parse.h"
+
+#include <iostream>
+#include <thread>
+#include <cstdlib>
+#include <ctime>
+
+namespace nasal::cli {
+
+cli_config parse(const std::vector<std::string>& args) {
+    cli_config result;
+
+    for (const auto& arg : args) {
+        if (cli_options.count(arg)) {
+            result.options.insert(cli_options.at(arg));
+        } else if (!result.input_file_path.length()) {
+            result.input_file_path = arg;
+        } else {
+            result.nasal_vm_args.push_back(arg);
+        }
+    }
+
+    if (result.input_file_path.length() && result.options.empty()) {
+        result.options.insert(option::cli_execute);
+    }
+    return result;
+}
+
+std::ostream& help(std::ostream& out) {
+    out
+    << "\n"
+    << "     ,--#-,\n"
+    << "<3  / \\____\\  <3\n"
+    << "    |_|__A_|\n"
+    << "\nnasal <option>\n"
+    << "option:\n"
+    << "   -h,   --help     | get help.\n"
+    << "   -v,   --version  | get version.\n"
+    << "   -r,   --repl     | use repl interpreter.\n"
+    << "\nnasal [option] <file> [argv]\n"
+    << "option:\n"
+    << "   -a,   --ast      | view ast after link/optimize process.\n"
+    << "         --raw-ast  | view ast without after-processing.\n"
+    << "   -c,   --code     | view generated bytecode.\n"
+    << "   -s,   --symbol   | show analysed symbol info.\n"
+    << "   -e,   --exec     | execute directly.\n"
+    << "   -t,   --time     | show execute time.\n"
+    << "   -d,   --detail   | get detail info.\n"
+    << "   -f,   --ref-file | get referenced files.\n"
+    << "   -dbg, --debug    | debug mode.\n"
+    << "         --prof     | show profiling result, "
+    << "available under debug mode.\n"
+    << "         --prof-all | show profiling result of all files, "
+    << "available under debug mode.\n"
+    << "         --limit    | use limited execution mode "
+    << "(readonly api enabled).\n"
+    << "file:\n"
+    << "   <filename>       | execute file.\n"
+    << "argv:\n"
+    << "   <args>           | cmd arguments used in program.\n"
+    << "\n";
+    return out;
+}
+
+std::ostream& nasal_format_help(std::ostream& out) {
+    out
+    << "\n"
+    << "     ,--#-,\n"
+    << "<3  / \\____\\  <3\n"
+    << "    |_|__A_|\n"
+    << "\nnasal-format <option>\n"
+    << "option:\n"
+    << "   -h,   --help     | get help.\n"
+    << "   -v,   --version  | get version.\n"
+    << "\nnasal-format <file>\n"
+    << "file:\n"
+    << "   <filename>       | file to be formatted.\n"
+    << "\n";
+    return out;
+}
+
+std::ostream& logo(std::ostream& out) {
+    out
+    << "\n"
+    << "       __                _\n"
+    << "    /\\ \\ \\__ _ ___  __ _| |\n"
+    << "   /  \\/ / _` / __|/ _` | |\n"
+    << "  / /\\  / (_| \\__ \\ (_| | |\n"
+    << "  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
+    << "\n"
+    << "ver  : " << __nasver__
+    << " " << nasal::util::get_platform()
+    << " " << nasal::util::get_arch()
+    << " (" << __DATE__ << " " << __TIME__ << ")\n"
+    << "std  : c++ " << __cplusplus << "\n"
+    << "core : " << std::thread::hardware_concurrency() << " core(s)\n"
+    << "repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
+    << "repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
+    << "wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
+    << "\n"
+    << "presented by fgprc members:\n"
+    << " - http://fgprc.org\n"
+    << " - http://fgprc.org.cn\n"
+    << "\n"
+    << "input <nasal -h> to get help.\n\n";
+    return out;
+}
+
+std::ostream& version(std::ostream& out) {
+    std::srand(static_cast<u32>(std::time(nullptr)));
+
+    f64 num = 0;
+    for (u32 i = 0; i<5; ++i) {
+        num = (num+rand())*(1.0/(RAND_MAX+1.0));
+    }
+    // give you 5% to see this easter egg
+    if (num<0.05) {
+        nasal::parse::easter_egg();
+    }
+
+    out << "nasal version " << __nasver__;
+    out << " " << nasal::util::get_platform();
+    out << " " << nasal::util::get_arch();
+    out << " (" << __DATE__ << " " << __TIME__ << ")\n";
+    return out;
+}
+
+std::ostream& nasal_format_version(std::ostream& out) {
+    out << "nasal-format version " << __nasver__ << "-beta";
+    out << " " << nasal::util::get_platform();
+    out << " " << nasal::util::get_arch();
+    out << " (" << __DATE__ << " " << __TIME__ << ")\n";
+    return out;
+}
+
+}

src/cli/cli.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <cstring>
+#include <sstream>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <iostream>
+
+namespace nasal::cli {
+
+enum class option {
+    cli_help,
+    cli_version,
+    cli_repl_mode,
+    cli_view_ast,
+    cli_view_raw_ast,
+    cli_view_code,
+    cli_show_symbol,
+    cli_execute,
+    cli_show_execute_time,
+    cli_detail_info,
+    cli_show_referenced_file,
+    cli_debug_mode,
+    cli_profile,
+    cli_profile_all,
+    cli_limit_mode
+};
+
+struct cli_config {
+    std::string input_file_path = "";
+    std::unordered_set<option> options = {};
+    std::vector<std::string> nasal_vm_args = {};
+
+    bool has(option opt) const {
+        return options.count(opt);
+    }
+};
+
+const std::unordered_map<std::string, option> cli_options = {
+    {"-h", option::cli_help},
+    {"--help", option::cli_help},
+    {"-v", option::cli_version},
+    {"--version", option::cli_version},
+    {"-r", option::cli_repl_mode},
+    {"--repl", option::cli_repl_mode},
+    {"-a", option::cli_view_ast},
+    {"--ast", option::cli_view_ast},
+    {"--raw-ast", option::cli_view_raw_ast},
+    {"-c", option::cli_view_code},
+    {"--code", option::cli_view_code},
+    {"-s", option::cli_show_symbol},
+    {"--symbol", option::cli_show_symbol},
+    {"-e", option::cli_execute},
+    {"--exec", option::cli_execute},
+    {"-t", option::cli_show_execute_time},
+    {"--time", option::cli_show_execute_time},
+    {"-d", option::cli_detail_info},
+    {"--detail", option::cli_detail_info},
+    {"-f", option::cli_show_referenced_file},
+    {"--ref-file", option::cli_show_referenced_file},
+    {"-dbg", option::cli_debug_mode},
+    {"--debug", option::cli_debug_mode},
+    {"--prof", option::cli_profile},
+    {"--prof-all", option::cli_profile_all},
+    {"--limit", option::cli_limit_mode}
+};
+
+cli_config parse(const std::vector<std::string>&);
+
+std::ostream& help(std::ostream&);
+std::ostream& nasal_format_help(std::ostream&);
+
+std::ostream& logo(std::ostream&);
+std::ostream& version(std::ostream&);
+std::ostream& nasal_format_version(std::ostream&);
+
+}

src/format.cpp

@@ -0,0 +1,53 @@
+#include "nasal.h"
+#include "nasal_lexer.h"
+#include "ast/ast.h"
+#include "nasal_parse.h"
+#include "util/util.h"
+#include "cli/cli.h"
+#include "ast/ast_format.h"
+
+#include <iostream>
+#include <thread>
+
+[[noreturn]]
+void err() {
+    std::cerr << "invalid argument(s), use <nasal-format -h> to get help.\n";
+    std::exit(1);
+}
+
+void execute(const nasal::cli::cli_config& config) {
+    nasal::lexer lex;
+    nasal::parse parse;
+
+    // lexer scans file to get tokens
+    lex.scan(config.input_file_path).chkerr();
+
+    // parser gets lexer's token list to compile
+    parse.compile(lex).chkerr();
+
+    nasal::ast_format("nasal-format-out.nas").do_format(parse.tree());
+}
+
+int main(i32 argc, const char* argv[]) {
+    // output version info
+    if (argc <= 1) {
+        err();
+    } else if (argc > 2) {
+        err();
+    }
+
+    // the first argument is the executable itself, ignore it
+    const auto config = nasal::cli::parse({argv+1, argv+argc});
+
+    // run directly or show help
+    if (config.has(nasal::cli::option::cli_help)) {
+        std::clog << nasal::cli::nasal_format_help;
+    } else if (config.has(nasal::cli::option::cli_version)) {
+        std::clog << nasal::cli::nasal_format_version;
+    } else if (config.input_file_path.size()) {
+        execute(config);
+    } else {
+        err();
+    }
+    return 0;
+}

src/main.cpp

@@ -0,0 +1,145 @@
+#include "nasal.h"
+#include "nasal_type.h"
+#include "nasal_gc.h"
+#include "nasal_err.h"
+#include "nasal_lexer.h"
+#include "ast/ast.h"
+#include "ast/ast_visitor.h"
+#include "ast/ast_dumper.h"
+#include "nasal_parse.h"
+#include "nasal_import.h"
+#include "symbol_finder.h"
+#include "optimizer.h"
+#include "nasal_codegen.h"
+#include "nasal_vm.h"
+#include "nasal_dbg.h"
+
+#include "util/util.h"
+#include "repl/repl.h"
+#include "cli/cli.h"
+
+#include <cstdlib>
+
+[[noreturn]]
+void err() {
+    std::cerr << "invalid argument(s), use <nasal -h> to get help.\n";
+    std::exit(1);
+}
+
+void execute(const nasal::cli::cli_config& config) {
+    using option = nasal::cli::option;
+    using clk = std::chrono::high_resolution_clock;
+    const auto den = clk::duration::period::den;
+
+    nasal::lexer   lex;
+    nasal::parse   parse;
+    nasal::linker  ld;
+    nasal::codegen gen;
+
+    // lexer scans file to get tokens
+    lex.scan(config.input_file_path).chkerr();
+
+    // parser gets lexer's token list to compile
+    parse.compile(lex).chkerr();
+    if (config.has(option::cli_view_raw_ast)) {
+        nasal::ast_dumper().dump(parse.tree());
+    }
+
+    // linker gets parser's ast and load import files to this ast
+    ld.link(parse, config.has(option::cli_detail_info)).chkerr();
+    if (config.has(option::cli_show_referenced_file)) {
+        if (ld.get_file_list().size()) {
+            std::cout << "referenced file(s):\n";
+        }
+        for (const auto& file: ld.get_file_list()) {
+            std::cout << "  " << file << "\n";
+        }
+    }
+    
+    // optimizer does simple optimization on ast
+    auto opt = std::make_unique<nasal::optimizer>();
+    opt->do_optimization(parse.tree());
+    if (config.has(option::cli_view_ast)) {
+        nasal::ast_dumper().dump(parse.tree());
+    }
+
+    // code generator gets parser's ast and import file list to generate code
+    gen.compile(parse, ld, false, config.has(option::cli_limit_mode)).chkerr();
+    if (config.has(option::cli_view_code)) {
+        gen.print(std::cout);
+    }
+    if (config.has(option::cli_show_symbol)) {
+        gen.symbol_dump(std::cout);
+    }
+
+    // run
+    const auto start = clk::now();
+    double gc_time_ms = 0.0;
+    double gc_total_memory = 0.0;
+    if (config.has(option::cli_debug_mode)) {
+        auto debugger = std::make_unique<nasal::dbg>();
+        debugger->run(
+            gen,
+            ld,
+            config.nasal_vm_args,
+            config.has(option::cli_profile),
+            config.has(option::cli_profile_all)
+        );
+        gc_time_ms = debugger->get_gc_time_ms();
+        gc_total_memory = debugger->get_total_memory();
+    } else if (config.has(option::cli_show_execute_time) ||
+               config.has(option::cli_detail_info) ||
+               config.has(option::cli_limit_mode) ||
+               config.has(option::cli_execute)) {
+        auto runtime = std::make_unique<nasal::vm>();
+        runtime->set_detail_report_info(config.has(option::cli_detail_info));
+        runtime->set_limit_mode_flag(config.has(option::cli_limit_mode));
+        runtime->run(gen, ld, config.nasal_vm_args);
+        gc_time_ms = runtime->get_gc_time_ms();
+        gc_total_memory = runtime->get_total_memory();
+    }
+
+    // get running time
+    const auto end = clk::now();
+    if (config.has(option::cli_show_execute_time)) {
+        double execute_time_sec = static_cast<f64>((end - start).count())/den;
+        double gc_time_sec = gc_time_ms / 1000.0;
+        std::clog << "process exited after ";
+        std::clog << execute_time_sec << "s, gc time: ";
+        std::clog << gc_time_sec << "s (";
+        std::clog << gc_time_sec / execute_time_sec * 100.0 << "%), ";
+        std::clog << "memory usage: " << gc_total_memory << "MB\n\n";
+    }
+}
+
+i32 main(i32 argc, const char* argv[]) {
+    // output version info
+    if (argc <= 1) {
+        std::clog << nasal::cli::logo;
+        return 0;
+    }
+
+    // the first argument is the executable itself, ignore it
+    const auto config = nasal::cli::parse({argv+1, argv+argc});
+
+    // run directly or show help
+    if (argc == 2) {
+        if (config.has(nasal::cli::option::cli_help)) {
+            std::clog << nasal::cli::help;
+        } else if (config.has(nasal::cli::option::cli_version)) {
+            std::clog << nasal::cli::version;
+        } else if (config.has(nasal::cli::option::cli_repl_mode)) {
+            auto repl = std::make_unique<nasal::repl::repl>();
+            repl->execute();
+        } else if (config.input_file_path.size()) {
+            execute(config);
+        } else {
+            err();
+        }
+        return 0;
+    }
+
+    // execute with arguments
+    execute(config);
+    return 0;
+}

src/nasal.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#ifndef __nasver__
+#define __nasver__ "11.3.3"
+#endif
+
+#include <cstddef>
+#include <cstdint>
+
+// abbreviation of some useful basic type
+using i32 = std::int32_t;
+using i64 = std::int64_t;
+using u8 = std::uint8_t;
+using u16 = std::uint16_t;
+using u32 = std::uint32_t;
+using u64 = std::uint64_t;
+using usize = std::size_t;
+using f64 = double;
+
+// virtual machine stack depth, both global depth and value stack depth
+const u32 VM_STACK_DEPTH = UINT16_MAX + 1;
+
+// avoid error loading function bug in MSVC version nasal.exe
+#ifdef _MSC_VER
+    // and fuck MSVC again
+    #define NASAL_EXPORT extern "C" __declspec(dllexport)
+#else
+    #define NASAL_EXPORT extern "C" __attribute__((visibility("default")))
+#endif

src/nasal_codegen.h

@@ -0,0 +1,177 @@
+#pragma once
+
+#include "nasal_err.h"
+#include "nasal_opcode.h"
+#include "ast/ast.h"
+#include "ast/ast_visitor.h"
+#include "symbol_finder.h"
+#include "nasal_parse.h"
+#include "nasal_import.h"
+
+#include "natives/builtin.h"
+#include "natives/coroutine.h"
+#include "natives/bits_lib.h"
+#include "natives/math_lib.h"
+#include "natives/fg_props.h"
+#include "natives/io_lib.h"
+#include "natives/json_lib.h"
+#include "natives/dylib_lib.h"
+#include "natives/regex_lib.h"
+#include "natives/unix_lib.h"
+#include "natives/subprocess.h"
+
+#include <iomanip>
+#include <list>
+#include <stack>
+#include <unordered_map>
+#include <unordered_set>
+
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#endif
+
+namespace nasal {
+
+class codegen {
+private:
+    error err;
+
+    // repl output flag, will generate op_repl to output stack top value if true
+    bool flag_need_repl_output = false;
+
+    // limit mode flag
+    bool flag_limited_mode = false;
+
+    // under limited mode, unsafe system api will be banned
+    const std::unordered_set<std::string> unsafe_system_api = {
+        // builtin
+        "__system", "__input", "__terminal_size",
+        // io
+        "__fout", "__open", "__write", "__stat"
+        // bits
+        "__fld", "__sfld", "__setfld",
+        "__buf",
+        // fg
+        "__logprint",
+        // dylib
+        "__dlopen", "__dlclose", "__dlcallv", "__dlcall",
+        // unix
+        "__chdir", "__environ", "__getcwd", "__getenv",
+        // subprocess
+        "__subprocess_create",
+        "__subprocess_active",
+        "__subprocess_terminate"
+    };
+
+    // file mapper for file -> index
+    std::unordered_map<std::string, usize> file_map;
+    void init_file_map(const std::vector<std::string>&);
+
+    // used for generate pop in return expression
+    std::vector<u32> in_foreach_loop_level;
+
+    // constant numbers and strings
+    std::unordered_map<f64, u64> const_number_map;
+    std::unordered_map<std::string, u64> const_string_map;
+    std::vector<f64> const_number_table;
+    std::vector<std::string> const_string_table;
+
+    // native functions
+    std::vector<nasal_builtin_table> native_function;
+    std::unordered_map<std::string, usize> native_function_mapper;
+    void load_native_function_table(nasal_builtin_table*);
+    void init_native_function();
+
+    // generated opcodes
+    std::vector<opcode> code;
+
+    // used to store jmp operands index, to fill the jump address back
+    std::list<std::vector<u64>> continue_ptr;
+    std::list<std::vector<u64>> break_ptr;
+
+    // symbol table
+    // global : max VM_STACK_DEPTH-1 values
+    std::unordered_map<std::string, u64> global;
+
+    // nasal namespace
+    // stores all global symbols of each file
+    std::unordered_map<std::string, std::unordered_set<std::string>> nasal_namespace;
+
+    // local  : max 32768 upvalues 65536 values
+    // but in fact local scope also has less than VM_STACK_DEPTH value
+    std::list<std::unordered_map<std::string, u64>> local;
+
+    void check_id_exist(identifier*);
+    
+    void die(const std::string& info, expr* node) {
+        err.err("code", node->get_location(), info);
+    }
+
+    void regist_number(const f64);
+    void regist_string(const std::string&);
+    void find_symbol(code_block*);
+    void regist_symbol(const std::string&);
+    i64 local_symbol_find(const std::string&);
+    i64 global_symbol_find(const std::string&);
+    i64 upvalue_symbol_find(const std::string&);
+
+    void emit(u8, u64, const span&);
+
+    void number_gen(number_literal*);
+    void string_gen(string_literal*);
+    void bool_gen(bool_literal*);
+    void vector_gen(vector_expr*);
+    void hash_gen(hash_expr*);
+    void func_gen(function*);
+    void call_gen(call_expr*);
+    void call_identifier(identifier*);
+    void call_hash_gen(call_hash*);
+    void null_access_gen(null_access*);
+    void call_vector_gen(call_vector*);
+    void call_func_gen(call_function*);
+    void mcall(expr*);
+    void mcall_identifier(identifier*);
+    void mcall_vec(call_vector*);
+    void mcall_hash(call_hash*);
+    void multi_def(definition_expr*);
+    void single_def(definition_expr*);
+    void definition_gen(definition_expr*);
+    void assignment_expression(assignment_expr*);
+    void gen_assignment_equal_statement(assignment_expr*);
+    void replace_left_assignment_with_load(const span&);
+    void assignment_statement(assignment_expr*);
+    void multi_assign_gen(multi_assign*);
+    void cond_gen(condition_expr*);
+    void loop_gen(expr*);
+    void load_continue_break(u64, u64);
+    void while_gen(while_expr*);
+    void for_gen(for_expr*);
+    void forei_gen(forei_expr*);
+    void statement_generation(expr*);
+    void or_gen(binary_operator*);
+    void and_gen(binary_operator*);
+    void unary_gen(unary_operator*);
+    void binary_gen(binary_operator*);
+    void null_chain_gen(binary_operator*);
+    void trino_gen(ternary_operator*);
+    void calc_gen(expr*);
+    void repl_mode_info_output_gen(expr*);
+    void block_gen(code_block*);
+    void ret_gen(return_expr*);
+
+public:
+    const auto& strs() const { return const_string_table; }
+    const auto& nums() const { return const_number_table; }
+    const auto& natives() const { return native_function; }
+    const auto& codes() const { return code; }
+    const auto& globals() const { return global; }
+
+public:
+    codegen() = default;
+    const error& compile(parse&, linker&, bool, bool);
+    void print(std::ostream&);
+    void symbol_dump(std::ostream&) const;
+};
+
+}

src/nasal_dbg.cpp

@@ -0,0 +1,305 @@
+#include "nasal_dbg.h"
+
+namespace nasal {
+
+void operand_line_counter::init_counter() {
+    for (usize i = 0; i<operand_line_counter::operand_size; ++i) {
+        operand_counter[i] = 0;
+    }
+}
+
+void operand_line_counter::load_file_line_counter(
+    const std::vector<std::string>& file_list) {
+    file_name_list = file_list;
+    file_line_counter = {};
+    file_contents = {};
+    filestream fs;
+    for (usize i =0; i<file_list.size(); ++i) {
+        fs.load(file_list[i]);
+        file_contents.push_back(fs.file_content());
+        file_line_counter.push_back({});
+        file_line_counter.back().resize(fs.size(), 0);
+    }
+}
+
+void operand_line_counter::init(const std::vector<std::string>& file_list) {
+    init_counter();
+    load_file_line_counter(file_list);
+}
+
+void operand_line_counter::dump_operand_count() const {
+    typedef std::pair<u32, u64> op_count;
+    std::vector<op_count> opcall;
+    u64 total = 0;
+    for (usize i = 0; i<operand_line_counter::operand_size; ++i) {
+        total += operand_counter[i];
+        opcall.push_back({i, operand_counter[i]});
+    }
+    std::sort(opcall.begin(), opcall.end(),
+        [](const op_count& a, const op_count& b) {
+            return a.second>b.second;
+        }
+    );
+    std::clog << "\noperands call info (<1% ignored)\n";
+    for (const auto& i : opcall) {
+        u64 rate = i.second*100/total;
+        if (!rate) {
+            break;
+        }
+        std::clog << " ";
+        std::clog << operand_name_table.at(static_cast<opcode_type>(i.first));
+        std::clog << " : " << i.second << " (" << rate << "%)\n";
+    }
+    std::clog << " total  : " << total << '\n';
+}
+
+void operand_line_counter::dump_all_code_line_counter(std::ostream& os) const {
+    u64 max_call_time = 0;
+    for (const auto& context : file_line_counter) {
+        for (const auto& count : context) {
+            max_call_time = count>max_call_time? count:max_call_time;
+        }
+    }
+    auto pad_length = std::to_string(max_call_time).length();
+    for (usize i = 0; i<file_name_list.size(); ++i) {
+        os << "\ncode profiling data of " << file_name_list[i] << ":\n";
+        const auto& context = file_contents[i];
+        const auto& counter = file_line_counter[i];
+        for (usize j = 0; j<context.size(); ++j) {
+            os << " " << std::right << std::setw(pad_length);
+            os << std::setfill(' ');
+            os << (counter[j]==0? "":std::to_string(counter[j]));
+            os << " " << context[j] << "\n";
+        }
+    }
+}
+
+void operand_line_counter::dump_this_file_line_counter(std::ostream& os) const {
+    u64 max_call_time = 0;
+    for (const auto& count : file_line_counter[0]) {
+        max_call_time = count>max_call_time? count:max_call_time;
+    }
+    auto pad_length = std::to_string(max_call_time).length();
+
+    os << "\ncode profiling data of " << file_name_list[0] << ":\n";
+    const auto& context = file_contents[0];
+    const auto& counter = file_line_counter[0];
+    for (usize i = 0; i<context.size(); ++i) {
+        os << " " << std::right << std::setw(pad_length);
+        os << std::setfill(' ');
+        os << (counter[i]==0? "":std::to_string(counter[i]));
+        os << " " << context[i] << "\n";
+    }
+}
+
+std::vector<std::string> dbg::parse(const std::string& cmd) {
+    std::vector<std::string> res;
+    usize last = 0, pos = cmd.find(" ", 0);
+    while (pos!=std::string::npos) {
+        if (pos>last) {
+            res.push_back(cmd.substr(last, pos-last));
+        }
+        last = pos+1;
+        pos = cmd.find(" ", last);
+    }
+    if (last<cmd.length()) {
+        res.push_back(cmd.substr(last));
+    }
+    return res;
+}
+
+u16 dbg::file_index(const std::string& filename) const {
+    for (u16 i = 0; i<file_list_size; ++i) {
+        if (filename==files[i]) {
+            return i;
+        }
+    }
+    return UINT16_MAX;
+}
+
+void dbg::err() const {
+    std::cerr
+    << "incorrect command\n"
+    << "input \'h\' to get help\n";
+}
+
+void dbg::help() const {
+    std::clog
+    << "<option>\n"
+    << "  h,   help      | get help\n"
+    << "  bt,  backtrace | get function call trace\n"
+    << "  c,   continue  | run program until break point or exit\n"
+    << "  f,   file      | see all the compiled files\n"
+    << "  g,   global    | see global values\n"
+    << "  l,   local     | see local values\n"
+    << "  u,   upval     | see upvalue\n"
+    << "  r,   register  | show vm register detail\n"
+    << "  a,   all       | show global, local and upvalue\n"
+    << "  n,   next      | execute next bytecode\n"
+    << "  q,   exit      | exit debugger\n"
+    << "<option> <filename> <line>\n"
+    << "  bk,  break     | set break point\n";
+}
+
+void dbg::list_file() const {
+    for (usize i = 0; i<file_list_size; ++i) {
+        std::clog << "[" << i << "] " << files[i] << "\n";
+    }
+}
+
+void dbg::step_info() {
+    u64 line = bytecode[ctx.pc].line==0? 0:bytecode[ctx.pc].line-1;
+    u64 begin = (line>>3)==0? 0:((line>>3)<<3);
+    u64 end = (1+(line>>3))<<3;
+
+    src.load(files[bytecode[ctx.pc].fidx]);
+
+    std::clog << clear_screen << set_cursor;
+    std::clog << "\nsource code:\n";
+    for (u64 i = begin; i<end && i<src.size(); ++i) {
+        std::clog << (i==line? back_white:reset);
+        std::clog << (i==line? "--> ":"    ") << src[i] << reset << "\n";
+    }
+
+    begin = (ctx.pc>>3)==0? 0:((ctx.pc>>3)<<3);
+    end = (1+(ctx.pc>>3))<<3;
+    codestream::set(
+        const_number,
+        const_string,
+        global_symbol_name,
+        native_function.data(),
+        files
+    );
+
+    std::clog << "\nnext bytecode:\n";
+    for (u64 i = begin; i<end && bytecode[i].op!=op_exit; ++i) {
+        std::clog
+        << (i==ctx.pc? back_white:reset)
+        << (i==ctx.pc? "--> ":"    ")
+        << codestream(bytecode[i], i)
+        << reset << "\n";
+    }
+    stack_info(16);
+}
+
+void dbg::interact() {
+    // special operand, end execution
+    if (bytecode[ctx.pc].op==op_exit) {
+        return;
+    }
+
+    // do not need interact while doing profiling
+    if (do_operand_count) {
+        return;
+    }
+
+    // is not break point and is not next stop command
+    const auto& code = bytecode[ctx.pc];
+    if ((code.fidx!=break_file_index || code.line!=break_line) && !next) {
+        return;
+    }
+
+    next = false;
+    std::string cmd;
+    step_info();
+    while (true) {
+        std::clog << ">> ";
+        std::getline(std::cin, cmd);
+        auto res = parse(cmd);
+        if (res.size()==0) {
+            // enter key without input using cmd_next by default
+            next = true;
+            return;
+        } else if (res.size()==1) {
+            switch(get_cmd_type(res[0])) {
+                case cmd_kind::cmd_help: help(); break;
+                case cmd_kind::cmd_backtrace:
+                    function_call_trace();
+                    trace_back();
+                    break;
+                case cmd_kind::cmd_continue: return;
+                case cmd_kind::cmd_list_file: list_file(); break;
+                case cmd_kind::cmd_global: global_state(); break;
+                case cmd_kind::cmd_local: local_state(); break;
+                case cmd_kind::cmd_upval: upvalue_state(); break;
+                case cmd_kind::cmd_register: register_info(); break;
+                case cmd_kind::cmd_show_all: all_state_detail(); break;
+                case cmd_kind::cmd_next: next = true; return;
+                case cmd_kind::cmd_exit: std::exit(0);
+                default: err(); break;
+            }
+        } else if (res.size()==3 &&
+            get_cmd_type(res[0])==cmd_kind::cmd_break_point) {
+            break_file_index = file_index(res[1]);
+            if (break_file_index==UINT16_MAX) {
+                std::clog << "cannot find file named `" << res[1] << "`\n";
+                continue;
+            }
+            i32 tmp = atoi(res[2].c_str());
+            if (tmp<=0) {
+                std::clog << "incorrect line number `" << res[2] << "`\n";
+            } else {
+                break_line = tmp;
+            }
+        } else {
+            err();
+        }
+    }
+}
+
+void dbg::run(const codegen& gen,
+              const linker& linker,
+              const std::vector<std::string>& argv,
+              bool profile,
+              bool show_all_prof_result) {
+
+    set_detail_report_info(true);
+    do_operand_count = profile || show_all_prof_result;
+
+    const auto& file_list = linker.get_file_list();
+    file_list_size = file_list.size();
+
+    vm_init_enrty(
+        gen.strs(),
+        gen.nums(),
+        gen.natives(),
+        gen.codes(),
+        gen.globals(),
+        file_list,
+        argv
+    );
+    counter.init(file_list);
+
+    std::vector<u8> code;
+    std::vector<u16> code_file_index;
+    std::vector<u64> code_line;
+    for (const auto& i : gen.codes()) {
+        code.push_back(i.op);
+        code_file_index.push_back(i.fidx);
+        code_line.push_back(i.line);
+        imm.push_back(i.num);
+    }
+    while (operand_function[code[ctx.pc]]) {
+        interact();
+        counter.add_operand_counter(code[ctx.pc]);
+        counter.add_code_line_counter(code_file_index[ctx.pc], code_line[ctx.pc]);
+        (this->*operand_function[code[ctx.pc]])();
+        if (ctx.top>=ctx.canary) {
+            die("stack overflow");
+        }
+        ++ctx.pc;
+    }
+
+    counter.dump_operand_count();
+    if (do_operand_count) {
+        show_all_prof_result?
+            counter.dump_all_code_line_counter(std::clog):
+            counter.dump_this_file_line_counter(std::clog);
+    }
+    ngc.status.dump_info();
+    ngc.clear();
+    imm.clear();
+    return;
+}
+
+}

src/nasal_dbg.h

@@ -0,0 +1,124 @@
+#pragma once
+
+#include "nasal_import.h"
+#include "nasal_err.h"
+#include "nasal_opcode.h"
+#include "nasal_vm.h"
+
+#include <cstring>
+#include <algorithm>
+#include <unordered_map>
+
+namespace nasal {
+
+// count detail operand calling
+// and show them before each line of the source file
+class operand_line_counter {
+private:
+    static const usize operand_size = opcode_type::op_ret + 1;
+    u64 operand_counter[operand_size];
+    std::vector<std::string> file_name_list;
+    std::vector<std::vector<u64>> file_line_counter;
+    std::vector<std::vector<std::string>> file_contents;
+
+private:
+    void init_counter();
+    void load_file_line_counter(const std::vector<std::string>&);
+
+public:
+    void init(const std::vector<std::string>&);
+    void dump_operand_count() const;
+    void dump_all_code_line_counter(std::ostream&) const;
+    void dump_this_file_line_counter(std::ostream&) const;
+    void add_operand_counter(usize index) {
+        operand_counter[index] += index<operand_size? 1:0;
+    }
+    void add_code_line_counter(usize fidx, usize line) {
+        auto& vec = file_line_counter[fidx];
+        vec[line==0? line: line-1]++;
+    }
+};
+
+class dbg: public vm {
+private:
+    enum class cmd_kind {
+        cmd_error,
+        cmd_help,
+        cmd_backtrace,
+        cmd_continue,
+        cmd_list_file,
+        cmd_global,
+        cmd_local,
+        cmd_upval,
+        cmd_register,
+        cmd_show_all,
+        cmd_next,
+        cmd_break_point,
+        cmd_exit
+    };
+
+private:
+    const std::unordered_map<std::string, cmd_kind> command_table = {
+        {"h", cmd_kind::cmd_help},
+        {"help", cmd_kind::cmd_help},
+        {"bt", cmd_kind::cmd_backtrace},
+        {"backtrace", cmd_kind::cmd_backtrace},
+        {"c", cmd_kind::cmd_continue},
+        {"continue", cmd_kind::cmd_continue},
+        {"f", cmd_kind::cmd_list_file},
+        {"file", cmd_kind::cmd_list_file},
+        {"g", cmd_kind::cmd_global},
+        {"global", cmd_kind::cmd_global},
+        {"l", cmd_kind::cmd_local},
+        {"local", cmd_kind::cmd_local},
+        {"u", cmd_kind::cmd_upval},
+        {"upval", cmd_kind::cmd_upval},
+        {"r", cmd_kind::cmd_register},
+        {"register", cmd_kind::cmd_register},
+        {"a", cmd_kind::cmd_show_all},
+        {"all", cmd_kind::cmd_show_all},
+        {"n", cmd_kind::cmd_next},
+        {"next", cmd_kind::cmd_next},
+        {"bk", cmd_kind::cmd_break_point},
+        {"break", cmd_kind::cmd_break_point},
+        {"q", cmd_kind::cmd_exit},
+        {"exit", cmd_kind::cmd_exit}
+    };
+    cmd_kind get_cmd_type(const std::string& cmd) const {
+        return command_table.count(cmd)
+                ? command_table.at(cmd)
+                : cmd_kind::cmd_error;
+    }
+
+private:
+    bool next;
+    usize file_list_size;
+    u16 break_file_index;
+    u64 break_line;
+    error src;
+
+private:
+    operand_line_counter counter;
+    bool do_operand_count;
+
+private:
+    std::vector<std::string> parse(const std::string&);
+    u16 file_index(const std::string&) const;
+    void err() const;
+    void help() const;
+    void list_file() const;
+    void step_info();
+    void interact();
+
+public:
+    dbg(): next(true), file_list_size(0),
+           break_file_index(0), break_line(0),
+           do_operand_count(false) {}
+    void run(const codegen&,
+             const linker&,
+             const std::vector<std::string>&,
+             bool,
+             bool);
+};
+
+}

src/nasal_err.cpp

@@ -0,0 +1,245 @@
+#include "nasal_err.h"
+#include "repl/repl.h"
+
+namespace nasal {
+
+#ifdef _WIN32
+#include <windows.h> // use SetConsoleTextAttribute
+struct for_reset {
+    CONSOLE_SCREEN_BUFFER_INFO scr;
+    for_reset() {
+        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &scr);
+    }
+};
+static for_reset windows_system_set;
+#endif
+
+std::ostream& clear_screen(std::ostream& s) {
+#ifdef _WIN32
+    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (hConsole == INVALID_HANDLE_VALUE) {
+        return s;
+    }
+
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    if (!GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) {
+        return s;
+    }
+
+    auto rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+    auto cols = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+    DWORD dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
+    COORD coord = { 0, 0 };
+    DWORD dwCharsWritten;
+
+    FillConsoleOutputCharacter(hConsole, ' ', dwConSize, coord, &dwCharsWritten);
+
+    // set raw attribute
+    FillConsoleOutputAttribute(
+        hConsole,
+        csbi.wAttributes,
+        dwConSize,
+        coord,
+        &dwCharsWritten
+    );
+
+    // set cursor position
+    SetConsoleCursorPosition(hConsole, coord);
+#else
+    s << "\033c";
+#endif
+    return s;
+}
+
+std::ostream& set_cursor(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), {0, 0});
+#else
+    s << "\033[0;0H";
+#endif
+    return s;
+}
+
+std::ostream& back_white(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0xf0);
+#else
+    s << "\033[7m";
+#endif
+    return s;
+}
+
+std::ostream& red(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0c);
+#else
+    s << "\033[91;1m";
+#endif
+    return s;
+}
+
+std::ostream& cyan(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x03);
+#else
+    s << "\033[36;1m";
+#endif
+    return s;
+}
+
+std::ostream& orange(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0e);
+#else
+    s << "\033[93;1m";
+#endif
+    return s;
+}
+
+std::ostream& white(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0f);
+#else
+    s << "\033[0m\033[1m";
+#endif
+    return s;
+}
+
+std::ostream& reset(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(
+        GetStdHandle(STD_OUTPUT_HANDLE),
+        windows_system_set.scr.wAttributes
+    );
+#else
+    s << "\033[0m";
+#endif
+    return s;
+}
+
+void filestream::load(const std::string& f) {
+    if (file==f) { // don't need to load a loaded file
+        return;
+    }
+    
+    // update file name
+    file = f;
+
+    // REPL: load from memory
+    if (repl::info::instance()->in_repl_mode &&
+        repl::info::instance()->repl_file_name==file) {
+        const auto& source = repl::info::instance()->repl_file_source;
+        res = {};
+        size_t pos = 0, last = 0;
+        while ((pos = source.find("\n", last))!=std::string::npos) {
+            res.push_back(source.substr(last, pos - last));
+            last = pos + 1;
+        }
+        if (last<source.length()) {
+            res.push_back(source.substr(last));
+        } else {
+            res.push_back("");
+        }
+        return;
+    }
+
+    res.clear();
+    std::ifstream in(f, std::ios::binary);
+    if (in.fail()) {
+        std::cerr << red << "src: " << reset << "cannot open <" << f << ">\n";
+        std::exit(1);
+    }
+    
+    while (!in.eof()) {
+        std::string line;
+        std::getline(in, line);
+        res.push_back(line);
+    }
+}
+
+void error::err(const std::string& stage, const std::string& info) {
+    ++cnt;
+    std::cerr << red << stage << ": " << white << info << reset << "\n\n";
+}
+
+void error::warn(const std::string& stage, const std::string& info) {
+    std::clog << orange << stage << ": " << white << info << reset << "\n\n";
+}
+
+void error::err(const std::string& stage,
+                const span& loc,
+                const std::string& info) {
+    // load error occurred file into string lines
+    load(loc.file);
+
+    ++cnt;
+
+    std::cerr << red << stage << ": " << white << info << reset << "\n";
+    std::cerr << cyan << "  --> " << red;
+    loc.dump_begin(std::cerr);
+    std::cerr << reset << "\n";
+
+    const usize maxlen = std::to_string(loc.end_line).length();
+    const std::string iden = identation(maxlen);
+
+    for (u64 line = loc.begin_line; line<=loc.end_line; ++line) {
+        // skip line 0
+        if (!line) {
+            continue;
+        }
+
+        if (loc.begin_line<line && line<loc.end_line) {
+            if (line==loc.begin_line+1) {
+                std::cerr << cyan << iden << " | " << reset << "...\n";
+                std::cerr << cyan << iden << " | " << reset << "\n";
+            }
+            continue;
+        }
+
+        // if this line has nothing, skip
+        if (!res[line-1].length() && line!=loc.end_line) {
+            continue;
+        }
+
+        // line out of range
+        if (line-1>=res.size()) {
+            continue;
+        }
+
+        const auto& code = res[line-1];
+        std::cerr << cyan << leftpad(line, maxlen) << " | " << reset << code << "\n";
+        // output underline
+        std::cerr << cyan << iden << " | " << reset;
+        if (loc.begin_line==loc.end_line) {
+            for (u64 i = 0; i<loc.begin_column; ++i) {
+                std::cerr << char(" \t"[code[i]=='\t']);
+            }
+            for (u64 i = loc.begin_column; i<loc.end_column; ++i) {
+                std::cerr << red << (code[i]=='\t'? "^^^^":"^") << reset;
+            }
+        } else if (line==loc.begin_line) {
+            for (u64 i = 0; i<loc.begin_column; ++i) {
+                std::cerr << char(" \t"[code[i]=='\t']);
+            }
+            for (u64 i = loc.begin_column; i<code.size(); ++i) {
+                std::cerr << red << (code[i]=='\t'? "^^^^":"^") << reset;
+            }
+        } else if (loc.begin_line<line && line<loc.end_line) {
+            for (u64 i = 0; i<code.size(); ++i) {
+                std::cerr << red << (code[i]=='\t'? "^^^^":"^");
+            }
+        } else {
+            for (u64 i = 0; i<loc.end_column; ++i) {
+                std::cerr << red << (code[i]=='\t'? "^^^^":"^");
+            }
+        }
+        if (line==loc.end_line) {
+            std::cerr << reset;
+        } else {
+            std::cerr << reset << "\n";
+        }
+    }
+    std::cerr << "\n\n";
+}
+
+}

src/nasal_err.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <iostream>
+#include <fstream>
+#include <sstream> // MSVC need this to use std::getline
+#include <cstring>
+#include <vector>
+
+#include "nasal.h"
+
+namespace nasal {
+
+struct span {
+    u64 begin_line;
+    u64 begin_column;
+    u64 end_line;
+    u64 end_column;
+    std::string file;
+
+    void dump_begin(std::ostream& out) const {
+        out << file << ":" << begin_line << ":" << begin_column + 1;
+    }
+};
+
+std::ostream& clear_screen(std::ostream&);
+std::ostream& set_cursor(std::ostream&);
+std::ostream& back_white(std::ostream&);
+std::ostream& red(std::ostream&);
+std::ostream& cyan(std::ostream&);
+std::ostream& orange(std::ostream&);
+std::ostream& white(std::ostream&);
+std::ostream& reset(std::ostream&);
+
+class filestream {
+protected:
+    std::string file;
+    std::vector<std::string> res;
+
+public:
+    filestream(): file("") {}
+    void load(const std::string&);
+    const std::string& operator[](usize n) const {return res[n];}
+    const auto& name() const {return file;}
+    const auto& file_content() const {return res;}
+    usize size() const {return res.size();}
+};
+
+class error: public filestream {
+private:
+    u32 cnt; // counter for errors
+
+    std::string identation(usize len) {
+        return std::string(len, ' ');
+    }
+    std::string leftpad(u64 num, usize len) {
+        auto tmp = std::to_string(num);
+        while (tmp.length()<len) {
+            tmp = " "+tmp;
+        }
+        return tmp;
+    }
+
+public:
+    error(): cnt(0) {}
+    void err(const std::string&, const std::string&);
+    void warn(const std::string&, const std::string&);
+    void err(const std::string&, const span&, const std::string&);
+
+    void chkerr() const {
+        if (cnt) {
+            std::exit(1);
+        }
+    }
+    auto geterr() const { return cnt; }
+};
+
+}

src/nasal_gc.cpp

@@ -0,0 +1,361 @@
+#include "nasal_gc.h"
+
+namespace nasal {
+
+void gc::do_mark_sweep() {
+    count_mark_time();
+    count_sweep_time();
+}
+
+void gc::count_mark_time() {
+    if (in_incremental_sweep_stage) {
+        return;
+    }
+
+    status.stamp();
+    mark();
+    status.elapsed_mark_time();
+
+    in_incremental_sweep_stage = true;
+    current_sweep_index = memory.size() - 1;
+}
+
+void gc::count_sweep_time() {
+    status.stamp();
+    sweep();
+    status.elapsed_sweep_time();
+}
+
+void gc::mark() {
+    std::vector<var> bfs;
+    mark_context_root(bfs);
+
+    // concurrent mark
+    if (memory.size() > UINT16_MAX * 16 && bfs.size() > 16) {
+        auto size = bfs.size();
+        std::thread t0(&gc::concurrent_mark, this, std::ref(bfs), 0, size/4);
+        std::thread t1(&gc::concurrent_mark, this, std::ref(bfs), size/4, size/2);
+        std::thread t2(&gc::concurrent_mark, this, std::ref(bfs), size/2, size/4*3);
+        std::thread t3(&gc::concurrent_mark, this, std::ref(bfs), size/4*3, size);
+        t0.join();
+        t1.join();
+        t2.join();
+        t3.join();
+        return;
+    }
+
+    // normal mark
+    while (!bfs.empty()) {
+        var value = bfs.back();
+        bfs.pop_back();
+        if (value.type<=vm_type::vm_num ||
+            value.val.gcobj->mark!=nas_val::gc_status::uncollected) {
+            continue;
+        }
+        mark_var(bfs, value);
+    }
+}
+
+void gc::concurrent_mark(std::vector<var>& vec, usize begin, usize end) {
+    std::vector<var> bfs;
+    for (auto i = begin; i<end; ++i) {
+        var value = vec[i];
+        if (value.type<=vm_type::vm_num ||
+            value.val.gcobj->mark!=nas_val::gc_status::uncollected) {
+            continue;
+        }
+        mark_var(bfs, value);
+    }
+    while (!bfs.empty()) {
+        var value = bfs.back();
+        bfs.pop_back();
+        if (value.type<=vm_type::vm_num ||
+            value.val.gcobj->mark!=nas_val::gc_status::uncollected) {
+            continue;
+        }
+        mark_var(bfs, value);
+    }
+}
+
+void gc::mark_context_root(std::vector<var>& bfs_queue) {
+    // scan global
+    for (usize i = 0; i < main_context_global_size; ++i) {
+        auto& val = main_context_global[i];
+        if (val.type > vm_type::vm_num) {
+            bfs_queue.push_back(val);
+        }
+    }
+    // scan now running context, this context maybe related to coroutine or main
+    for (var* i = running_context->stack; i <= running_context->top; ++i) {
+        if (i->type > vm_type::vm_num) {
+            bfs_queue.push_back(*i);
+        }
+    }
+    bfs_queue.push_back(running_context->funcr);
+    bfs_queue.push_back(running_context->upvalr);
+    bfs_queue.push_back(temp);
+
+    if (!cort) {
+        return;
+    }
+
+    // coroutine is running, so scan main process stack from mctx
+    for (var* i = main_context.stack; i <= main_context.top; ++i) {
+        if (i->type > vm_type::vm_num) {
+            bfs_queue.push_back(*i);
+        }
+    }
+    bfs_queue.push_back(main_context.funcr);
+    bfs_queue.push_back(main_context.upvalr);
+}
+
+void gc::mark_var(std::vector<var>& bfs_queue, var& value) {
+    value.val.gcobj->mark = nas_val::gc_status::found;
+    switch(value.type) {
+        case vm_type::vm_vec: mark_vec(bfs_queue, value.vec()); break;
+        case vm_type::vm_hash: mark_hash(bfs_queue, value.hash()); break;
+        case vm_type::vm_func: mark_func(bfs_queue, value.func()); break;
+        case vm_type::vm_upval: mark_upval(bfs_queue, value.upval()); break;
+        case vm_type::vm_ghost: mark_ghost(bfs_queue, value.ghost()); break;
+        case vm_type::vm_co: mark_co(bfs_queue, value.co()); break;
+        case vm_type::vm_map: mark_map(bfs_queue, value.map()); break;
+        default: break;
+    }
+}
+
+void gc::mark_vec(std::vector<var>& bfs_queue, nas_vec& vec) {
+    for (auto& i : vec.elems) {
+        if (i.type > vm_type::vm_num) {
+            bfs_queue.push_back(i);
+        }
+    }
+}
+
+void gc::mark_hash(std::vector<var>& bfs_queue, nas_hash& hash) {
+    for (auto& i : hash.elems) {
+        if (i.second.type > vm_type::vm_num) {
+            bfs_queue.push_back(i.second);
+        }
+    }
+}
+
+void gc::mark_func(std::vector<var>& bfs_queue, nas_func& function) {
+    for (auto& i : function.local) {
+        if (i.type > vm_type::vm_num) {
+            bfs_queue.push_back(i);
+        }
+    }
+    for (auto& i : function.upval) {
+        bfs_queue.push_back(i);
+    }
+}
+
+void gc::mark_upval(std::vector<var>& bfs_queue, nas_upval& upval) {
+    for (auto& i : upval.elems) {
+        if (i.type > vm_type::vm_num) {
+            bfs_queue.push_back(i);
+        }
+    }
+}
+
+void gc::mark_ghost(std::vector<var>& bfs_queue, nas_ghost& ghost) {
+    if (!ghost.gc_mark_function) {
+        return;
+    }
+    ghost.gc_mark_function(ghost.pointer, &bfs_queue);
+}
+
+void gc::mark_co(std::vector<var>& bfs_queue, nas_co& co) {
+    bfs_queue.push_back(co.ctx.funcr);
+    bfs_queue.push_back(co.ctx.upvalr);
+    for (var* i = co.ctx.stack; i<=co.ctx.top; ++i) {
+        if (i->type > vm_type::vm_num) {
+            bfs_queue.push_back(*i);
+        }
+    }
+}
+
+void gc::mark_map(std::vector<var>& bfs_queue, nas_map& mp) {
+    for (const auto& i : mp.mapper) {
+        if (i.second->type > vm_type::vm_num) {
+            bfs_queue.push_back(*i.second);
+        }
+    }
+}
+
+void gc::sweep() {
+    // if threshold is too small, too many allocated objects will be marked as "found"
+    // objects with "found" will be marked to "uncollected" in the next gc cycle
+    // this will cause memory wasting.
+    const i64 threshold = 4096;
+    for (i64 it = 0; it < threshold; ++it) {
+        if (current_sweep_index - it < 0) {
+            break;
+        }
+        auto i = memory[current_sweep_index - it];
+        if (i->mark==nas_val::gc_status::uncollected) {
+            unused[static_cast<u32>(i->type)-static_cast<u32>(vm_type::vm_str)].push_back(i);
+            i->mark = nas_val::gc_status::collected;
+        } else if (i->mark==nas_val::gc_status::found) {
+            i->mark = nas_val::gc_status::uncollected;
+        }
+    }
+    current_sweep_index -= threshold;
+    if (current_sweep_index < 0) {
+        in_incremental_sweep_stage = false;
+        current_sweep_index = 0;
+    }
+}
+
+void gc::extend(const vm_type type) {
+    const u32 index = static_cast<u32>(type)-static_cast<u32>(vm_type::vm_str);
+    status.object_size[index] += incr[index];
+
+    for (u64 i = 0; i<incr[index]; ++i) {
+        // no need to check, will be killed if memory is not enough
+        nas_val* tmp = new nas_val(type);
+
+        // add to heap
+        memory.push_back(tmp);
+        unused[index].push_back(tmp);
+    }
+    switch(type) {
+        case vm_type::vm_str:
+            total_object_count += incr[index] * sizeof(std::string); break;
+        case vm_type::vm_vec:
+            total_object_count += incr[index] * sizeof(nas_vec); break;
+        case vm_type::vm_hash:
+            total_object_count += incr[index] * sizeof(nas_hash); break;
+        case vm_type::vm_func:
+            total_object_count += incr[index] * sizeof(nas_func); break;
+        case vm_type::vm_upval:
+            total_object_count += incr[index] * sizeof(nas_upval); break;
+        case vm_type::vm_ghost:
+            total_object_count += incr[index] * sizeof(nas_ghost); break;
+        case vm_type::vm_co:
+            total_object_count += incr[index] * sizeof(nas_co); break;
+        case vm_type::vm_map:
+            total_object_count += incr[index] * sizeof(nas_map); break;
+        default: break;
+    }
+
+    // if incr[index] = 1, this will always be 1
+    incr[index] = incr[index] + incr[index];
+}
+
+void gc::init(const std::vector<std::string>& constant_strings,
+              const std::vector<std::string>& argv) {
+    // initialize gc status recorder
+    status.init();
+
+    // coroutine pointer set to nullptr
+    cort = nullptr;
+
+    // init constant strings
+    strs.resize(constant_strings.size());
+    for (u64 i = 0; i < strs.size(); ++i) {
+        // incremental initialization, avoid memory leak in repl mode
+        if (strs[i].is_str() && strs[i].str()==constant_strings[i]) {
+            continue;
+        }
+        strs[i] = var::gcobj(new nas_val(vm_type::vm_str));
+        strs[i].val.gcobj->immutable = 1;
+        strs[i].str() = constant_strings[i];
+        total_object_count += strs[i].str().size();
+        total_object_count += sizeof(std::string);
+    }
+
+    // record arguments
+    env_argv.resize(argv.size());
+    for (u64 i = 0; i < argv.size(); ++i) {
+        // incremental initialization, avoid memory leak in repl mode
+        if (env_argv[i].is_str() && env_argv[i].str() == argv[i]) {
+            continue;
+        }
+        env_argv[i] = var::gcobj(new nas_val(vm_type::vm_str));
+        env_argv[i].val.gcobj->immutable = 1;
+        env_argv[i].str() = argv[i];
+        total_object_count += env_argv[i].str().size();
+        total_object_count += sizeof(std::string);
+    }
+}
+
+void gc::clear() {
+    for (auto i : memory) {
+        delete i;
+    }
+    memory.clear();
+    for (u32 i = 0; i<GC_TYPE_SIZE; ++i) {
+        unused[i].clear();
+    }
+    for (auto& i : strs) {
+        delete i.val.gcobj;
+    }
+    strs.clear();
+    env_argv.clear();
+}
+
+var gc::alloc(const vm_type type) {
+    const u32 index = static_cast<u32>(type)-static_cast<u32>(vm_type::vm_str);
+    ++status.alloc_count[index];
+    // if still in incremental sweep stage? do it
+    // if not in incremental sweep stage, run a new gc cycle
+    if (in_incremental_sweep_stage) {
+        do_mark_sweep();
+    } else if (unused[index].empty()) {
+        ++status.gc_cycle_trigger_count[index];
+        do_mark_sweep();
+    }
+    // if in incremental sweep stage, but the unused list is empty,
+    // do it until the unused list has something
+    while (unused[index].empty() && in_incremental_sweep_stage) {
+        do_mark_sweep();
+    }
+    // after all gc stages, still get empty list, extend
+    if (unused[index].empty()) {
+        extend(type);
+    }
+
+    var ret = var::gcobj(unused[index].back());
+    ret.val.gcobj->clear();
+
+    // if incremental sweep stage, mark it as found
+    // but be aware that it may be collected in next gc cycle
+    ret.val.gcobj->mark = in_incremental_sweep_stage
+        ? nas_val::gc_status::found
+        : nas_val::gc_status::uncollected;
+    unused[index].pop_back();
+    return ret;
+}
+
+void gc::context_change(nas_co* co) {
+    // store running state to main context
+    main_context = *running_context;
+
+    // restore coroutine context state
+    *running_context = co->ctx;
+
+    // set coroutine pointer
+    cort = co;
+
+    // set coroutine state to running
+    cort->status = nas_co::status::running;
+}
+
+void gc::context_reserve() {
+    // pc = 0 means this coroutine is finished
+    cort->status = running_context->pc
+        ? nas_co::status::suspended
+        : nas_co::status::dead;
+
+    // store running state to coroutine
+    cort->ctx = *running_context;
+
+    // restore main context state
+    *running_context = main_context;
+
+    // set coroutine pointer to nullptr
+    cort = nullptr;
+}
+
+}

src/nasal_gc.h

@@ -0,0 +1,148 @@
+#pragma once
+
+// avoid MSVC warnings
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4102)
+#endif
+
+#include <iomanip>
+#include <vector>
+#include <chrono>
+#include <thread>
+#include <cstring>
+#include <sstream>
+#include <iostream>
+
+#include "nasal.h"
+#include "nasal_type.h"
+#include "util/gc_stat.h"
+
+namespace nasal {
+
+struct free_list {
+    std::vector<nas_val*> elem[GC_TYPE_SIZE];
+
+    auto& operator[](i64 index) {
+        return elem[index];
+    }
+};
+
+struct gc {
+    /* main context temporary storage */
+    context main_context;
+
+    /* global storage */
+    var* main_context_global = nullptr;
+    usize main_context_global_size = 0;
+
+    /* runtime context */
+    context* running_context = nullptr;
+    nas_co* cort = nullptr;         // running coroutine
+
+    /*  temporary space used in native / module functions */
+    var temp = nil;
+
+    /* constants and memory pool */
+    std::vector<var> strs = {};     // reserved address for const vm_str
+    std::vector<var> env_argv = {}; // command line arguments
+    std::vector<nas_val*> memory;   // gc memory
+    free_list unused;               // gc free list
+
+    /* heap increase size */
+    u64 incr[GC_TYPE_SIZE] = {
+        256, // vm_str
+        256, // vm_vec
+        256, // vm_hash
+        256, // vm_func
+        256, // vm_upval
+        4,   // vm_obj
+        4,   // vm_co
+        1,   // vm_map
+    };
+
+    // total object count
+    u64 total_object_count = 0;
+
+    /* values for analysis */
+    gc_stat status;
+
+    bool in_incremental_sweep_stage = false;
+    i64 current_sweep_index = 0;
+
+    void set(context* _ctx, var* _global, usize _size) {
+        running_context = _ctx;
+        main_context_global = _global;
+        main_context_global_size = _size;
+    }
+
+private:
+    /* gc functions */
+    void do_mark_sweep();
+    void count_mark_time();
+    void count_sweep_time();
+    void mark();
+    void concurrent_mark(std::vector<var>&, usize, usize);
+    void mark_context_root(std::vector<var>&);
+    void mark_var(std::vector<var>&, var&);
+    void mark_vec(std::vector<var>&, nas_vec&);
+    void mark_hash(std::vector<var>&, nas_hash&);
+    void mark_func(std::vector<var>&, nas_func&);
+    void mark_upval(std::vector<var>&, nas_upval&);
+    void mark_ghost(std::vector<var>&, nas_ghost&);
+    void mark_co(std::vector<var>&, nas_co&);
+    void mark_map(std::vector<var>&, nas_map&);
+    void sweep();
+
+public:
+    void extend(const vm_type);
+    void init(const std::vector<std::string>&, const std::vector<std::string>&);
+    void clear();
+    var alloc(const vm_type);
+    void context_change(nas_co*);
+    void context_reserve();
+
+public:
+    f64 get_gc_time_ms() const {
+        return status.gc_time_ms();
+    }
+
+    // not very accurate
+    f64 get_total_memory() const {
+        return total_object_count * 3.5 / 1024.0 / 1024.0;
+    }
+
+public:
+    var newstr(char c) {
+        var s = alloc(vm_type::vm_str);
+        s.str() = c;
+        return s;
+    }
+
+    var newstr(const char* buff) {
+        var s = alloc(vm_type::vm_str);
+        s.str() = std::string(buff);
+        return s;
+    }
+
+    var newstr(const std::string& buff) {
+        var s = alloc(vm_type::vm_str);
+        s.str() = buff;
+        return s;
+    }
+};
+
+// module function type
+typedef var (*module_func)(var*, usize, gc*);
+
+// module function stores in tables with this type, end with {nullptr, nullptr}
+struct module_func_info {
+    const char* name;
+    module_func fd;
+};
+
+// module function "get" type
+typedef module_func_info* (*get_func_ptr)();
+
+}

src/nasal_import.cpp

@@ -0,0 +1,428 @@
+#include "nasal_import.h"
+#include "symbol_finder.h"
+#include "util/util.h"
+#include "util/fs.h"
+
+#include <memory>
+#include <unordered_set>
+
+namespace nasal {
+
+linker::linker(): show_path_flag(false), this_file("") {
+    const auto env_get_path = getenv("PATH");
+    if (!env_get_path) {
+        err.warn("link", "cannot get env \"PATH\".");
+        envpath = {};
+        return;
+    }
+
+    const auto seperator = util::is_windows()? ';':':';
+    const auto PATH = std::string(env_get_path);
+    usize last = 0, position = PATH.find(seperator, 0);
+    while (position!=std::string::npos) {
+        std::string dirpath = PATH.substr(last, position-last);
+        if (dirpath.length()) {
+            envpath.push_back(dirpath);
+        }
+        last = position+1;
+        position = PATH.find(seperator, last);
+    }
+    if (last!=PATH.length()) {
+        envpath.push_back(PATH.substr(last));
+    }
+}
+
+std::string linker::get_path(expr* node) {
+    if (node->get_type()==expr_type::ast_use) {
+        auto file_relative_path = std::string("");
+        const auto& path = reinterpret_cast<use_stmt*>(node)->get_path();
+        for (auto i : path) {
+            file_relative_path += i->get_name();
+            if (i!=path.back()) {
+                file_relative_path += (util::is_windows()? "\\":"/");
+            }
+        }
+        return file_relative_path + ".nas";
+    }
+    auto call_node = reinterpret_cast<call_expr*>(node);
+    auto arguments = reinterpret_cast<call_function*>(call_node->get_calls()[0]);
+    auto content = reinterpret_cast<string_literal*>(arguments->get_argument()[0]);
+    return content->get_content();
+}
+
+std::string linker::find_real_file_path(const std::string& filename,
+                                        const span& location) {
+    // first add file name itself into the file path
+    std::vector<fs::path> path_list = {filename};
+
+    // generate search path from environ path
+    for (const auto& p : envpath) {
+        path_list.push_back(fs::path(p)/filename);
+    }
+
+    // search file
+    for (const auto& path : path_list) {
+        if (fs::exists(path)) {
+            return path.str();
+        }
+    }
+
+    // we will find lib.nas in nasal std directory
+    if (filename=="lib.nas") {
+        return util::is_windows()?
+            find_real_file_path("std\\lib.nas", location):
+            find_real_file_path("std/lib.nas", location);
+    }
+    if (!show_path_flag) {
+        err.err("link",
+            "in <" + location.file + ">: " +
+            "cannot find file <" + filename + ">, " +
+            "use <-d> to get detail search path"
+        );
+        return "";
+    }
+    auto path_list_info = std::string("");
+    for (const auto& path : path_list) {
+        path_list_info += "  -> " + path.str() + "\n";
+    }
+    err.err("link",
+        "in <" + location.file + ">: " +
+        "cannot find file <" + filename +
+        "> in these paths:\n" + path_list_info
+    );
+    return "";
+}
+
+bool linker::import_check(expr* node) {
+    if (node->get_type()==expr_type::ast_use) {
+        return true;
+    }
+/*
+    call
+    |_id:import
+    |_call_func
+      |_string:'filename'
+*/
+    if (node->get_type()!=expr_type::ast_call) {
+        return false;
+    }
+    auto call_node = reinterpret_cast<call_expr*>(node);
+    auto first_expr = call_node->get_first();
+    if (first_expr->get_type()!=expr_type::ast_id) {
+        return false;
+    }
+    if (reinterpret_cast<identifier*>(first_expr)->get_name()!="import") {
+        return false;
+    }
+    if (!call_node->get_calls().size()) {
+        return false;
+    }
+
+    // import("xxx");
+    if (call_node->get_calls().size()!=1) {
+        return false;
+    }
+    auto maybe_func_call = call_node->get_calls()[0];
+    if (maybe_func_call->get_type()!=expr_type::ast_callf) {
+        return false;
+    }
+    auto func_call = reinterpret_cast<call_function*>(maybe_func_call);
+    if (func_call->get_argument().size()!=1) {
+        return false;
+    }
+    if (func_call->get_argument()[0]->get_type()!=expr_type::ast_str) {
+        return false;
+    }
+    return true;
+}
+
+bool linker::check_exist_or_record_file(const std::string& file) {
+    // avoid importing the same file
+    for (const auto& name : imported_files) {
+        if (file==name) {
+            return true;
+        }
+    }
+    imported_files.push_back(file);
+    return false;
+}
+
+bool linker::check_self_import(const std::string& file) {
+    for (const auto& name : module_load_stack) {
+        if (file==name) {
+            return true;
+        }
+    }
+    return false;
+}
+
+std::string linker::generate_self_import_path(const std::string& filename) {
+    std::string res = "";
+    for (const auto& i : module_load_stack) {
+        res += "[" + i + "] -> ";
+    }
+    return res + "[" + filename + "]";
+}
+
+void linker::merge_tree(code_block* new_tree_root, code_block* old_tree_root) {
+    // add children of add_root to the back of root
+    for (auto& i : old_tree_root->get_expressions()) {
+        new_tree_root->add_expression(i);
+    }
+    // clean old root
+    old_tree_root->get_expressions().clear();
+}
+
+code_block* linker::import_regular_file(
+    expr* node, std::unordered_set<std::string>& used_modules) {
+    // get filename
+    auto filename = get_path(node);
+
+    // avoid infinite loading loop
+    filename = find_real_file_path(filename, node->get_location());
+    // if get empty string(error) or this file is used before, do not parse
+    if (!filename.length() || used_modules.count(filename)) {
+        return new code_block({0, 0, 0, 0, filename});
+    }
+
+    // check self import, avoid infinite loading loop
+    if (check_self_import(filename)) {
+        err.err("link",
+            node->get_location(),
+            "self-referenced module <" + filename + ">, " +
+            "reference path: " + generate_self_import_path(filename)
+        );
+        return new code_block({0, 0, 0, 0, filename});
+    }
+    check_exist_or_record_file(filename);
+
+    module_load_stack.push_back(filename);
+    // avoid stack overflow
+    if (module_load_stack.size()>MAX_RECURSION_DEPTH) {
+        err.err("link",
+            node->get_location(),
+            "too deep module import stack (>" +
+            std::to_string(MAX_RECURSION_DEPTH) + ")."
+        );
+        return new code_block({0, 0, 0, 0, filename});
+    }
+    // start importing...
+    lexer nasal_lexer;
+    parse nasal_parser;
+    if (nasal_lexer.scan(filename).geterr()) {
+        err.err("link",
+            node->get_location(),
+            "error occurred when analysing <" + filename + ">"
+        );
+        return new code_block({0, 0, 0, 0, filename});
+    }
+    if (nasal_parser.compile(nasal_lexer).geterr())  {
+        err.err("link",
+            node->get_location(),
+            "error occurred when analysing <" + filename + ">"
+        );
+        return new code_block({0, 0, 0, 0, filename});
+    }
+    // swap result out
+    auto parse_result = nasal_parser.swap(nullptr);
+
+    // check if parse result has 'import'
+    load(parse_result, filename);
+    module_load_stack.pop_back();
+    return parse_result;
+}
+
+code_block* linker::import_nasal_lib() {
+    auto path = find_real_file_path(
+        "lib.nas", {0, 0, 0, 0, this_file}
+    );
+    if (!path.length()) {
+        return new code_block({0, 0, 0, 0, path});
+    }
+
+    // avoid infinite loading library
+    if (check_exist_or_record_file(path)) {
+        return new code_block({0, 0, 0, 0, path});
+    }
+    
+    // start importing...
+    lexer nasal_lexer;
+    parse nasal_parser;
+    if (nasal_lexer.scan(path).geterr()) {
+        err.err("link",
+            "error occurred when analysing library <" + path + ">"
+        );
+        return new code_block({0, 0, 0, 0, path});
+    }
+    if (nasal_parser.compile(nasal_lexer).geterr())  {
+        err.err("link",
+            "error occurred when analysing library <" + path + ">"
+        );
+        return new code_block({0, 0, 0, 0, path});
+    }
+    // swap result out
+    auto parse_result = nasal_parser.swap(nullptr);
+    // check if library has 'import' (in fact it should not)
+    load(parse_result, path);
+    return parse_result;
+}
+
+std::string linker::generate_module_name(const std::string& file_path) {
+    // import("...") may trigger this error module name
+    auto error_name = "module@[" + file_path + "]";
+    if (!file_path.length()) {
+        return error_name;
+    }
+
+    // check file suffix and get file suffix position
+    auto suffix_position = file_path.find(".nas");
+    if (suffix_position==std::string::npos) {
+        err.warn("link",
+            "get invalid module name from <" + file_path + ">, " +
+            "will not be easily accessed. " +
+            "\".nas\" suffix is required."
+        );
+        return error_name;
+    }
+    if (suffix_position+4!=file_path.length()) {
+        err.warn("link",
+            "get invalid module name from <" + file_path + ">, " +
+            "will not be easily accessed. " +
+            "only one \".nas\" suffix is required in the path."
+        );
+        return error_name;
+    }
+
+    // only get the file name as module name, directory path is not included
+    auto split_position = file_path.find_last_of("/");
+    // find "\\" in windows platform
+    if (split_position==std::string::npos) {
+        split_position = file_path.find_last_of("\\");
+    }
+
+    // split file path to get module name
+    auto module_name = split_position==std::string::npos?
+        file_path.substr(0, suffix_position):
+        file_path.substr(split_position+1, suffix_position-split_position-1);
+    
+    // check validation of module name
+    if (!module_name.length()) {
+        err.warn("link",
+            "get empty module name from <" + file_path + ">, " +
+            "will not be easily accessed."
+        );
+        return module_name;
+    }
+    if (std::isdigit(module_name[0]) ||
+        module_name.find(".")!=std::string::npos ||
+        module_name.find("-")!=std::string::npos) {
+        err.warn("link",
+            "get module <" + module_name + "> from <" + file_path + ">, " +
+            "will not be easily accessed."
+        );
+    }
+    return module_name;
+}
+
+return_expr* linker::generate_module_return(code_block* block) {
+    auto finder = std::make_unique<symbol_finder>();
+    auto result = new return_expr(block->get_location());
+    auto value = new hash_expr(block->get_location());
+    result->set_value(value);
+    for (const auto& i : finder->do_find(block)) {
+        // do not export symbol begins with '_'
+        if (i.name.length() && i.name[0]=='_') {
+            continue;
+        }
+        auto pair = new hash_pair(block->get_location());
+        pair->set_name(i.name);
+        pair->set_value(new identifier(block->get_location(), i.name));
+        value->add_member(pair);
+    }
+    return result;
+}
+
+definition_expr* linker::generate_module_definition(code_block* block) {
+    // generate ast node like this:
+    // var {module_name} = (func() {
+    //     ... # module itself
+    // })();
+    auto def = new definition_expr(block->get_location());
+    def->set_identifier(new identifier(
+        block->get_location(),
+        generate_module_name(block->get_location().file)
+    ));
+    
+    // (func() {...})();
+    auto call = new call_expr(block->get_location());
+    // func() {...}
+    auto func = new function(block->get_location());
+    func->set_code_block(block);
+    func->get_code_block()->add_expression(generate_module_return(block));
+    call->set_first(func);
+    call->add_call(new call_function(block->get_location()));
+
+    def->set_value(call);
+    return def;
+}
+
+void linker::load(code_block* program_root, const std::string& filename) {
+    // load imported modules
+    std::unordered_set<std::string> used_modules = {};
+    for (auto& import_node : program_root->get_expressions()) {
+        if (!import_check(import_node)) {
+            break;
+        }
+        // parse file and get ast
+        auto module_code_block = import_regular_file(import_node, used_modules);
+
+        // avoid repeatedly importing the same module in one file
+        const auto& module_path = module_code_block->get_location().file;
+        if (used_modules.count(module_path)) {
+            delete module_code_block;
+            auto replace_node = new null_expr(import_node->get_location());
+            // after importing the regular file as module, delete this node
+            delete import_node;
+            // and replace the node with null_expr node
+            import_node = replace_node;
+            continue;
+        }
+        used_modules.insert(module_path);
+        delete import_node;
+        // then we generate a function warping the code block,
+        // and export the necessary global symbols in this code block
+        // by generate a return statement, with a hashmap return value
+        import_node = generate_module_definition(module_code_block);
+    }
+}
+
+const error& linker::link(parse& parse, bool spath = false) {
+    // switch for showing path when errors occur
+    show_path_flag = spath;
+
+    // initializing file map
+    this_file = parse.tree()->get_location().file;
+    imported_files = {this_file};
+    module_load_stack = {this_file};
+
+    // scan root and import files
+    // then generate a new ast and return to import_ast
+    // dfs load file
+    auto library = import_nasal_lib();
+    // load used modules of this file
+    load(parse.tree(), this_file);
+    // then insert the whole tree into library tree root
+    merge_tree(library, parse.tree());
+    // swap tree root, and delete old root
+    delete parse.swap(library);
+
+    if (imported_files.size()>=UINT16_MAX) {
+        err.err("link",
+            "too many imported files: " +
+            std::to_string(imported_files.size())
+        );
+    }
+    return err;
+}
+
+}

src/nasal_import.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#ifndef _MSC_VER
+#include <unistd.h>
+#else
+#define _CRT_SECURE_NO_DEPRECATE 1
+#define _CRT_NONSTDC_NO_DEPRECATE 1
+#include <io.h>
+#endif
+
+#include "nasal.h"
+#include "ast/ast.h"
+#include "nasal_lexer.h"
+#include "nasal_parse.h"
+#include "symbol_finder.h"
+#include "util/fs.h"
+
+#include <cstring>
+#include <sstream>
+#include <vector>
+#include <unordered_set>
+
+namespace nasal {
+
+class linker {
+private:
+    const u32 MAX_RECURSION_DEPTH = 256;
+    bool show_path_flag;
+    std::string this_file;
+    error err;
+    std::vector<std::string> imported_files;
+    std::vector<std::string> module_load_stack;
+    std::vector<fs::path> envpath;
+
+private:
+    bool import_check(expr*);
+    bool check_exist_or_record_file(const std::string&);
+    bool check_self_import(const std::string&);
+    std::string generate_self_import_path(const std::string&);
+    void merge_tree(code_block*, code_block*);
+    std::string get_path(expr*);
+    std::string find_real_file_path(const std::string&, const span&);
+    code_block* import_regular_file(expr*, std::unordered_set<std::string>&);
+    code_block* import_nasal_lib();
+    std::string generate_module_name(const std::string&);
+    return_expr* generate_module_return(code_block*);
+    definition_expr* generate_module_definition(code_block*);
+    void load(code_block*, const std::string&);
+
+public:
+    linker();
+    const error& link(parse&, bool);
+    const auto& get_file_list() const {return imported_files;}
+};
+
+}

src/nasal_lexer.cpp

@@ -0,0 +1,458 @@
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4102)
+#endif
+
+#include "nasal_lexer.h"
+#include "repl/repl.h"
+#include "util/util.h"
+#include "util/fs.h"
+
+namespace nasal {
+
+bool lexer::skip(char c) {
+    return c==' ' || c=='\n' || c=='\t' || c=='\r' || c==0;
+}
+
+bool lexer::is_id(char c) {
+    return (c=='_') || std::isalpha(c) || (c<0);   
+}
+
+bool lexer::is_hex(char c) {
+    return std::isxdigit(c);
+}
+
+bool lexer::is_oct(char c) {
+    return '0'<=c && c<='7';
+}
+
+bool lexer::is_dec(char c) {
+    return std::isdigit(c);
+}
+
+bool lexer::is_str(char c) {
+    return c=='\'' || c=='\"' || c=='`';
+}
+
+bool lexer::is_quesmark(char c) {
+    return c=='?';
+}
+
+bool lexer::is_single_opr(char c) {
+    return (
+        c=='(' || c==')' || c=='[' || c==']' ||
+        c=='{' || c=='}' || c==',' || c==';' ||
+        c==':' || c=='`' || c=='@' || c=='%' ||
+        c=='$' || c=='\\'
+    );
+}
+
+bool lexer::is_calc_opr(char c) {
+    return (
+        c=='=' || c=='+' || c=='-' || c=='*' ||
+        c=='!' || c=='/' || c=='<' || c=='>' ||
+        c=='~' || c=='|' || c=='&' || c=='^'
+    );
+}
+
+void lexer::skip_note() {
+    // avoid note, after this process ptr will point to '\n'
+    // so next loop line counter+1
+    while (++ptr<res.size() && res[ptr]!='\n') {}
+}
+
+void lexer::err_char() {
+    ++column;
+    char c = res[ptr++];
+    err.err("lexer",
+        {line, column-1, line, column, filename},
+        "invalid character 0x" + util::char_to_hex(c)
+    );
+    ++invalid_char;
+}
+
+void lexer::open(const std::string& file) {
+    if (repl::info::instance()->in_repl_mode &&
+        repl::info::instance()->repl_file_name==file) {
+        err.load(file);
+        filename = file;
+        res = repl::info::instance()->repl_file_source;
+        return;
+    }
+
+    if (file.empty()) {
+        err.err("lexer", "empty input file");
+        err.chkerr();
+    }
+
+    // check file exsits and it is a regular file
+    if (!fs::is_regular(file)) {
+        err.err("lexer", "<"+file+"> is not a regular file");
+        err.chkerr();
+    }
+
+    // load
+    filename = file;
+    std::ifstream in(file, std::ios::binary);
+    if (in.fail()) {
+        err.err("lexer", "failed to open <" + file + ">");
+        res = "";
+        return;
+    }
+    err.load(file);
+    std::stringstream ss;
+    ss << in.rdbuf();
+    res = ss.str();
+}
+
+tok lexer::get_type(const std::string& str) {
+    // search token type from mapper
+    // if cannot find, just return null
+    return token_mapper.count(str)? token_mapper.at(str):tok::tk_null;
+}
+
+std::string lexer::utf8_gen() {
+    std::string str = "";
+    while (ptr<res.size() && res[ptr]<0) {
+        std::string tmp = "";
+        u32 nbytes = util::utf8_hdchk(res[ptr]);
+        if (!nbytes) {
+            ++ptr;
+            ++column;
+            continue;
+        }
+
+        tmp += res[ptr++];
+        for (u32 i = 0; i<nbytes; ++i, ++ptr) {
+            if (ptr<res.size() && (res[ptr]&0xc0)==0x80) {
+                tmp += res[ptr];
+            }
+        }
+
+        // utf8 character's total length is 1+nbytes
+        if (tmp.length()!=1+nbytes) {
+            ++column;
+            std::string utf_info = "0x" + util::char_to_hex(tmp[0]);
+            for (u32 i = 1; i<tmp.size(); ++i) {
+                utf_info += " 0x" + util::char_to_hex(tmp[i]);
+            }
+            err.err("lexer",
+                {line, column-1, line, column, filename},
+                "invalid utf-8 <"+utf_info+">"
+            );
+            ++invalid_char;
+        }
+        str += tmp;
+        // may have some problems because not all the unicode takes 2 space
+        column += 2;
+    }
+    return str;
+}
+
+token lexer::id_gen() {
+    u64 begin_line = line;
+    u64 begin_column = column;
+    std::string str = "";
+    while (ptr<res.size() && (is_id(res[ptr]) || is_dec(res[ptr]))) {
+        if (res[ptr]<0) { // utf-8
+            str += utf8_gen();
+        } else { // ascii
+            str += res[ptr++];
+            ++column;
+        }
+    }
+    tok type = get_type(str);
+    return {
+        {begin_line, begin_column, line, column, filename},
+        (type!=tok::tk_null)? type:tok::tk_id,
+        str
+    };
+}
+
+token lexer::num_gen() {
+    u64 begin_line = line;
+    u64 begin_column = column;
+    // generate hex number
+    if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='x') {
+        std::string str = "0x";
+        ptr += 2;
+        while (ptr<res.size() && is_hex(res[ptr])) {
+            str += res[ptr++];
+        }
+        column += str.length();
+        // "0x"
+        if (str.length()<3) {
+            err.err("lexer",
+                {begin_line, begin_column, line, column, filename},
+                "invalid number `"+str+"`"
+            );
+        }
+        return {
+            {begin_line, begin_column, line, column, filename},
+            tok::tk_num,
+            str
+        };
+    } else if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='o') { // generate oct number
+        std::string str = "0o";
+        ptr += 2;
+        while (ptr<res.size() && is_oct(res[ptr])) {
+            str += res[ptr++];
+        }
+        bool erfmt = false;
+        while (ptr<res.size() && (is_dec(res[ptr]) || is_hex(res[ptr]))) {
+            erfmt = true;
+            str += res[ptr++];
+        }
+        column += str.length();
+        if (str.length()==2 || erfmt) {
+            err.err("lexer",
+                {begin_line, begin_column, line, column, filename},
+                "invalid number `"+str+"`"
+            );
+        }
+        return {
+            {begin_line, begin_column, line, column, filename},
+            tok::tk_num,
+            str
+        };
+    }
+    // generate dec number
+    // dec number -> [0~9][0~9]*(.[0~9]*)(e|E(+|-)0|[1~9][0~9]*)
+    std::string str = "";
+    while (ptr<res.size() && is_dec(res[ptr])) {
+        str += res[ptr++];
+    }
+    if (ptr<res.size() && res[ptr]=='.') {
+        str += res[ptr++];
+        while (ptr<res.size() && is_dec(res[ptr])) {
+            str += res[ptr++];
+        }
+        // "xxxx." is not a correct number
+        if (str.back()=='.') {
+            column += str.length();
+            err.err("lexer",
+                {begin_line, begin_column, line, column, filename},
+                "invalid number `"+str+"`"
+            );
+            return {
+                {begin_line, begin_column, line, column, filename},
+                tok::tk_num,
+                "0"
+            };
+        }
+    }
+    if (ptr<res.size() && (res[ptr]=='e' || res[ptr]=='E')) {
+        str += res[ptr++];
+        if (ptr<res.size() && (res[ptr]=='-' || res[ptr]=='+')) {
+            str += res[ptr++];
+        }
+        while (ptr<res.size() && is_dec(res[ptr])) {
+            str += res[ptr++];
+        }
+        // "xxxe(-|+)" is not a correct number
+        if (str.back()=='e' || str.back()=='E' || str.back()=='-' || str.back()=='+') {
+            column += str.length();
+            err.err("lexer",
+                {begin_line, begin_column, line, column, filename},
+                "invalid number `"+str+"`"
+            );
+            return {
+                {begin_line, begin_column, line, column, filename},
+                tok::tk_num,
+                "0"
+            };
+        }
+    }
+    column += str.length();
+    return {
+        {begin_line, begin_column, line, column, filename},
+        tok::tk_num,
+        str
+    };
+}
+
+token lexer::str_gen() {
+    u64 begin_line = line;
+    u64 begin_column = column;
+    std::string str = "";
+    const char begin = res[ptr];
+    ++column;
+    while (++ptr<res.size() && res[ptr]!=begin) {
+        ++column;
+        if (res[ptr]=='\n') {
+            column = 0;
+            ++line;
+        }
+        if (res[ptr]=='\\' && ptr+1<res.size()) {
+            ++column;
+            ++ptr;
+            switch(res[ptr]) {
+                case '0': str += '\0';    break;
+                case 'a': str += '\a';    break;
+                case 'b': str += '\b';    break;
+                case 'e': str += '\033';  break;
+                case 't': str += '\t';    break;
+                case 'n': str += '\n';    break;
+                case 'v': str += '\v';    break;
+                case 'f': str += '\f';    break;
+                case 'r': str += '\r';    break;
+                case '?': str += '\?';    break;
+                case '\\':str += '\\';    break;
+                case '\'':str += '\'';    break;
+                case '\"':str += '\"';    break;
+                default:  str += res[ptr];break;
+            }
+            if (res[ptr]=='\n') {
+                column = 0;
+                ++line;
+            }
+            continue;
+        }
+        str += res[ptr];
+    }
+    // check if this string ends with a " or '
+    if (ptr++>=res.size()) {
+        err.err("lexer",
+            {begin_line, begin_column, line, column, filename},
+            "get EOF when generating string"
+        );
+        return {
+            {begin_line, begin_column, line, column, filename},
+            tok::tk_str,
+            str
+        };
+    }
+    ++column;
+
+    // if is not utf8, 1+utf8_hdchk should be 1
+    if (begin=='`' && str.length()!=1+util::utf8_hdchk(str[0])) {
+        err.err("lexer",
+            {begin_line, begin_column, line, column, filename},
+            "\'`\' is used for string including one character"
+        );
+    }
+    return {
+        {begin_line, begin_column, line, column, filename},
+        tok::tk_str,
+        str
+    };
+}
+
+token lexer::quesmark_gen() {
+    u64 begin_line = line;
+    u64 begin_column = column;
+    std::string str(1, res[ptr]);
+    ++column;
+    ++ptr;
+    if (ptr < res.size() && (res[ptr]=='?' || res[ptr]=='.')) {
+        str += res[ptr];
+        ++column;
+        ++ptr;
+    }
+    return {
+        {begin_line, begin_column, line, column, filename},
+        get_type(str),
+        str
+    };
+}
+
+token lexer::single_opr() {
+    u64 begin_line = line;
+    u64 begin_column = column;
+    std::string str(1, res[ptr]);
+    ++column;
+    tok type = get_type(str);
+    if (type==tok::tk_null) {
+        err.err("lexer",
+            {begin_line, begin_column, line, column, filename},
+            "invalid operator `"+str+"`"
+        );
+    }
+    ++ptr;
+    return {{begin_line, begin_column, line, column, filename}, type, str};
+}
+
+token lexer::dots() {
+    u64 begin_line = line;
+    u64 begin_column = column;
+    std::string str = ".";
+    if (ptr+2<res.size() && res[ptr+1]=='.' && res[ptr+2]=='.') {
+        str += "..";
+    }
+    ptr += str.length();
+    column += str.length();
+    return {{begin_line, begin_column, line, column, filename}, get_type(str), str};
+}
+
+token lexer::calc_opr() {
+    u64 begin_line = line;
+    u64 begin_column = column;
+    // get calculation operator
+    std::string str(1, res[ptr++]);
+    if (ptr<res.size() && res[ptr]=='=') {
+        str += res[ptr++];
+    }
+    column += str.length();
+    return {{begin_line, begin_column, line, column, filename}, get_type(str), str};
+}
+
+const error& lexer::scan(const std::string& file) {
+    line = 1;
+    column = 0;
+    ptr = 0;
+    toks = {};
+    open(file);
+
+    while (ptr<res.size()) {
+        while (ptr<res.size() && skip(res[ptr])) {
+            // these characters will be ignored, and '\n' will cause ++line
+            ++column;
+            if (res[ptr++]=='\n') {
+                ++line;
+                column = 0;
+            }
+        }
+        if (ptr>=res.size()) {
+            break;
+        }
+        if (is_id(res[ptr])) {
+            toks.push_back(id_gen());
+        } else if (is_dec(res[ptr])) {
+            toks.push_back(num_gen());
+        } else if (is_str(res[ptr])) {
+            toks.push_back(str_gen());
+        } else if (is_quesmark(res[ptr])) {
+            toks.push_back(quesmark_gen());
+        } else if (is_single_opr(res[ptr])) {
+            toks.push_back(single_opr());
+        } else if (res[ptr]=='.') {
+            toks.push_back(dots());
+        } else if (is_calc_opr(res[ptr])) {
+            toks.push_back(calc_opr());
+        } else if (res[ptr]=='#') {
+            skip_note();
+        } else {
+            err_char();
+        }
+        if (invalid_char>10) {
+            err.err("lexer", "too many invalid characters, stop");
+            break;
+        }
+    }
+    if (toks.size()) {
+        // eof token's location is the last token's location
+        toks.push_back({toks.back().loc, tok::tk_eof, "<eof>"});
+    } else {
+        // if token sequence is empty, generate a default location
+        toks.push_back({
+            {line, column, line, column, filename},
+            tok::tk_eof,
+            "<eof>"
+        });
+    }
+    res = "";
+    return err;
+}
+
+}

src/nasal_lexer.h

@@ -0,0 +1,198 @@
+#pragma once
+
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4102)
+#endif
+
+#include <cstring>
+#include <sstream>
+#include <vector>
+#include <unordered_map>
+
+#include "nasal.h"
+#include "nasal_err.h"
+
+namespace nasal {
+
+enum class tok {
+    tk_null = 0, // null token (default token type)
+    tk_num,      // number literal
+    tk_str,      // string literal
+    tk_id,       // identifier
+    tk_true,     // keyword true
+    tk_false,    // keyword false
+    tk_use,      // keyword use
+    tk_for,      // loop keyword for
+    tk_forindex, // loop keyword forindex
+    tk_foreach,  // loop keyword foreach
+    tk_while,    // loop keyword while
+    tk_var,      // keyword for definition
+    tk_func,     // keyword for definition of function
+    tk_brk,      // loop keyword break
+    tk_cont,     // loop keyword continue
+    tk_ret,      // function keyword return
+    tk_if,       // condition expression keyword if
+    tk_elsif,    // condition expression keyword elsif
+    tk_else,     // condition expression keyword else
+    tk_nil,      // nil literal
+    tk_lcurve,   // (
+    tk_rcurve,   // )
+    tk_lbracket, // [
+    tk_rbracket, // ]
+    tk_lbrace,   // {
+    tk_rbrace,   // }
+    tk_semi,     // ;
+    tk_and,      // operator and
+    tk_or,       // operator or
+    tk_comma,    // ,
+    tk_dot,      // .
+    tk_ellipsis, // ...
+    tk_quesmark, // ?
+    tk_quesques, // ??
+    tk_quesdot,  // ?.
+    tk_colon,    // :
+    tk_add,      // operator +
+    tk_sub,      // operator -
+    tk_mult,     // operator *
+    tk_div,      // operator /
+    tk_floater,  // operator ~ and binary operator ~
+    tk_btand,    // bitwise operator &
+    tk_btor,     // bitwise operator |
+    tk_btxor,    // bitwise operator ^
+    tk_not,      // operator !
+    tk_eq,       // operator =
+    tk_addeq,    // operator +=
+    tk_subeq,    // operator -=
+    tk_multeq,   // operator *=
+    tk_diveq,    // operator /=
+    tk_lnkeq,    // operator ~=
+    tk_btandeq,  // operator &=
+    tk_btoreq,   // operator |=
+    tk_btxoreq,  // operator ^=
+    tk_cmpeq,    // operator ==
+    tk_neq,      // operator !=
+    tk_less,     // operator <
+    tk_leq,      // operator <=
+    tk_grt,      // operator >
+    tk_geq,      // operator >=
+    tk_eof       // <eof> end of token list
+};
+
+struct token {
+    span loc;        // location
+    tok type;        // token type
+    std::string str; // content
+
+    token() = default;
+    token(const token&) = default;
+};
+
+class lexer {
+private:
+    u64 line;
+    u64 column;
+    usize ptr;
+    std::string filename;
+    std::string res;
+
+private:
+    error err;
+    u64 invalid_char;
+    std::vector<token> toks;
+
+private:
+    const std::unordered_map<std::string, tok> token_mapper = {
+        {"use"     , tok::tk_use     },
+        {"true"    , tok::tk_true    },
+        {"false"   , tok::tk_false   },
+        {"for"     , tok::tk_for     },
+        {"forindex", tok::tk_forindex},
+        {"foreach" , tok::tk_foreach },
+        {"while"   , tok::tk_while   },
+        {"var"     , tok::tk_var     },
+        {"func"    , tok::tk_func    },
+        {"break"   , tok::tk_brk     },
+        {"continue", tok::tk_cont    },
+        {"return"  , tok::tk_ret     },
+        {"if"      , tok::tk_if      },
+        {"elsif"   , tok::tk_elsif   },
+        {"else"    , tok::tk_else    },
+        {"nil"     , tok::tk_nil     },
+        {"("       , tok::tk_lcurve  },
+        {")"       , tok::tk_rcurve  },
+        {"["       , tok::tk_lbracket},
+        {"]"       , tok::tk_rbracket},
+        {"{"       , tok::tk_lbrace  },
+        {"}"       , tok::tk_rbrace  },
+        {";"       , tok::tk_semi    },
+        {"and"     , tok::tk_and     },
+        {"or"      , tok::tk_or      },
+        {","       , tok::tk_comma   },
+        {"."       , tok::tk_dot     },
+        {"..."     , tok::tk_ellipsis},
+        {"?"       , tok::tk_quesmark},
+        {"??"      , tok::tk_quesques},
+        {"?."      , tok::tk_quesdot },
+        {":"       , tok::tk_colon   },
+        {"+"       , tok::tk_add     },
+        {"-"       , tok::tk_sub     },
+        {"*"       , tok::tk_mult    },
+        {"/"       , tok::tk_div     },
+        {"~"       , tok::tk_floater },
+        {"&"       , tok::tk_btand   },
+        {"|"       , tok::tk_btor    },
+        {"^"       , tok::tk_btxor   },
+        {"!"       , tok::tk_not     },
+        {"="       , tok::tk_eq      },
+        {"+="      , tok::tk_addeq   },
+        {"-="      , tok::tk_subeq   },
+        {"*="      , tok::tk_multeq  },
+        {"/="      , tok::tk_diveq   },
+        {"~="      , tok::tk_lnkeq   },
+        {"&="      , tok::tk_btandeq },
+        {"|="      , tok::tk_btoreq  },
+        {"^="      , tok::tk_btxoreq },
+        {"=="      , tok::tk_cmpeq   },
+        {"!="      , tok::tk_neq     },
+        {"<"       , tok::tk_less    },
+        {"<="      , tok::tk_leq     },
+        {">"       , tok::tk_grt     },
+        {">="      , tok::tk_geq     }
+    };
+
+private:
+    tok get_type(const std::string&);
+    bool skip(char);
+    bool is_id(char);
+    bool is_hex(char);
+    bool is_oct(char);
+    bool is_dec(char);
+    bool is_str(char);
+    bool is_quesmark(char);
+    bool is_single_opr(char);
+    bool is_calc_opr(char);
+
+    void skip_note();
+    void err_char();
+
+    void open(const std::string&);
+    std::string utf8_gen();
+    token id_gen();
+    token num_gen();
+    token str_gen();
+    token quesmark_gen();
+    token single_opr();
+    token dots();
+    token calc_opr();
+
+public:
+    lexer(): line(1), column(0), ptr(0),
+             filename(""), res(""),
+             invalid_char(0) {}
+    const error& scan(const std::string&);
+    const auto& result() const {return toks;}
+};
+
+}

src/nasal_opcode.cpp

@@ -0,0 +1,165 @@
+#include "nasal_opcode.h"
+#include "util/util.h"
+
+namespace nasal {
+
+void codestream::set(const f64* number_list,
+                     const std::string* string_list,
+                     const std::unordered_map<std::string, u64>& globals,
+                     const nasal_builtin_table* native_table,
+                     const std::string* file_list) {
+    const_number = number_list;
+    const_string = string_list;
+    natives = native_table;
+    files = file_list;
+
+    global_variable.resize(globals.size());
+    for (auto& [name, index]: globals) {
+        global_variable[index] = name;
+    }
+}
+
+void codestream::set(const f64* number_list,
+                     const std::string* string_list,
+                     const std::vector<std::string>& globals,
+                     const nasal_builtin_table* native_table,
+                     const std::string* file_list) {
+    const_number = number_list;
+    const_string = string_list;
+    natives = native_table;
+    files = file_list;
+
+    global_variable = globals;
+}
+
+void codestream::dump(std::ostream& out) const {
+    using std::setw;
+    using std::setfill;
+    using std::hex;
+    using std::dec;
+
+    const auto op = code.op;
+    const auto num = code.num;
+
+    // dump operand index and bytecode(hex format)
+    out << hex << "0x"
+        << setw(8) << setfill('0') << index << "    "
+        << setw(2) << setfill('0') << static_cast<u32>(op) << ":" << dec;
+
+    // dump immediate number(hex format)
+    for (i32 i = 64-8; i>=0; i -= 8) {
+        auto this_byte = ((num>>i)&0xff);
+        out << hex << setw(2) << setfill('0') << this_byte << dec << " ";
+    }
+
+    // dump operand name
+    out << "    " << operand_name_table.at(static_cast<opcode_type>(op)) << "  ";
+
+    switch(op) {
+        case op_addeq:
+        case op_subeq:
+        case op_muleq:
+        case op_diveq:
+        case op_lnkeq:
+        case op_meq:
+        case op_btandeq:
+        case op_btoreq:
+        case op_btxoreq:
+            out << hex << "0x" << num << dec << " sp-" << num;
+            break;
+        case op_addeqc:
+        case op_subeqc:
+        case op_muleqc:
+        case op_diveqc:
+            out << hex << "0x" << num << dec;
+            out << " (" << const_number[num] << ")";
+            break;
+        case op_lnkeqc:
+            out << hex << "0x" << num << dec;
+            out << " (\"" << util::rawstr(const_string[num], 32) << "\")";
+            break;
+        case op_addecp:
+        case op_subecp:
+        case op_mulecp:
+        case op_divecp:
+            out << hex << "0x" << num << dec;
+            out << " (" << const_number[num] << ") sp-1";
+            break;
+        case op_lnkecp:
+            out << hex << "0x" << num << dec;
+            out << " (\"" << util::rawstr(const_string[num], 32) << "\") sp-1";
+            break;
+        case op_addc:
+        case op_subc:
+        case op_mulc:
+        case op_divc:
+        case op_lessc:
+        case op_leqc:
+        case op_grtc:
+        case op_geqc:
+        case op_pnum:
+            out << hex << "0x" << num << dec;
+            out << " (" << const_number[num] << ")";
+            break;
+        case op_callvi:
+        case op_newv:
+        case op_callfv:
+        case op_repl:
+        case op_intl:
+        case op_findex:
+        case op_feach:
+        case op_newf:
+        case op_jmp:
+        case op_jt:
+        case op_jf:
+        case op_calll:
+        case op_mcalll:
+        case op_loadl:
+            out << hex << "0x" << num << dec; break;
+        case op_loadg:
+        case op_mcallg:
+        case op_callg:
+            out << hex << "0x" << num << dec;
+            out << " (" << util::rawstr(global_variable[num], 32) << ")";
+            break;
+        case op_callb:
+            out << hex << "0x" << num << dec;
+            out << " <" << natives[num].name << "@0x";
+            out << hex << reinterpret_cast<u64>(natives[num].func) << dec;
+            out << ">";
+            break;
+        case op_upval:
+        case op_mupval:
+        case op_loadu:
+            out << hex << "0x" << ((num>>16)&0xffff)
+                << "[0x" << (num&0xffff) << "]" << dec; break;
+        case op_happ:
+        case op_pstr:
+        case op_lnkc:
+        case op_callh:
+        case op_mcallh:
+        case op_para:
+        case op_deft:
+        case op_dyn:
+            out << hex << "0x" << num << dec;
+            out << " (\"" << util::rawstr(const_string[num], 32) << "\")";
+            break;
+        default:
+            if (files) {
+                out << hex << "0x" << num << dec;
+            }
+            break;
+    }
+
+    // if file list is loaded, dump file location info
+    if (files) {
+        out << " (" << files[code.fidx] << ":" << code.line << ")";
+    }
+}
+
+std::ostream& operator<<(std::ostream& out, const codestream& ins) {
+    ins.dump(out);
+    return out;
+}
+
+}

src/nasal_opcode.h

@@ -0,0 +1,232 @@
+#pragma once
+
+#include "nasal.h"
+#include "natives/builtin.h"
+
+#include <iostream>
+#include <vector>
+#include <cstring>
+#include <sstream>
+#include <unordered_map>
+
+namespace nasal {
+
+enum opcode_type: u8 {
+    op_exit,    // stop the virtual machine
+    op_repl,    // in repl mode: print value on stack top
+    op_intl,    // local scope size
+    op_loadg,   // load global value
+    op_loadl,   // load local value
+    op_loadu,   // load upvalue
+    op_dup,     // copy value on stack top
+    op_pnum,    // push constant number to the stack
+    op_pnil,    // push constant nil to the stack
+    op_pstr,    // push constant std::string to the stack
+    op_newv,    // push new vector with initial values from stack
+    op_newh,    // push new hash to the stack
+    op_newf,    // push new function to the stack
+    op_happ,    // hash append
+    op_para,    // normal  parameter
+    op_deft,    // default parameter
+    op_dyn,     // dynamic parameter
+    op_lnot,    // ! logical negation
+    op_usub,    // - negation
+    op_bnot,    // ~ bitwise not static_cast<i32>
+    op_btor,    // | bitwise or
+    op_btxor,   // ^ bitwise xor
+    op_btand,   // & bitwise and
+    op_add,     // +
+    op_sub,     // -
+    op_mul,     // *
+    op_div,     // /
+    op_lnk,     // ~
+    op_addc,    // + const
+    op_subc,    // - const
+    op_mulc,    // * const
+    op_divc,    // / const
+    op_lnkc,    // ~ const
+    op_addeq,   // += maybe pop stack top
+    op_subeq,   // -= maybe pop stack top
+    op_muleq,   // *= maybe pop stack top
+    op_diveq,   // /= maybe pop stack top
+    op_lnkeq,   // ~= maybe pop stack top
+    op_btandeq, // &= maybe pop stack top
+    op_btoreq,  // |= maybe pop stack top
+    op_btxoreq, // ^= maybe pop stack top
+    op_addeqc,  // += const don't pop stack top
+    op_subeqc,  // -= const don't pop stack top
+    op_muleqc,  // *= const don't pop stack top
+    op_diveqc,  // /= const don't pop stack top
+    op_lnkeqc,  // ~= const don't pop stack top
+    op_addecp,  // += const and pop stack top
+    op_subecp,  // -= const and pop stack top
+    op_mulecp,  // *= const and pop stack top
+    op_divecp,  // /= const and pop stack top
+    op_lnkecp,  // ~= concat const std::string and pop stack top
+    op_meq,     // = maybe pop stack top
+    op_eq,      // == compare operator
+    op_neq,     // != compare operator
+    op_less,    // < compare operator
+    op_leq,     // <= compare operator
+    op_grt,     // > compare operator
+    op_geq,     // >= compare operator
+    op_lessc,    // < const compare operator
+    op_leqc,    // <= const compare operator
+    op_grtc,    // > const compare operator
+    op_geqc,    // >= const compare operator
+    op_pop,     // pop a value out of stack top
+    op_jmp,     // jump absolute address with no condition
+    op_jt,      // used in operator and/or, jmp when condition is true and DO NOT POP
+    op_jf,      // used in conditional/loop, jmp when condition is false and POP STACK
+    op_cnt,     // add counter for forindex/foreach
+    op_findex,  // index counter on the top of forindex_stack plus 1
+    op_feach,   // index counter on the top of forindex_stack plus 1 and get the value in vector
+    op_callg,   // get value in global scope
+    op_calll,   // get value in local scope
+    op_upval,   // get value in closure, high 16 as the index of upval, low 16 as the index of local
+    op_callv,   // call vec[index]
+    op_callvi,  // call vec[immediate] (used in multi-assign/multi-define)
+    op_callh,   // call hash.label
+    op_callfv,  // call function(vector as parameters)
+    op_callfh,  // call function(hash as parameters)
+    op_callb,   // call native functions
+    op_slcbeg,  // begin of slice like: vec[1, 2, 3:6, 0, -1]
+    op_slcend,  // end of slice
+    op_slc,     // slice like vec[1]
+    op_slc2,    // slice like vec[nil:10]
+    op_mcallg,  // get memory space of value in global scope
+    op_mcalll,  // get memory space of value in local scope
+    op_mupval,  // get memory space of value in closure
+    op_mcallv,  // get memory space of vec[index]
+    op_mcallh,  // get memory space of hash.label
+    op_ret      // return
+};
+
+static std::unordered_map<opcode_type, std::string> operand_name_table = {
+    {opcode_type::op_exit,    "exit  "},
+    {opcode_type::op_repl,    "repl  "},
+    {opcode_type::op_intl,    "intl  "},
+    {opcode_type::op_loadg,   "loadg "},
+    {opcode_type::op_loadl,   "loadl "},
+    {opcode_type::op_loadu,   "loadu "},
+    {opcode_type::op_dup,     "dup   "},
+    {opcode_type::op_pnum,    "pnum  "},
+    {opcode_type::op_pnil,    "pnil  "},
+    {opcode_type::op_pstr,    "pstr  "},
+    {opcode_type::op_newv,    "newv  "},
+    {opcode_type::op_newh,    "newh  "},
+    {opcode_type::op_newf,    "newf  "},
+    {opcode_type::op_happ,    "happ  "},
+    {opcode_type::op_para,    "para  "},
+    {opcode_type::op_deft,    "def   "},
+    {opcode_type::op_dyn,     "dyn   "},
+    {opcode_type::op_lnot,    "lnot  "},
+    {opcode_type::op_usub,    "usub  "},
+    {opcode_type::op_bnot,    "bitnot"},
+    {opcode_type::op_btor,    "bitor "},
+    {opcode_type::op_btxor,   "bitxor"},
+    {opcode_type::op_btand,   "bitand"},
+    {opcode_type::op_add,     "add   "},
+    {opcode_type::op_sub,     "sub   "},
+    {opcode_type::op_mul,     "mult  "},
+    {opcode_type::op_div,     "div   "},
+    {opcode_type::op_lnk,     "lnk   "},
+    {opcode_type::op_addc,    "addc  "},
+    {opcode_type::op_subc,    "subc  "},
+    {opcode_type::op_mulc,    "multc "},
+    {opcode_type::op_divc,    "divc  "},
+    {opcode_type::op_lnkc,    "lnkc  "},
+    {opcode_type::op_addeq,   "addeq "},
+    {opcode_type::op_subeq,   "subeq "},
+    {opcode_type::op_muleq,   "muleq "},
+    {opcode_type::op_diveq,   "diveq "},
+    {opcode_type::op_lnkeq,   "lnkeq "},
+    {opcode_type::op_btandeq, "bandeq"},
+    {opcode_type::op_btoreq,  "boreq "},
+    {opcode_type::op_btxoreq, "bxoreq"},
+    {opcode_type::op_addeqc,  "addeqc"},
+    {opcode_type::op_subeqc,  "subeqc"},
+    {opcode_type::op_muleqc,  "muleqc"},
+    {opcode_type::op_diveqc,  "diveqc"},
+    {opcode_type::op_lnkeqc,  "lnkeqc"},
+    {opcode_type::op_addecp,  "addecp"},
+    {opcode_type::op_subecp,  "subecp"},
+    {opcode_type::op_mulecp,  "mulecp"},
+    {opcode_type::op_divecp,  "divecp"},
+    {opcode_type::op_lnkecp,  "lnkecp"},
+    {opcode_type::op_meq,     "meq   "},
+    {opcode_type::op_eq,      "eq    "},
+    {opcode_type::op_neq,     "neq   "},
+    {opcode_type::op_less,    "less  "},
+    {opcode_type::op_leq,     "leq   "},
+    {opcode_type::op_grt,     "grt   "},
+    {opcode_type::op_geq,     "geq   "},
+    {opcode_type::op_lessc,   "lessc "},
+    {opcode_type::op_leqc,    "leqc  "},
+    {opcode_type::op_grtc,    "grtc  "},
+    {opcode_type::op_geqc,    "geqc  "},
+    {opcode_type::op_pop,     "pop   "},
+    {opcode_type::op_jmp,     "jmp   "},
+    {opcode_type::op_jt,      "jt    "},
+    {opcode_type::op_jf,      "jf    "},
+    {opcode_type::op_cnt,     "cnt   "},
+    {opcode_type::op_findex,  "findx "},
+    {opcode_type::op_feach,   "feach "},
+    {opcode_type::op_callg,   "callg "},
+    {opcode_type::op_calll,   "calll "},
+    {opcode_type::op_upval,   "upval "},
+    {opcode_type::op_callv,   "callv "},
+    {opcode_type::op_callvi,  "callvi"},
+    {opcode_type::op_callh,   "callh "},
+    {opcode_type::op_callfv,  "callfv"},
+    {opcode_type::op_callfh,  "callfh"},
+    {opcode_type::op_callb,   "callb "},
+    {opcode_type::op_slcbeg,  "slcbeg"},
+    {opcode_type::op_slcend,  "slcend"},
+    {opcode_type::op_slc,     "slice "},
+    {opcode_type::op_slc2,    "slice2"},
+    {opcode_type::op_mcallg,  "mcallg"},
+    {opcode_type::op_mcalll,  "mcalll"},
+    {opcode_type::op_mupval,  "mupval"},
+    {opcode_type::op_mcallv,  "mcallv"},
+    {opcode_type::op_mcallh,  "mcallh"},
+    {opcode_type::op_ret,     "ret   "}
+};
+
+struct opcode {
+    u8  op;   // opcode
+    u16 fidx; // source code file index
+    u64 num;  // immediate num
+    u64 line; // location line of source code
+    opcode() = default;
+    opcode(const opcode&) = default;
+    opcode& operator=(const opcode&) = default;
+};
+
+class codestream {
+private:
+    opcode code;
+    const u64 index;
+    inline static const f64* const_number = nullptr;
+    inline static const std::string* const_string = nullptr;
+    inline static const nasal_builtin_table* natives = nullptr;
+    inline static const std::string* files = nullptr;
+    inline static std::vector<std::string> global_variable;
+    
+public:
+    codestream(const opcode& c, const u64 i): code(c), index(i) {}
+    static void set(const f64*,
+                    const std::string*,
+                    const std::unordered_map<std::string, u64>&,
+                    const nasal_builtin_table*,
+                    const std::string* file_list = nullptr);
+    static void set(const f64*,
+                    const std::string*,
+                    const std::vector<std::string>&,
+                    const nasal_builtin_table*,
+                    const std::string* file_list = nullptr);
+    void dump(std::ostream&) const;
+    friend std::ostream& operator<<(std::ostream&, const codestream&);
+};
+
+}

src/nasal_parse.h

@@ -0,0 +1,169 @@
+#pragma once
+
+#include <unordered_map>
+
+#include "nasal.h"
+#include "ast/ast.h"
+#include "nasal_lexer.h"
+#include "nasal_err.h"
+
+namespace nasal {
+
+class parse {
+
+#define thisspan (toks[ptr].loc)
+#define prevspan (ptr!=0? toks[ptr-1].loc:toks[ptr].loc)
+
+private:
+    u64 ptr;
+    u64 in_func_depth; // count function block
+    u64 in_loop_depth; // count loop block
+    const token* toks;
+    code_block* root;
+    error err;
+
+private:
+    const std::unordered_map<tok, std::string> token_name_mapper = {
+        {tok::tk_true    , "true"    },
+        {tok::tk_false   , "false"   },
+        {tok::tk_use     , "use"     },
+        {tok::tk_for     , "for"     },
+        {tok::tk_forindex, "forindex"},
+        {tok::tk_foreach , "foreach" },
+        {tok::tk_while   , "while"   },
+        {tok::tk_var     , "var"     },
+        {tok::tk_func    , "func"    },
+        {tok::tk_brk     , "break"   },
+        {tok::tk_cont    , "continue"},
+        {tok::tk_ret     , "return"  },
+        {tok::tk_if      , "if"      },
+        {tok::tk_elsif   , "elsif"   },
+        {tok::tk_else    , "else"    },
+        {tok::tk_nil     , "nil"     },
+        {tok::tk_lcurve  , "("       },
+        {tok::tk_rcurve  , ")"       },
+        {tok::tk_lbracket, "["       },
+        {tok::tk_rbracket, "]"       },
+        {tok::tk_lbrace  , "{"       },
+        {tok::tk_rbrace  , "}"       },
+        {tok::tk_semi    , ";"       },
+        {tok::tk_and     , "and"     },
+        {tok::tk_or      , "or"      },
+        {tok::tk_comma   , ","       },
+        {tok::tk_dot     , "."       },
+        {tok::tk_ellipsis, "..."     },
+        {tok::tk_quesmark, "?"       },
+        {tok::tk_quesques, "??"      },
+        {tok::tk_quesdot , "?."      },
+        {tok::tk_colon   , ":"       },
+        {tok::tk_add     , "+"       },
+        {tok::tk_sub     , "-"       },
+        {tok::tk_mult    , "*"       },
+        {tok::tk_div     , "/"       },
+        {tok::tk_floater , "~"       },
+        {tok::tk_btand   , "&"       },
+        {tok::tk_btor    , "|"       },
+        {tok::tk_btxor   , "^"       },
+        {tok::tk_not     , "!"       },
+        {tok::tk_eq      , "="       },
+        {tok::tk_addeq   , "+="      },
+        {tok::tk_subeq   , "-="      },
+        {tok::tk_multeq  , "*="      },
+        {tok::tk_diveq   , "/="      },
+        {tok::tk_lnkeq   , "~="      },
+        {tok::tk_btandeq , "&="      },
+        {tok::tk_btoreq  , "|="      },
+        {tok::tk_btxoreq , "^="      },
+        {tok::tk_cmpeq   , "=="      },
+        {tok::tk_neq     , "!="      },
+        {tok::tk_less    , "<"       },
+        {tok::tk_leq     , "<="      },
+        {tok::tk_grt     , ">"       },
+        {tok::tk_geq     , ">="      }
+    };
+
+private:
+    void die(const span&, const std::string&);
+    void next();
+    void match(tok, const char* info = nullptr);
+    bool lookahead(tok);
+    bool lookahead_expression();
+    bool is_call(tok);
+    bool check_comma(const tok*);
+    bool check_tuple();
+    bool check_func_end(expr*);
+    bool check_in_curve_multi_definition();
+    bool check_special_call();
+    bool need_semi_check(expr*);
+    void update_location(expr*);
+
+private:
+    use_stmt* use_stmt_gen();
+    null_expr* null();
+    nil_expr* nil();
+    number_literal* num();
+    string_literal* str();
+    identifier* id();
+    bool_literal* bools();
+    vector_expr* vec();
+    hash_expr* hash();
+    hash_pair* pair();
+    function* func();
+    void params(function*);
+    expr* lcurve_expr();
+    expr* expression();
+    code_block* expression_block();
+    expr* calc();
+    expr* bitwise_or();
+    expr* bitwise_xor();
+    expr* bitwise_and();
+    expr* or_expr();
+    expr* and_expr();
+    expr* cmp_expr();
+    expr* null_chain_expr();
+    expr* additive_expr();
+    expr* multive_expr();
+    unary_operator* unary();
+    expr* scalar();
+    call* call_scalar();
+    call_hash* callh();
+    null_access* null_access_call();
+    call_vector* callv();
+    call_function* callf();
+    slice_vector* subvec();
+    expr* definition();
+    multi_identifier* incurve_def();
+    multi_identifier* outcurve_def();
+    multi_identifier* multi_id();
+    tuple_expr* multi_scalar();
+    multi_assign* multi_assignment();
+    expr* loop();
+    while_expr* while_loop();
+    for_expr* for_loop();
+    forei_expr* forei_loop();
+    iter_expr* iter_gen();
+    condition_expr* cond();
+    continue_expr* continue_expression();
+    break_expr* break_expression();
+    return_expr* return_expression();
+
+public:
+    code_block* tree() {return root;}
+
+    // swap root pointer with another pointer(maybe nullptr)
+    code_block* swap(code_block* another) {
+        auto res = root;
+        root = another;
+        return res;
+    }
+
+public:
+    parse(): ptr(0), in_func_depth(0),
+             in_loop_depth(0), toks(nullptr),
+             root(nullptr) {}
+    ~parse() {delete root;}
+    const error& compile(const lexer&);
+    static void easter_egg();
+};
+
+}

src/nasal_type.cpp

@@ -0,0 +1,281 @@
+#include "nasal_type.h"
+#include "util/util.h"
+
+#include <cstring>
+#include <sstream>
+
+namespace nasal {
+
+std::ostream& operator<<(std::ostream& out, nas_vec& vec) {
+    if (!vec.elems.size() || vec.printed) {
+        out << (vec.elems.size()? "[..]":"[]");
+        return out;
+    }
+    vec.printed = true;
+    usize iter = 0, size = vec.elems.size();
+    out << "[";
+    for (auto& i:vec.elems) {
+        out << i << ",]"[(++iter)==size];
+    }
+    vec.printed = false;
+    return out;
+}
+
+var nas_hash::get_value(const std::string& key) {
+    if (elems.count(key)) {
+        return elems.at(key);
+    }
+    if (!elems.count("parents")) {
+        return var::none();
+    }
+
+    auto ret = var::none();
+    auto& val = elems.at("parents");
+    if (!val.is_vec()) {
+        return ret;
+    }
+    for (auto& i : val.vec().elems) {
+        if (i.is_hash()) {
+            ret = i.hash().get_value(key);
+        }
+        if (!ret.is_none()) {
+            return ret;
+        }
+    }
+    return ret;
+}
+
+var* nas_hash::get_memory(const std::string& key) {
+    if (elems.count(key)) {
+        return &elems.at(key);
+    }
+    if (!elems.count("parents")) {
+        return nullptr;
+    }
+
+    var* addr = nullptr;
+    var& val = elems.at("parents");
+    if (!val.is_vec()) {
+        return addr;
+    }
+    for (auto& i : val.vec().elems) {
+        // recursively search key in `parents`
+        if (i.is_hash()) {
+            addr = i.hash().get_memory(key);
+        }
+        if (addr) {
+            return addr;
+        }
+    }
+    return addr;
+}
+
+std::ostream& operator<<(std::ostream& out, nas_hash& hash) {
+    if (!hash.elems.size() || hash.printed) {
+        out << (hash.elems.size()? "{..}":"{}");
+        return out;
+    }
+
+    // mark print, to avoid infinite recursion
+    hash.printed = true;
+
+    static const char* sep[] = {", ", "}"};
+    usize iter = 0, size = hash.elems.size();
+    out << "{";
+    for (auto& i : hash.elems) {
+        out << i.first << ": " << i.second << sep[(++iter)==size];
+    }
+
+    // restore flag
+    hash.printed = false;
+    return out;
+}
+
+std::ostream& operator<<(std::ostream& out, nas_func& func) {
+    out << "func(";
+    
+    std::vector<std::string> argument_list = {};
+    argument_list.resize(func.keys.size());
+    for (const auto& key : func.keys) {
+        argument_list[key.second-1] = key.first;
+    }
+
+    for (const auto& key : argument_list) {
+        out << key;
+        if (key != argument_list.back()) {
+            out << ", ";
+        }
+    }
+    if (func.dynamic_parameter_index>=0) {
+        out << (argument_list.size()? ", ":"");
+        out << func.dynamic_parameter_name << "...";
+    }
+
+    out << ") {..}";
+    return out;
+}
+
+void nas_func::clear() {
+    dynamic_parameter_index = -1;
+    local.clear();
+    upval.clear();
+    keys.clear();
+}
+
+void nas_ghost::set(const std::string& ghost_type_name,
+                    destructor destructor_pointer,
+                    marker gc_marker_pointer,
+                    void* ghost_pointer) {
+    type_name = ghost_type_name;
+    destructor_function = destructor_pointer;
+    gc_mark_function = gc_marker_pointer;
+    pointer = ghost_pointer;
+}
+
+void nas_ghost::clear() {
+    // do nothing if pointer is null
+    if (!pointer) {
+        return;
+    }
+
+    // do clear pointer if destructor function pointer is null
+    if (!destructor_function) {
+        type_name = "";
+        pointer = nullptr;
+        return;
+    }
+
+    // do destruction
+    destructor_function(pointer);
+    type_name = "";
+    pointer = nullptr;
+    destructor_function = nullptr;
+    gc_mark_function = nullptr;
+}
+
+std::ostream& operator<<(std::ostream& out, const nas_ghost& ghost) {
+    out << "<" << ghost.get_ghost_name();
+    out << "@0x" << std::hex << ghost.convert<u64>() << std::dec << ">";
+    return out;
+}
+
+std::ostream& operator<<(std::ostream& out, const nas_co& co) {
+    out << "<coroutine at 0x" << std::hex;
+    out << reinterpret_cast<u64>(&co) << std::dec << ">";
+    return out;
+}
+
+var nas_map::get_value(const std::string& key) {
+    if (mapper.count(key)) {
+        return *mapper.at(key);
+    }
+    return var::none();
+}
+
+var* nas_map::get_memory(const std::string& key) {
+    if (mapper.count(key)) {
+        return mapper.at(key);
+    }
+    return nullptr;
+}
+
+std::ostream& operator<<(std::ostream& out, nas_map& mp) {
+    if (!mp.mapper.size() || mp.printed) {
+        out << (mp.mapper.size()? "{..}":"{}");
+        return out;
+    }
+
+    // mark print, to avoid infinite recursion
+    mp.printed = true;
+
+    static const char* sep[] = {", ", "}"};
+    usize iter = 0, size = mp.mapper.size();
+    out << "{";
+    for (auto& i : mp.mapper) {
+        out << i.first << ": " << *i.second << sep[(++iter)==size];
+    }
+
+    // restore flag
+    mp.printed = false;
+    return out;
+}
+
+nas_val::nas_val(vm_type val_type) {
+    mark = gc_status::collected;
+    type = val_type;
+    immutable = 0;
+    switch(val_type) {
+        case vm_type::vm_str:   ptr.str = new std::string; break;
+        case vm_type::vm_vec:   ptr.vec = new nas_vec;     break;
+        case vm_type::vm_hash:  ptr.hash = new nas_hash;   break;
+        case vm_type::vm_func:  ptr.func = new nas_func;   break;
+        case vm_type::vm_upval: ptr.upval = new nas_upval; break;
+        case vm_type::vm_ghost: ptr.obj = new nas_ghost;   break;
+        case vm_type::vm_co:    ptr.co = new nas_co;       break;
+        case vm_type::vm_map:   ptr.map = new nas_map;     break;
+        default: break;
+    }
+}
+
+nas_val::~nas_val() {
+    switch(type) {
+        case vm_type::vm_str:   delete ptr.str;   break;
+        case vm_type::vm_vec:   delete ptr.vec;   break;
+        case vm_type::vm_hash:  delete ptr.hash;  break;
+        case vm_type::vm_func:  delete ptr.func;  break;
+        case vm_type::vm_upval: delete ptr.upval; break;
+        case vm_type::vm_ghost: delete ptr.obj;   break;
+        case vm_type::vm_co:    delete ptr.co;    break;
+        case vm_type::vm_map:   delete ptr.map;   break;
+        default: break;
+    }
+    type = vm_type::vm_nil;
+}
+
+void nas_val::clear() {
+    switch(type) {
+        case vm_type::vm_str:   ptr.str->clear();        break;
+        case vm_type::vm_vec:   ptr.vec->elems.clear();  break;
+        case vm_type::vm_hash:  ptr.hash->elems.clear(); break;
+        case vm_type::vm_func:  ptr.func->clear();       break;
+        case vm_type::vm_upval: ptr.upval->clear();      break;
+        case vm_type::vm_ghost: ptr.obj->clear();        break;
+        case vm_type::vm_co:    ptr.co->clear();         break;
+        case vm_type::vm_map:   ptr.map->clear();        break;
+        default: break;
+    }
+}
+
+std::string var::to_str() {
+    if (type==vm_type::vm_str) {
+        return str();
+    } else if (type==vm_type::vm_num) {
+        auto tmp = std::to_string(num());
+        tmp.erase(tmp.find_last_not_of('0') + 1, std::string::npos);
+        tmp.erase(tmp.find_last_not_of('.') + 1, std::string::npos);
+        return tmp;
+    }
+
+    std::stringstream ss;
+    ss << *this;
+    return ss.str();
+}
+
+std::ostream& operator<<(std::ostream& out, var& ref) {
+    switch(ref.type) {
+        case vm_type::vm_none:  out << "undefined"; break;
+        case vm_type::vm_nil:   out << "nil";       break;
+        case vm_type::vm_num:   out << ref.val.num; break;
+        case vm_type::vm_str:   out << ref.str();   break;
+        case vm_type::vm_vec:   out << ref.vec();   break;
+        case vm_type::vm_hash:  out << ref.hash();  break;
+        case vm_type::vm_func:  out << ref.func();  break;
+        case vm_type::vm_ghost: out << ref.ghost(); break;
+        case vm_type::vm_co:    out << ref.co();    break;
+        case vm_type::vm_map:   out << ref.map();   break;
+        default: break;
+    }
+    return out;
+}
+
+}

src/nasal_type.h

@@ -0,0 +1,398 @@
+#pragma once
+
+#include "nasal.h"
+#include "util/util.h"
+
+#include <cstring>
+#include <sstream>
+#include <iostream>
+#include <vector>
+#include <unordered_map>
+
+namespace nasal {
+
+enum class vm_type: u8 {
+    /* none-gc object */
+    vm_none = 0, // error type
+    vm_cnt,      // counter for forindex/foreach loop
+    vm_addr,     // var* address
+    vm_ret,      // return addres(program counter) 
+    vm_nil,      // nil
+    vm_num,      // number
+
+    /* gc object */
+    vm_str,      // string
+    vm_vec,      // vector
+    vm_hash,     // hashmap(dict)
+    vm_func,     // function(lambda)
+    vm_upval,    // upvalue
+    vm_ghost,    // ghost type
+    vm_co,       // coroutine
+    vm_map,      // for globals and namespaces
+
+    /* mark type range */
+    vm_type_size_max
+};
+
+// size of gc object type
+const u32 GC_TYPE_SIZE =
+    static_cast<u32>(vm_type::vm_type_size_max) -
+    static_cast<u32>(vm_type::vm_str);
+
+// basic types
+struct nas_vec;   // vector
+struct nas_hash;  // hashmap(dict)
+struct nas_func;  // function(lambda)
+struct nas_upval; // upvalue
+struct nas_ghost; // objects
+struct nas_co;    // coroutine
+struct nas_map;   // mapper
+
+// nas_val includes gc-managed types
+struct nas_val {
+    enum class gc_status: u8 {
+        uncollected = 0,
+        collected,
+        found
+    };
+
+    gc_status mark;
+    vm_type type; // value type
+    u8 immutable; // used to mark if a string is immutable
+    union elem {
+        std::string* str;
+        nas_vec*   vec;
+        nas_hash*  hash;
+        nas_func*  func;
+        nas_upval* upval;
+        nas_ghost* obj;
+        nas_co*    co;
+        nas_map*   map;
+    } ptr;
+
+    nas_val(vm_type);
+    ~nas_val();
+    void clear();
+};
+
+struct var {
+public:
+    vm_type type = vm_type::vm_none;
+    union {
+        u64 ret;
+        i64 cnt;
+        f64 num;
+        var* addr;
+        nas_val* gcobj;
+    } val;
+
+private:
+    var(vm_type t, u64 pc) { type = t; val.ret = pc; }
+    var(vm_type t, i64 ct) { type = t; val.cnt = ct; }
+    var(vm_type t, f64 n) { type = t; val.num = n; }
+    var(vm_type t, var* p) { type = t; val.addr = p; }
+    var(vm_type t, nas_val* p) { type = t; val.gcobj = p; }
+
+public:
+    var() = default;
+    var(const var&) = default;
+    bool operator==(const var& nr) const {
+        return type == nr.type && val.gcobj == nr.val.gcobj;
+    }
+    bool operator!=(const var& nr) const {
+        return type != nr.type || val.gcobj != nr.val.gcobj;
+    }
+
+public:
+    // create new var object
+    static var none() {
+        return var(vm_type::vm_none, static_cast<u64>(0));
+    }
+    static var nil() {
+        return var(vm_type::vm_nil, static_cast<u64>(0));
+    }
+    static var ret(u64 pc) {
+        return var(vm_type::vm_ret, pc);
+    }
+    static var cnt(i64 n) {
+        return var(vm_type::vm_cnt, n);
+    }
+    static var num(f64 n) {
+        return var(vm_type::vm_num, n);
+    }
+    static var gcobj(nas_val* p) {
+        return var(p->type, p);
+    }
+    static var addr(var* p) {
+        return var(vm_type::vm_addr, p);
+    }
+
+public:
+    // get value
+    var* addr() const { return val.addr; }
+    u64 ret() const { return val.ret; }
+    i64& cnt() { return val.cnt; }
+    f64 num() const { return val.num; }
+
+public:
+    // get gc object
+    std::string& str() { return *val.gcobj->ptr.str; }
+    nas_vec& vec() { return *val.gcobj->ptr.vec; }
+    nas_hash& hash() { return *val.gcobj->ptr.hash; }
+    nas_func& func() { return *val.gcobj->ptr.func; }
+    nas_upval& upval() { return *val.gcobj->ptr.upval; }
+    nas_ghost& ghost() { return *val.gcobj->ptr.obj; }
+    nas_co& co() { return *val.gcobj->ptr.co; }
+    nas_map& map() { return *val.gcobj->ptr.map; }
+    
+
+public:
+    // get const gc object
+    const std::string& str() const { return *val.gcobj->ptr.str; }
+    const nas_vec& vec() const { return *val.gcobj->ptr.vec; }
+    const nas_hash& hash() const { return *val.gcobj->ptr.hash; }
+    const nas_func& func() const { return *val.gcobj->ptr.func; }
+    const nas_upval& upval() const { return *val.gcobj->ptr.upval; }
+    const nas_ghost& ghost() const { return *val.gcobj->ptr.obj; }
+    const nas_co& co() const { return *val.gcobj->ptr.co; }
+    const nas_map& map() const { return *val.gcobj->ptr.map; }
+
+public:
+    bool is_none() const { return type == vm_type::vm_none; }
+    bool is_cnt() const { return type == vm_type::vm_cnt; }
+    bool is_addr() const { return type == vm_type::vm_addr; }
+    bool is_ret() const { return type == vm_type::vm_ret; }
+    bool is_nil() const { return type == vm_type::vm_nil; }
+    bool is_num() const { return type == vm_type::vm_num; }
+    bool is_str() const { return type == vm_type::vm_str; }
+    bool is_vec() const { return type == vm_type::vm_vec; }
+    bool is_hash() const { return type == vm_type::vm_hash; }
+    bool is_func() const { return type == vm_type::vm_func; }
+    bool is_upval() const { return type == vm_type::vm_upval; }
+    bool is_ghost() const { return type == vm_type::vm_ghost; }
+    bool is_coroutine() const { return type == vm_type::vm_co; }
+    bool is_map() const { return type == vm_type::vm_map; }
+
+public:
+    // convert to number
+    f64 to_num() const {
+        return type != vm_type::vm_str
+            ? val.num
+            : util::str_to_num(str().c_str());
+    }
+    // convert to string
+    std::string to_str();
+    inline bool object_check(const std::string&) const;
+    friend std::ostream& operator<<(std::ostream&, var&);
+};
+
+struct nas_vec {
+    std::vector<var> elems;
+
+    // mark if this is printed, avoid stack overflow
+    bool printed = false;
+
+    auto size() const { return elems.size(); }
+    var get_value(const i32 index) {
+        i32 size = elems.size();
+        if (index < -size || index >= size) {
+            return var::none();
+        }
+        return elems[index >= 0 ? index : index + size];
+    }
+    var* get_memory(const i32 index) {
+        i32 size = elems.size();
+        if (index < -size || index >= size) {
+            return nullptr;
+        }
+        return &elems[index >= 0 ? index : index + size];
+    }
+    friend std::ostream& operator<<(std::ostream&, nas_vec&);
+};
+
+struct nas_hash {
+    std::unordered_map<std::string, var> elems;
+
+    // mark if this is printed, avoid stack overflow
+    bool printed = false;
+
+    auto size() const { return elems.size(); }
+    var get_value(const std::string&);
+    var* get_memory(const std::string&);
+    friend std::ostream& operator<<(std::ostream&, nas_hash&);
+};
+
+struct nas_func {
+    i64 dynamic_parameter_index; // dynamic parameter name index in hash.
+    u64 entry; // pc will set to entry-1 to call this function
+    u32 parameter_size; // used to load default parameters to a new function
+    u64 local_size; // used to expand memory space for local values on stack
+    std::vector<var> local; // local scope with default value(var)
+    std::vector<var> upval; // closure
+
+    // parameter table, u32 begins from 1
+    std::unordered_map<std::string, u32> keys;
+
+    // dynamic parameter name
+    std::string dynamic_parameter_name;
+
+    nas_func():
+        dynamic_parameter_index(-1), entry(0),
+        parameter_size(0), local_size(0),
+        dynamic_parameter_name("") {}
+    void clear();
+    friend std::ostream& operator<<(std::ostream&, nas_func&);
+};
+
+struct nas_upval {
+public:
+    /* on stack, use these variables */
+    bool on_stack;
+    u64 size;
+    var* stack_frame_offset;
+
+    /* not on stack, use this */
+    std::vector<var> elems;
+
+public:
+    nas_upval(): on_stack(true), size(0), stack_frame_offset(nullptr) {}
+
+    var& operator[](usize n) {
+        return on_stack? stack_frame_offset[n] : elems[n];
+    }
+
+    void clear() {
+        on_stack = true;
+        elems.clear();
+        size = 0;
+    }
+};
+
+struct nas_ghost {
+private:
+    using destructor = void (*)(void*);
+    using marker = void (*)(void*, std::vector<var>*);
+
+public:
+    std::string type_name;
+    destructor destructor_function;
+    marker gc_mark_function;
+    void* pointer;
+
+public:
+    nas_ghost():
+        type_name(""), destructor_function(nullptr),
+        gc_mark_function(nullptr), pointer(nullptr) {}
+    ~nas_ghost() { clear(); }
+    void set(const std::string&, destructor, marker, void*);
+    void clear();
+    friend std::ostream& operator<<(std::ostream&, const nas_ghost&);
+
+public:
+    const auto& get_ghost_name() const { return type_name; }
+
+public:
+    template<typename T>
+    T* get() { return static_cast<T*>(pointer); }
+    template<typename T>
+    T convert() const { return reinterpret_cast<T>(pointer); }
+};
+
+struct callsite {
+    var caller;
+    u64 file_index = 0;
+    u64 line = 0;
+};
+
+struct context {
+    u64  pc = 0;
+    var* localr = nullptr;
+    var* memr = nullptr;
+    var  funcr = var::nil();
+    var  upvalr = var::nil();
+    var* canary = nullptr;
+
+    var* stack = nullptr;
+    var* top = nullptr;
+
+    callsite* func_stack = nullptr;
+    callsite* func_top = nullptr;
+
+    const std::string* files = nullptr;
+
+    void ctor() {
+        stack = new var[VM_STACK_DEPTH];
+        func_stack = new callsite[VM_STACK_DEPTH];
+    }
+    void dtor() {
+        delete[] stack;
+        delete[] func_stack;
+    }
+    void clear() {
+        /* set canary and program counter */
+        pc = 0;
+        localr = nullptr;
+        memr = nullptr;
+        funcr = var::nil();
+        upvalr = var::nil();
+
+        /* set canary = stack[VM_STACK_DEPTH-1] */
+        canary = stack + VM_STACK_DEPTH - 1;
+
+        /* nothing is on stack */
+        top = stack;
+        func_top = func_stack - 1;
+
+        /* clear main stack */
+        for (u32 i = 0; i < VM_STACK_DEPTH; ++i) {
+            stack[i] = var::nil();
+        }
+    }
+};
+
+struct nas_co {
+    enum class status:u32 {
+        suspended,
+        running,
+        dead
+    };
+
+    context ctx;
+    status status;
+
+    nas_co() { ctx.ctor(); }
+    ~nas_co() { ctx.dtor(); }
+    void clear() { ctx.clear(); status = status::suspended; }
+    friend std::ostream& operator<<(std::ostream&, const nas_co&);
+};
+
+struct nas_map {
+    bool printed = false;
+    std::unordered_map<std::string, var*> mapper;
+
+public:
+    void clear() {
+        mapper.clear();
+    }
+    auto size() const { return mapper.size(); }
+
+    var get_value(const std::string&);
+    var* get_memory(const std::string&);
+    friend std::ostream& operator<<(std::ostream&, nas_map&);
+};
+
+const var zero = var::num(0);
+const var one = var::num(1);
+const var nil = var::nil();
+
+inline bool var::object_check(const std::string& name) const {
+    return is_ghost() && ghost().type_name == name && ghost().pointer;
+}
+
+// use to print error log and return error value
+static var nas_err(const std::string& func, const std::string& info) {
+    std::cerr << "[vm] " << func << ": " << info << "\n";
+    return var::none();
+}
+
+}

src/nasal_vm.cpp

@@ -0,0 +1,822 @@
+#include "nasal_vm.h"
+#include "util/util.h"
+
+namespace nasal {
+
+void vm::vm_init_enrty(const std::vector<std::string>& strs,
+                       const std::vector<f64>& nums,
+                       const std::vector<nasal_builtin_table>& natives,
+                       const std::vector<opcode>& code,
+                       const std::unordered_map<std::string, u64>& global_symbol,
+                       const std::vector<std::string>& filenames,
+                       const std::vector<std::string>& argv) {
+    const_number = nums.data();
+    const_string = strs.data();
+    bytecode = code.data();
+    files = filenames.data();
+    global_size = global_symbol.size();
+
+    /* set native functions */
+    native_function = natives;
+
+    /* set context and global */
+    if (!is_repl_mode || first_exec_flag) {
+        context_and_global_init();
+        first_exec_flag = false;
+    }
+
+    /* init gc */
+    ngc.set(&ctx, global, global_size);
+    ngc.init(strs, argv);
+
+    /* init vm globals */
+    auto map_instance = ngc.alloc(vm_type::vm_map);
+    global_symbol_name.resize(global_symbol.size());
+    global[global_symbol.at("globals")] = map_instance;
+    for (const auto& i : global_symbol) {
+        map_instance.map().mapper[i.first] = global + i.second;
+        global_symbol_name[i.second] = i.first;
+    }
+
+    /* init vm arg */
+    auto arg_instance = ngc.alloc(vm_type::vm_vec);
+    global[global_symbol.at("arg")] = arg_instance;
+    arg_instance.vec().elems = ngc.env_argv;
+}
+
+void vm::context_and_global_init() {
+    /* clear context status */
+    ctx.clear();
+
+    /* clear main stack and global */
+    for (u32 i = 0; i < VM_STACK_DEPTH; ++i) {
+        global[i] = nil;
+    }
+}
+
+void vm::return_address_info(const var& val) {
+    std::clog << "0x";
+    std::clog << std::hex << val.ret() << std::dec;
+}
+
+void vm::memory_address_info(const var& val) {
+    std::clog << "0x";
+    std::clog << std::hex << reinterpret_cast<u64>(val.addr()) << std::dec;
+}
+
+void vm::raw_string_info(var& val) {
+    std::clog << "\"" << util::rawstr(val.str(), 24) << "\"";
+}
+
+void vm::upvalue_info(var& val) {
+    std::clog << "[" << val.upval().size << " val] ";
+    if (val.upval().on_stack) {
+        std::clog << "offset:0x" << std::hex;
+        std::clog << reinterpret_cast<u64>(val.upval().stack_frame_offset);
+        std::clog << std::dec;
+    }
+}
+
+void vm::vector_value_info(var& val) {
+    std::clog << "[" << val.vec().size() << " val]";
+}
+
+void vm::hash_value_info(var& val, const usize max_show_elems) {
+    std::clog << "{";
+    usize count = 0;
+    for (const auto& i : val.hash().elems) {
+        ++count;
+        if (count>max_show_elems) {
+            break;
+        }
+
+        std::clog << i.first;
+        if (count!=val.hash().size()) {
+            std::clog << ", ";
+        }
+    }
+    if (val.hash().size()>max_show_elems) {
+        std::clog << "...";
+    }
+    std::clog << "}";
+}
+
+void vm::coroutine_value_info(var& val) {
+    std::clog << "[ ";
+    switch(val.co().status) {
+        case nas_co::status::dead: std::clog << "dead"; break;
+        case nas_co::status::running: std::clog << "running"; break;
+        case nas_co::status::suspended: std::clog << "suspended"; break;
+    }
+    std::clog << " ] @0x";
+    std::clog << std::hex << reinterpret_cast<u64>(val.val.gcobj) << std::dec;
+}
+
+void vm::namespace_value_info(var& val, const usize max_show_elems) {
+    std::clog << "{";
+    usize count = 0;
+    for (const auto& i : val.map().mapper) {
+        ++count;
+        if (count>max_show_elems) {
+            break;
+        }
+
+        std::clog << i.first;
+        if (count!=val.map().size()) {
+            std::clog << ", ";
+        }
+    }
+    if (val.map().size()>max_show_elems) {
+        std::clog << "...";
+    }
+    std::clog << "}";
+}
+
+void vm::value_name_form(const var& val) {
+    std::clog << "| ";
+    switch(val.type) {
+        case vm_type::vm_none:  std::clog << "null "; break;
+        case vm_type::vm_ret:   std::clog << "ret  "; break;
+        case vm_type::vm_addr:  std::clog << "addr "; break;
+        case vm_type::vm_cnt:   std::clog << "cnt  "; break;
+        case vm_type::vm_nil:   std::clog << "nil  "; break;
+        case vm_type::vm_num:   std::clog << "num  "; break;
+        case vm_type::vm_str:   std::clog << "str  "; break;
+        case vm_type::vm_func:  std::clog << "func "; break;
+        case vm_type::vm_upval: std::clog << "upval"; break;
+        case vm_type::vm_vec:   std::clog << "vec  "; break;
+        case vm_type::vm_hash:  std::clog << "hash "; break;
+        case vm_type::vm_ghost: std::clog << "ghost"; break;
+        case vm_type::vm_co:    std::clog << "co   "; break;
+        case vm_type::vm_map:   std::clog << "map  "; break;
+        default:                std::clog << "err  "; break;
+    }
+    std::clog << " | ";
+}
+
+void vm::value_info(var& val) {
+    value_name_form(val);
+
+    switch(val.type) {
+        case vm_type::vm_none: break;
+        case vm_type::vm_ret: return_address_info(val); break;
+        case vm_type::vm_addr: memory_address_info(val); break;
+        case vm_type::vm_cnt: std::clog << val.cnt(); break;
+        case vm_type::vm_nil: break;
+        case vm_type::vm_num: std::clog << val.num(); break;
+        case vm_type::vm_str: raw_string_info(val); break;
+        case vm_type::vm_func: std::clog << val.func(); break;
+        case vm_type::vm_upval: upvalue_info(val); break;
+        case vm_type::vm_vec: vector_value_info(val); break;
+        case vm_type::vm_hash: hash_value_info(val, 4); break;
+        case vm_type::vm_ghost: std::clog << val.ghost(); break;
+        case vm_type::vm_co: coroutine_value_info(val); break;
+        case vm_type::vm_map: namespace_value_info(val, 4); break;
+        default: std::clog << "unknown"; break;
+    }
+    std::clog << "\n";
+}
+
+void vm::function_detail_info(const nas_func& func) {
+    std::clog << "func ";
+
+    std::vector<std::string> argument_list = {};
+    argument_list.resize(func.keys.size());
+    for (const auto& key : func.keys) {
+        argument_list[key.second-1] = key.first;
+    }
+
+    std::clog << "(";
+    for (const auto& key : argument_list) {
+        std::clog << key;
+        if (key != argument_list.back()) {
+            std::clog << ", ";
+        }
+    }
+    if (func.dynamic_parameter_index>=0) {
+        std::clog << (argument_list.size()? ", ":"");
+        std::clog << func.dynamic_parameter_name << "...";
+    }
+    std::clog << ") ";
+    const auto& code = bytecode[func.entry];
+    std::clog << "{ entry: " << files[code.fidx] << ":" << code.line << " }";
+}
+
+void vm::function_call_trace() {
+    // no function is called when error ocurred
+    if (!ctx.funcr.is_func()) {
+        return;
+    }
+
+    util::windows_code_page_manager cp;
+    cp.set_utf8_output();
+
+    var* bottom = ctx.stack;
+    var* top = ctx.top;
+
+    // generate trace back
+    std::vector<const nas_func*> functions;
+    std::vector<u64> callsite;
+
+    var* prev_func = &ctx.funcr;
+    functions.push_back(&prev_func->func());
+    for (var* i = top; i >= bottom; i--) {
+        // +-------+------------------+
+        // | ret   | 0x3bf            | <-- i + 1 (should not be 0, except coroutine)
+        // +-------+------------------+
+        // | addr  | 0x7ff5f61ae020   | <-- i
+        // +-------+------------------+
+        // | upval | ...              | <-- i - 1
+        // +-------+------------------+
+        // | locals| ...              |
+        // +-------+------------------+
+        // | func  | function         | <-- i - 1 - prev_func->local_size - 1
+        // +-------+------------------+
+        if (i + 1 <= top && i[0].is_addr() && i[1].is_ret()) {
+            auto r_addr = i[1].ret();
+            callsite.push_back(r_addr);
+            i--;
+            i -= prev_func->func().local_size;
+            i--;
+            if (i >= bottom && i[0].is_func()) {
+                prev_func = i;
+                functions.push_back(&prev_func->func());
+            }
+        }
+    }
+
+    std::clog << "\ncall trace ";
+    std::clog << (ngc.cort? "(coroutine)":"(main)") << "\n";
+    std::clog << "  crash occurred at\n       ";
+    function_detail_info(ctx.funcr.func());
+    std::clog << " at " << files[bytecode[ctx.pc].fidx] << ":";
+    std::clog << bytecode[ctx.pc].line << "\n";
+
+    if (callsite.empty()) {
+        cp.restore_code_page();
+        return;
+    }
+
+    const nas_func* prev = nullptr;
+    u64 prev_addr = 0;
+    u64 same_call_count = 0;
+    for (int i = 0; i < functions.size(); ++i) {
+        if (functions[i] == prev && callsite[i] == prev_addr) {
+            same_call_count++;
+            continue;
+        } else if (same_call_count) {
+            std::clog << "  `--> " << same_call_count << " same call(s)\n";
+            same_call_count = 0;
+        }
+
+        // in coroutine
+        if (callsite[i] == 0 && ngc.cort) {
+            std::clog << "  call by coroutine\n";
+            break;
+        }
+
+        std::clog << "  call ";
+        function_detail_info(*functions[i]);
+        auto r_addr = callsite[i];
+        std::clog << " from " << files[bytecode[r_addr].fidx] << ":";
+        std::clog << bytecode[r_addr].line << "\n";
+
+        prev = functions[i];
+        prev_addr = r_addr;
+    }
+    if (same_call_count) {
+        std::clog << "  `--> " << same_call_count << " same call(s)\n";
+    }
+
+    cp.restore_code_page();
+}
+
+void vm::trace_back() {
+    // generate trace back
+    std::stack<u64> ret;
+    for (var* i = ctx.stack; i<=ctx.top; ++i) {
+        if (i->is_ret() && i->ret()!=0) {
+            ret.push(i->ret());
+        }
+    }
+
+    // store the position program crashed
+    ret.push(ctx.pc);
+
+    std::clog << "\nback trace ";
+    std::clog << (ngc.cort? "(coroutine)":"(main)") << "\n";
+    codestream::set(
+        const_number,
+        const_string,
+        global_symbol_name,
+        native_function.data(),
+        files
+    );
+
+    for (u64 p = 0, same = 0, prev = 0xffffffff; !ret.empty(); prev = p, ret.pop()) {
+        if ((p = ret.top())==prev) {
+            ++same;
+            continue;
+        } else if (same) {
+            std::clog << "  0x" << std::hex
+                      << std::setw(8) << std::setfill('0')
+                      << prev << std::dec << "    "
+                      << same << " same call(s)\n";
+            same = 0;
+        }
+        std::clog << "  " << codestream(bytecode[p], p) << "\n";
+    }
+    // the first called place has no same calls
+}
+
+void vm::stack_info(const u64 limit) {
+    var* top = ctx.top;
+    var* bottom = ctx.stack;
+    const auto stack_address = reinterpret_cast<u64>(bottom);
+
+    std::clog << "\nstack (0x" << std::hex << stack_address << std::dec;
+    std::clog << ", limit " << limit << ", total ";
+    std::clog << (top<bottom? 0:static_cast<i64>(top-bottom+1)) << ")\n";
+
+    for (u32 i = 0; i<limit && top>=bottom; ++i, --top) {
+        std::clog << "  0x" << std::hex
+                  << std::setw(8) << std::setfill('0')
+                  << static_cast<u64>(top-bottom) << std::dec
+                  << "    ";
+        value_info(top[0]);
+    }
+}
+
+void vm::register_info() {
+    std::clog << "\nregister (" << (ngc.cort? "coroutine":"main") << ")\n";
+    std::clog << std::hex
+              << "  [ pc     ]    | pc    | 0x" << ctx.pc << "\n"
+              << "  [ global ]    | addr  | 0x"
+              << reinterpret_cast<u64>(global) << "\n"
+              << "  [ local  ]    | addr  | 0x"
+              << reinterpret_cast<u64>(ctx.localr) << "\n"
+              << "  [ memr   ]    | addr  | 0x"
+              << reinterpret_cast<u64>(ctx.memr) << "\n"
+              << "  [ canary ]    | addr  | 0x"
+              << reinterpret_cast<u64>(ctx.canary) << "\n"
+              << "  [ top    ]    | addr  | 0x"
+              << reinterpret_cast<u64>(ctx.top) << "\n"
+              << std::dec;
+    std::clog << "  [ funcr  ]    "; value_info(ctx.funcr);
+    std::clog << "  [ upval  ]    "; value_info(ctx.upvalr);
+}
+
+void vm::global_state() {
+    if (!global_size || global[0].is_none()) {
+        return;
+    }
+    std::clog << "\nglobal (0x" << std::hex
+              << reinterpret_cast<u64>(global) << ")\n" << std::dec;
+    for (usize i = 0; i<global_size; ++i) {
+        std::clog << "  0x" << std::hex << std::setw(8)
+                  << std::setfill('0') << static_cast<u64>(i) << std::dec
+                  << "    ";
+        auto name = global_symbol_name[i];
+        if (name.length()>=10) {
+            name = name.substr(0, 7) + "...";
+        } else {
+
+        }
+        std::clog << "| " << std::left << std::setw(10)
+                  << std::setfill(' ') << name << " "
+                  << std::internal;
+        value_info(global[i]);
+    }
+}
+
+void vm::local_state() {
+    if (!ctx.localr || !ctx.funcr.func().local_size) {
+        return;
+    }
+    const u32 lsize = ctx.funcr.func().local_size;
+    std::clog << "\nlocal (0x" << std::hex << reinterpret_cast<u64>(ctx.localr)
+              << " <+" << static_cast<u64>(ctx.localr-ctx.stack)
+              << ">)\n" << std::dec;
+    for (u32 i = 0; i<lsize; ++i) {
+        std::clog << "  0x" << std::hex << std::setw(8)
+                  << std::setfill('0') << i << std::dec
+                  << "    ";
+        value_info(ctx.localr[i]);
+    }
+}
+
+void vm::upvalue_state() {
+    if (ctx.funcr.is_nil() || ctx.funcr.func().upval.empty()) {
+        return;
+    }
+    std::clog << "\nupvalue\n";
+    auto& upval = ctx.funcr.func().upval;
+    for (u32 i = 0; i<upval.size(); ++i) {
+        std::clog << "  -> upval[" << i << "]:\n";
+        auto& uv = upval[i].upval();
+        for (u32 j = 0; j<uv.size; ++j) {
+            std::clog << "     0x" << std::hex << std::setw(8)
+                      << std::setfill('0') << j << std::dec
+                      << " ";
+            value_info(uv[j]);
+        }
+    }
+}
+
+void vm::all_state_detail() {
+    register_info();
+    global_state();
+    local_state();
+    upvalue_state();
+}
+
+std::string vm::report_lack_arguments(u32 argc, const nas_func& func) const {
+    auto result = std::string("lack argument(s) when calling function:\n  func(");
+    std::vector<std::string> argument_list = {};
+    argument_list.resize(func.keys.size());
+    for (const auto& i : func.keys) {
+        argument_list[i.second-1] = i.first;
+    }
+    for (u32 i = 0; i<argument_list.size(); ++i) {
+        result += argument_list[i];
+        if (i<argc) {
+            result += "[get]";
+        }
+        if (i!=argument_list.size()-1) {
+            result += ", ";
+        }
+    }
+    if (func.dynamic_parameter_index>=0) {
+        result += argument_list.size()? ", ":"";
+        result += const_string[func.dynamic_parameter_index] + "[dynamic]";
+    }
+    result += ") ";
+    std::stringstream out;
+    const auto& code = bytecode[func.entry];
+    out << "{ entry: " << files[code.fidx] << ":" << code.line << " }";
+    out << " @ 0x" << std::hex << reinterpret_cast<u64>(&func) << std::dec;
+    return result + out.str();
+}
+
+std::string vm::report_special_call_lack_arguments(var* local,
+                                                   const nas_func& func) const {
+    auto result = std::string("lack argument(s) when calling function:\n  func(");
+    std::vector<std::string> argument_list = {};
+    argument_list.resize(func.keys.size());
+    for (const auto& i : func.keys) {
+        argument_list[i.second-1] = i.first;
+    }
+    for (const auto& key : argument_list) {
+        if (local[func.keys.at(key)].is_none()) {
+            result += key + ", ";
+        } else {
+            result += key + "[get], ";
+        }
+    }
+    result = result.substr(0, result.length()-2);
+    result += ") ";
+    std::stringstream out;
+    const auto& code = bytecode[func.entry];
+    out << "{ entry: " << files[code.fidx] << ":" << code.line << " }";
+    out << " @ 0x" << std::hex << reinterpret_cast<u64>(&func) << std::dec;
+    return result + out.str();
+}
+
+std::string vm::report_key_not_found(const std::string& not_found,
+                                     const nas_hash& hash) const {
+    auto result = "member \"" + not_found + "\" doesn't exist in hash {";
+    for (const auto& i : hash.elems) {
+        result += i.first + ", ";
+    }
+    if (hash.elems.size()) {
+        result = result.substr(0, result.length()-2);
+    }
+    result += "}";
+    return result;
+}
+
+std::string vm::report_out_of_range(f64 index, usize real_size) const {
+    auto result = "index out of range: " + std::to_string(index);
+    result += " but max size is " + std::to_string(real_size);
+    if (!real_size) {
+        return result;
+    }
+    result += ", index range is -" + std::to_string(real_size);
+    result += "~" + std::to_string(real_size-1);
+    return result;
+}
+
+std::string vm::type_name_string(const var& value) const {
+    switch(value.type) {
+        case vm_type::vm_none: return "none";
+        case vm_type::vm_cnt: return "counter";
+        case vm_type::vm_addr: return "address";
+        case vm_type::vm_ret: return "program counter";
+        case vm_type::vm_nil: return "nil";
+        case vm_type::vm_num: return "number";
+        case vm_type::vm_str: return "string";
+        case vm_type::vm_vec: return "vector";
+        case vm_type::vm_hash: return "hash";
+        case vm_type::vm_func: return "function";
+        case vm_type::vm_upval: return "upvalue";
+        case vm_type::vm_ghost: return "ghost type";
+        case vm_type::vm_co: return "coroutine";
+        case vm_type::vm_map: return "namespace";
+        default: break;
+    }
+    return "unknown";
+}
+
+void vm::die(const std::string& str) {
+    const auto& file = files[bytecode[ctx.pc].fidx];
+    const auto line = bytecode[ctx.pc].line;
+    std::cerr << "[vm] error occurred at " << file << ":" << line << ": ";
+    std::cerr << str << "\n";
+    function_call_trace();
+
+    // trace back contains bytecode info, dump in verbose mode
+    if (verbose) {
+        trace_back();
+    }
+
+    // verbose will dump more values on stack
+    if (verbose) {
+        stack_info(64);
+    }
+
+    // show verbose crash info
+    if (verbose) {
+        all_state_detail();
+    }
+
+    if (!ngc.cort) {
+        if (!verbose) {
+            std::cerr << "\n[vm] use <-d> for detailed crash info.\n\n";
+        }
+        // in main context, exit directly
+        std::exit(1);
+    }
+
+    // in coroutine, shut down the coroutine and return to main context
+    ctx.pc = 0; // mark coroutine 'dead'
+    ngc.context_reserve(); // switch context to main
+    ctx.top[0] = nil; // generate return value 'nil'
+}
+
+void vm::run(const codegen& gen,
+             const linker& linker,
+             const std::vector<std::string>& argv) {
+    vm_init_enrty(
+        gen.strs(),
+        gen.nums(),
+        gen.natives(),
+        gen.codes(),
+        gen.globals(),
+        linker.get_file_list(),
+        argv
+    );
+
+#ifndef _MSC_VER
+
+// interrupt check macro for computed goto mode.
+#define CHECK_INTERRUPT { \
+    if (interrupt_ptr && interrupt_ptr->load()) { \
+        throw std::runtime_error("VM execution interrupted by timeout"); \
+    } \
+}
+
+    // using labels as values/computed goto
+    const void* oprs[] = {
+        &&vmexit,
+        &&repl,
+        &&intl,
+        &&loadg,
+        &&loadl,
+        &&loadu,
+        &&dup,
+        &&pnum,
+        &&pnil,
+        &&pstr,
+        &&newv,
+        &&newh,
+        &&newf,
+        &&happ,
+        &&para,
+        &&deft,
+        &&dyn,
+        &&lnot,
+        &&usub,
+        &&bnot,
+        &&btor,
+        &&btxor,
+        &&btand,
+        &&add,
+        &&sub,
+        &&mul,
+        &&div,
+        &&lnk,
+        &&addc,
+        &&subc,
+        &&mulc,
+        &&divc,
+        &&lnkc,
+        &&addeq,
+        &&subeq,
+        &&muleq,
+        &&diveq,
+        &&lnkeq,
+        &&bandeq,
+        &&boreq,
+        &&bxoreq,
+        &&addeqc,
+        &&subeqc,
+        &&muleqc,
+        &&diveqc,
+        &&lnkeqc,
+        &&addecp,
+        &&subecp,
+        &&mulecp,
+        &&divecp,
+        &&lnkecp,
+        &&meq,
+        &&eq,
+        &&neq,
+        &&less,
+        &&leq,
+        &&grt,
+        &&geq,
+        &&lessc,
+        &&leqc,
+        &&grtc,
+        &&geqc,
+        &&pop,
+        &&jmp,
+        &&jt,
+        &&jf,
+        &&cnt,
+        &&findex,
+        &&feach,
+        &&callg,
+        &&calll,
+        &&upval,
+        &&callv,
+        &&callvi,
+        &&callh,
+        &&callfv,
+        &&callfh,
+        &&callb,
+        &&slcbeg,
+        &&slcend,
+        &&slc,
+        &&slc2,
+        &&mcallg,
+        &&mcalll,
+        &&mupval,
+        &&mcallv,
+        &&mcallh,
+        &&ret
+    };
+    std::vector<const void*> code;
+    for (const auto& i : gen.codes()) {
+        code.push_back(oprs[i.op]);
+        imm.push_back(i.num);
+    }
+    CHECK_INTERRUPT;
+    // goto the first operand
+    goto *code[ctx.pc];
+#else
+    std::vector<nasal_vm_func> code;
+    for (const auto& i : gen.codes()) {
+        code.push_back(operand_function[i.op]);
+        imm.push_back(i.num);
+    }
+    while (code[ctx.pc]) {
+        if (interrupt_ptr && interrupt_ptr->load()) {
+            throw std::runtime_error("VM execution interrupted by timeout");
+        }
+        (this->*code[ctx.pc])();
+        if (ctx.top>=ctx.canary) {
+            die("stack overflow");
+        }
+        ++ctx.pc;
+    }
+#endif
+// all nasal programs should end here
+vmexit:
+    if (verbose) {
+        ngc.status.dump_info();
+    }
+    imm.clear();
+    if (!is_repl_mode) {
+        ngc.clear();
+    }
+    return;
+
+#ifndef _MSC_VER
+// IR which may cause stackoverflow
+#define exec_check(op) {\
+    op();\
+    CHECK_INTERRUPT;\
+    if (ctx.top<ctx.canary)\
+        goto *code[++ctx.pc];\
+    die("stack overflow");\
+    goto *code[++ctx.pc];\
+}
+// IR which does not cause stackoverflow
+#define exec_nodie(op) {\
+    op();\
+    CHECK_INTERRUPT;\
+    goto *code[++ctx.pc];\
+}
+
+repl:   exec_nodie(o_repl  ); // 0
+intl:   exec_nodie(o_intl  ); // -0
+loadg:  exec_nodie(o_loadg ); // -1
+loadl:  exec_nodie(o_loadl ); // -1
+loadu:  exec_nodie(o_loadu ); // -1
+dup:    exec_check(o_dup   ); // +1
+pnum:   exec_check(o_pnum  ); // +1
+pnil:   exec_check(o_pnil  ); // +1
+pstr:   exec_check(o_pstr  ); // +1
+newv:   exec_check(o_newv  ); // +1-imm[pc]
+newh:   exec_check(o_newh  ); // +1
+newf:   exec_check(o_newf  ); // +1
+happ:   exec_nodie(o_happ  ); // -1
+para:   exec_nodie(o_para  ); // -0
+deft:   exec_nodie(o_deft  ); // -1
+dyn:    exec_nodie(o_dyn   ); // -0
+lnot:   exec_nodie(o_lnot  ); // -0
+usub:   exec_nodie(o_usub  ); // -0
+bnot:   exec_nodie(o_bnot  ); // -0
+btor:   exec_nodie(o_btor  ); // -1
+btxor:  exec_nodie(o_btxor ); // -1
+btand:  exec_nodie(o_btand ); // -1
+add:    exec_nodie(o_add   ); // -1
+sub:    exec_nodie(o_sub   ); // -1
+mul:    exec_nodie(o_mul   ); // -1
+div:    exec_nodie(o_div   ); // -1
+lnk:    exec_nodie(o_lnk   ); // -1
+addc:   exec_nodie(o_addc  ); // -0
+subc:   exec_nodie(o_subc  ); // -0
+mulc:   exec_nodie(o_mulc  ); // -0
+divc:   exec_nodie(o_divc  ); // -0
+lnkc:   exec_nodie(o_lnkc  ); // -0
+addeq:  exec_nodie(o_addeq ); // -1
+subeq:  exec_nodie(o_subeq ); // -1
+muleq:  exec_nodie(o_muleq ); // -1
+diveq:  exec_nodie(o_diveq ); // -1
+lnkeq:  exec_nodie(o_lnkeq ); // -1
+bandeq: exec_nodie(o_bandeq); // -1
+boreq:  exec_nodie(o_boreq ); // -1
+bxoreq: exec_nodie(o_bxoreq); // -1
+addeqc: exec_nodie(o_addeqc); // -0
+subeqc: exec_nodie(o_subeqc); // -0
+muleqc: exec_nodie(o_muleqc); // -0
+diveqc: exec_nodie(o_diveqc); // -0
+lnkeqc: exec_nodie(o_lnkeqc); // -0
+addecp: exec_nodie(o_addecp); // -1
+subecp: exec_nodie(o_subecp); // -1
+mulecp: exec_nodie(o_mulecp); // -1
+divecp: exec_nodie(o_divecp); // -1
+lnkecp: exec_nodie(o_lnkecp); // -1
+meq:    exec_nodie(o_meq   ); // -1
+eq:     exec_nodie(o_eq    ); // -1
+neq:    exec_nodie(o_neq   ); // -1
+less:   exec_nodie(o_less  ); // -1
+leq:    exec_nodie(o_leq   ); // -1
+grt:    exec_nodie(o_grt   ); // -1
+geq:    exec_nodie(o_geq   ); // -1
+lessc:  exec_nodie(o_lessc ); // -0
+leqc:   exec_nodie(o_leqc  ); // -0
+grtc:   exec_nodie(o_grtc  ); // -0
+geqc:   exec_nodie(o_geqc  ); // -0
+pop:    exec_nodie(o_pop   ); // -1
+jmp:    exec_nodie(o_jmp   ); // -0
+jt:     exec_nodie(o_jt    ); // -0
+jf:     exec_nodie(o_jf    ); // -1
+cnt:    exec_nodie(o_cnt   ); // -0
+findex: exec_check(o_findex); // +1
+feach:  exec_check(o_feach ); // +1
+callg:  exec_check(o_callg ); // +1
+calll:  exec_check(o_calll ); // +1
+upval:  exec_check(o_upval ); // +1
+callv:  exec_nodie(o_callv ); // -0
+callvi: exec_nodie(o_callvi); // -0
+callh:  exec_nodie(o_callh ); // -0
+callfv: exec_nodie(o_callfv); // check in the function
+callfh: exec_nodie(o_callfh); // check in the function
+callb:  exec_nodie(o_callb ); // -0
+slcbeg: exec_check(o_slcbeg); // +1
+slcend: exec_nodie(o_slcend); // -1
+slc:    exec_nodie(o_slc   ); // -1
+slc2:   exec_nodie(o_slc2  ); // -2
+mcallg: exec_check(o_mcallg); // +1
+mcalll: exec_check(o_mcalll); // +1
+mupval: exec_check(o_mupval); // +1
+mcallv: exec_nodie(o_mcallv); // -0
+mcallh: exec_nodie(o_mcallh); // -0
+ret:    exec_nodie(o_ret   ); // -2
+#endif
+}
+
+}

src/nasal_web.cpp

@@ -0,0 +1,399 @@
+#include "nasal_web.h"
+#include "nasal_vm.h"
+#include "nasal_parse.h"
+#include "nasal_codegen.h"
+#include "nasal_import.h"
+#include "optimizer.h"
+#include "nasal_err.h"
+#include "nasal_lexer.h"
+#include "repl/repl.h"
+
+#include <string>
+#include <sstream>
+#include <fstream>
+#include <cstdlib>
+#include <cstdio>
+#include <stdexcept>
+#include <chrono>
+#include <vector>
+#include <future>
+#include <atomic>
+
+namespace {
+    // Helper function implementations inside anonymous namespace
+    std::vector<std::string> split_string(const std::string& str, char delim) {
+        std::vector<std::string> result;
+        std::stringstream ss(str);
+        std::string item;
+        while (std::getline(ss, item, delim)) {
+            result.push_back(item);
+        }
+        return result;
+    }
+
+    std::string join_string(const std::vector<std::string>& vec, const std::string& delim) {
+        if (vec.empty()) return "";
+        std::stringstream ss;
+        ss << vec[0];
+        for (size_t i = 1; i < vec.size(); ++i) {
+            ss << delim << vec[i];
+        }
+        return ss.str();
+    }
+}
+
+struct NasalContext {
+    std::unique_ptr<nasal::vm> vm_instance;
+    std::string last_result;
+    std::string last_error;
+    std::chrono::seconds timeout{5}; // Default 5 second timeout
+    std::atomic<bool> interrupted{false};
+
+    NasalContext() {
+        vm_instance = std::make_unique<nasal::vm>();
+        vm_instance->set_interrupt_ptr(&interrupted);
+    }
+
+    ~NasalContext() {
+        vm_instance.reset(); // Reset explicitly
+    }
+};
+
+struct WebReplContext {
+    std::unique_ptr<nasal::repl::repl> repl_instance;
+    std::vector<std::string> source;
+    std::string last_result;
+    std::string last_error;
+    bool allow_output;
+    bool initialized;
+    std::chrono::seconds timeout{1}; // Default 1 second timeout
+
+    WebReplContext() : allow_output(false), initialized(false) {
+        repl_instance = std::make_unique<nasal::repl::repl>();
+    }
+};
+
+void* nasal_init() {
+    return new NasalContext();
+}
+
+void nasal_cleanup(void* context) {
+    auto* ctx = static_cast<NasalContext*>(context);
+    ctx->vm_instance.reset(); 
+    delete ctx;
+}
+
+// Add new function to set timeout
+void nasal_set_timeout(void* context, int seconds) {
+    auto* ctx = static_cast<NasalContext*>(context);
+    ctx->timeout = std::chrono::seconds(seconds);
+}
+
+const char* nasal_eval(void* context, const char* code, int show_time) {
+    using clk = std::chrono::high_resolution_clock;
+    const auto den = clk::duration::period::den;
+    
+    auto* ctx = static_cast<NasalContext*>(context);
+    
+    try {
+        nasal::lexer lex;
+        nasal::parse parse;
+        nasal::linker ld;
+        nasal::codegen gen;
+        
+        // Create a unique temporary file
+        char temp_filename[256];
+        snprintf(temp_filename, sizeof(temp_filename), "/tmp/nasal_eval_%ld_XXXXXX", std::time(nullptr));
+        int fd = mkstemp(temp_filename);
+        if (fd == -1) {
+            throw std::runtime_error("Failed to create temporary file");
+        }
+
+        // Write the code to the temporary file
+        std::ofstream temp_file(temp_filename);
+        if (!temp_file.is_open()) {
+            close(fd);
+            throw std::runtime_error("Failed to open temporary file for writing");
+        }
+        temp_file << code;
+        temp_file.close();
+        close(fd);
+        
+        // Capture stdout and stderr
+        std::stringstream output;
+        std::stringstream error_output;
+        auto old_cout = std::cout.rdbuf(output.rdbuf());
+        auto old_cerr = std::cerr.rdbuf(error_output.rdbuf());
+
+        // Process the code
+        if (lex.scan(std::string(temp_filename)).geterr()) {
+            ctx->last_error = error_output.str();
+            std::cout.rdbuf(old_cout);
+            std::cerr.rdbuf(old_cerr);
+            std::remove(temp_filename);
+            return ctx->last_error.c_str();
+        }
+
+        if (parse.compile(lex).geterr()) {
+            ctx->last_error = error_output.str();
+            std::cout.rdbuf(old_cout);
+            std::cerr.rdbuf(old_cerr);
+            std::remove(temp_filename);
+            return ctx->last_error.c_str();
+        }
+
+        if (ld.link(parse, false).geterr()) {
+            ctx->last_error = error_output.str();
+            std::cout.rdbuf(old_cout);
+            std::cerr.rdbuf(old_cerr);
+            std::remove(temp_filename);
+            return ctx->last_error.c_str();
+        }
+        auto opt = std::make_unique<nasal::optimizer>();
+        opt->do_optimization(parse.tree());
+        
+        if (gen.compile(parse, ld, false, true).geterr()) {
+            ctx->last_error = error_output.str();
+            std::cout.rdbuf(old_cout);
+            std::cerr.rdbuf(old_cerr);
+            std::remove(temp_filename);
+            return ctx->last_error.c_str();
+        }
+
+        const auto start = show_time ? clk::now() : clk::time_point();
+        
+        // Create a future for the VM execution
+        auto future = std::async(std::launch::async, [&]() {
+            // Wrap VM execution in try/catch
+            try {
+                ctx->vm_instance->run(gen, ld, {});
+            } catch (const std::exception& e) {
+                ctx->last_error = e.what();
+                throw std::runtime_error(ctx->last_error);
+            } catch (...) {
+                ctx->last_error = "Unknown error in VM run()";
+                throw std::runtime_error(ctx->last_error);
+            }
+        });
+
+        // Wait for completion or timeout
+        auto status = future.wait_for(ctx->timeout);
+        if (status == std::future_status::timeout) {
+            ctx->interrupted.store(true);
+            std::remove(temp_filename);
+            throw std::runtime_error("Execution timed out after " + 
+                std::to_string(ctx->timeout.count()) + " seconds");
+        }
+
+        const auto end = show_time ? clk::now() : clk::time_point();
+        
+        std::cout.rdbuf(old_cout);
+        std::cerr.rdbuf(old_cerr);
+        
+        std::stringstream result;
+        result << output.str();
+        if (!error_output.str().empty()) {
+            result << error_output.str();
+        }
+        if (result.str().empty()) {
+            result << "Execution completed successfully.\n";
+        }
+        
+        if (show_time) {
+            double execution_time = static_cast<double>((end-start).count())/den;
+            result << "\nExecution time: " << execution_time << "s";
+        }
+        
+        ctx->last_result = result.str();
+        std::remove(temp_filename);
+        
+        return ctx->last_result.c_str();
+    } catch (const std::exception& e) {
+        ctx->last_error = e.what();
+        return ctx->last_error.c_str();
+    }
+}
+
+const char* nasal_get_error(void* context) {
+    auto* ctx = static_cast<NasalContext*>(context);
+    return ctx->last_error.c_str();
+}
+
+void* nasal_repl_init() {
+    auto* ctx = new WebReplContext();
+    
+    try {
+        // Initialize environment silently
+        nasal::repl::info::instance()->in_repl_mode = true;
+        ctx->repl_instance->get_runtime().set_repl_mode_flag(true);
+        ctx->repl_instance->get_runtime().set_detail_report_info(false);
+        
+        // Run initial setup
+        ctx->repl_instance->set_source({});
+        if (!ctx->repl_instance->run()) {
+            ctx->last_error = "Failed to initialize REPL environment";
+            return ctx;
+        }
+        
+        // Enable output after initialization
+        ctx->allow_output = true;
+        ctx->repl_instance->get_runtime().set_allow_repl_output_flag(true);
+        ctx->initialized = true;
+    } catch (const std::exception& e) {
+        ctx->last_error = std::string("Initialization error: ") + e.what();
+    }
+    
+    return ctx;
+}
+
+void nasal_repl_cleanup(void* context) {
+    delete static_cast<WebReplContext*>(context);
+}
+
+// Add new function to set REPL timeout
+void nasal_repl_set_timeout(void* context, int seconds) {
+    auto* ctx = static_cast<WebReplContext*>(context);
+    ctx->timeout = std::chrono::seconds(seconds);
+}
+
+const char* nasal_repl_eval(void* context, const char* line) {
+    auto* ctx = static_cast<WebReplContext*>(context);
+    
+    if (!ctx->initialized) {
+        ctx->last_error = "REPL not properly initialized";
+        return ctx->last_error.c_str();
+    }
+
+    try {
+        std::string input_line(line);
+        
+        // Handle empty input
+        if (input_line.empty()) {
+            ctx->last_result = "";
+            return ctx->last_result.c_str();
+        }
+
+        // Handle REPL commands
+        if (input_line[0] == '.') {
+            if (input_line == ".help" || input_line == ".h") {
+                ctx->last_result = 
+                    "Nasal REPL commands:\n"
+                    "  .help  .h     show this help message\n"
+                    "  .clear .c     clear screen\n"
+                    "  .exit  .e     exit repl\n"
+                    "  .quit  .q     exit repl\n"
+                    "  .source .s    show source\n";
+                return ctx->last_result.c_str();
+            }
+            else if (input_line == ".clear" || input_line == ".c") {
+                ctx->last_result = "\033c"; // Special marker for clear screen
+                return ctx->last_result.c_str();
+            }
+            else if (input_line == ".exit" || input_line == ".e" ||
+                     input_line == ".quit" || input_line == ".q") {
+                ctx->last_result = "__EXIT__"; // Special marker for exit
+                return ctx->last_result.c_str();
+            }
+            else if (input_line == ".source" || input_line == ".s") {
+                // Return accumulated source
+                ctx->last_result = ctx->source.empty() ? 
+                    "(no source)" : 
+                    join_string(ctx->source, "\n");
+                return ctx->last_result.c_str();
+            }
+            else {
+                ctx->last_error = "no such command \"" + input_line + "\", input \".help\" for help";
+                return ctx->last_error.c_str();
+            }
+        }
+
+        // Add the line to source
+        ctx->source.push_back(input_line);
+
+        // Capture output
+        std::stringstream output;
+        auto old_cout = std::cout.rdbuf(output.rdbuf());
+        auto old_cerr = std::cerr.rdbuf(output.rdbuf());
+
+        // Create a copy of the source for the async task
+        auto source_copy = ctx->source;
+
+        // Create a future for the REPL execution using the existing instance
+        auto future = std::async(std::launch::async, [repl = ctx->repl_instance.get(), source_copy]() {
+            repl->get_runtime().set_repl_mode_flag(true);
+            repl->get_runtime().set_allow_repl_output_flag(true);
+            repl->set_source(source_copy);
+            return repl->run();
+        });
+
+        // Wait for completion or timeout
+        auto status = future.wait_for(ctx->timeout);
+        
+        // Restore output streams first
+        std::cout.rdbuf(old_cout);
+        std::cerr.rdbuf(old_cerr);
+
+        if (status == std::future_status::timeout) {
+            ctx->source.pop_back(); // Remove the line that caused timeout
+            
+            // Reset the REPL instance state
+            ctx->repl_instance->get_runtime().set_repl_mode_flag(true);
+            ctx->repl_instance->get_runtime().set_allow_repl_output_flag(true);
+            ctx->repl_instance->set_source(ctx->source);
+            
+            throw std::runtime_error("Execution timed out after " + 
+                std::to_string(ctx->timeout.count()) + " seconds");
+        }
+
+        bool success = future.get();
+        std::string result = output.str();
+
+        if (!success) {
+            ctx->last_error = result;
+            ctx->source.pop_back(); // Remove failed line
+            return ctx->last_error.c_str();
+        }
+
+        ctx->last_result = result;
+        return ctx->last_result.c_str();
+
+    } catch (const std::exception& e) {
+        ctx->last_error = std::string("Error: ") + e.what();
+        ctx->source.pop_back(); // Remove failed line
+        return ctx->last_error.c_str();
+    }
+}
+
+int nasal_repl_is_complete(void* context, const char* line) {
+    auto* ctx = static_cast<WebReplContext*>(context);
+    
+    if (!ctx->initialized) {
+        return -1;  // Error state
+    }
+
+    // Handle empty input
+    if (!line || strlen(line) == 0) {
+        return 0;  // Complete
+    }
+
+    // Handle REPL commands
+    if (line[0] == '.') {
+        return 0;  // Commands are always complete
+    }
+
+    // Create a temporary source vector with existing source plus new line
+    std::vector<std::string> temp_source = ctx->source;
+    temp_source.push_back(line);
+
+    // Use the REPL's check_need_more_input method
+    int result = ctx->repl_instance->check_need_more_input(temp_source);
+    return result;  // Ensure a return value is provided
+}
+
+// Add this function to expose version info
+const char* nasal_repl_get_version() {
+    static std::string version_info = 
+        std::string("version ") + __nasver__ + 
+        " (" + __DATE__ + " " + __TIME__ + ")";
+    return version_info.c_str();
+}

src/nasal_web.h

@@ -0,0 +1,29 @@
+#ifndef __NASAL_WEB_H__
+#define __NASAL_WEB_H__
+
+#include "nasal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Main API functions
+NASAL_EXPORT void* nasal_init();
+NASAL_EXPORT void nasal_cleanup(void* context);
+NASAL_EXPORT void nasal_set_timeout(void* context, int seconds);
+NASAL_EXPORT const char* nasal_eval(void* context, const char* code, int show_time);
+NASAL_EXPORT const char* nasal_get_error(void* context);
+
+// REPL 
+NASAL_EXPORT void* nasal_repl_init();
+NASAL_EXPORT void nasal_repl_cleanup(void* repl_context);
+NASAL_EXPORT void nasal_repl_set_timeout(void* repl_context, int seconds);
+NASAL_EXPORT const char* nasal_repl_eval(void* repl_context, const char* line);
+NASAL_EXPORT int nasal_repl_is_complete(void* repl_context, const char* line);
+NASAL_EXPORT const char* nasal_repl_get_version();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif