Merge branch 'patch-4' of https://github.com/luxxxoor/amxmodx

"Invalid map handle provided (%d)" error is very unclear when it appears in complex code.

.gitattributes

@@ -0,0 +1,24 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Tell GitHub that these files are SourcePawn
+*.inc text linguist-language=sourcepawn
+*.sma text linguist-language=sourcepawn
+
+# Custom for Visual Studio
+*.cs diff=csharp
+
+# Sources
+*.C text
+*.cc text
+*.cxx text
+*.cpp text
+*.c++ text
+*.hpp text
+*.h text
+*.h++ text
+*.hh text
+
+# Compiled Object files
+*.o binary
+*.obj binary

.github/CONTRIBUTING.md

@@ -0,0 +1,74 @@
+# Contributing to AMX Mod X
+
+## Issue reports
+
+Please consider the following guidelines when reporting an issue.
+
+#### Not for general support
+This is not the right place to get help with using or installing AMX Mod X, or for issues with specific, third-party AMX Mod X plugins or extensions.
+
+For help with AMX Mod X, please consult the [AlliedModders forums](https://forums.alliedmods.net/forumdisplay.php?f=3). Similarly, for assistance with, or to report issues with, third-party AMX Mod X plugins or extensions, you should post in the existing thread for that plugin or extension on the [AlliedModders forums](https://forums.alliedmods.net/forumdisplay.php?f=3).
+
+#### Details, details, details
+Provide as much detail as possible when reporting an issue.
+
+For bugs or other undesired behavior, answers to the following questions are a great start:
+* What is the issue?
+* What behavior are you expecting instead?
+* On what operating system is the game server running?
+* What game is the game server running?
+* What exact versions (full x.y.z.a version number) of Metamod and AMX Mod X are installed on the game server?
+* What is the specific, shortest path to reproducing this issue? If this issue can be reproduced with plugin code, please try to shorten it to the minimum required to trigger the problem.
+
+If this is a feature request, the following are helpful. Generally, not all will apply, but whatever you can answer ahead of time will shorten back and forth conversation.
+* What is your end goal, or what are you trying to accomplish?
+* Why is this necessary, or what benefit do you see with it?
+* Will this be useful to others?
+
+#### Issues with security implications
+Please report any security bugs to [security@alliedmods.net](mailto:security@alliedmods.net) rather than to this public issue tracker.
+
+#### We're only human
+Please keep in mind that we maintain this project in our spare time, at no cost. There is no SLA, and you are not owed a response or a fix.
+
+#### Conduct
+Please refer to the [AlliedModders forum rules.](https://forums.alliedmods.net/misc.php?do=showrules)
+
+## Pull Requests
+
+Firstly, thank you for considering contributing changes to the project!
+
+However, if this is anything more than a small fix such as a gamedata update, a glaring code flaw, or a simple typo in a file like this one, please file an issue first so that it can be discussed, unless you have already spoken to multiple members of the development team about it on IRC or the AlliedModders forums.
+
+We don't like to have to reject pull requests, so we want to avoid those scenarios. We wouldn't want you to feel like you wasted your time writing something only for us to shoot it down.
+
+#### Rejection
+*Copied from Phabricator's [Contributing Code guidelines](https://secure.phabricator.com/book/phabcontrib/article/contributing_code/#rejecting-patches), as we largely feel the same way about this.*
+
+> If you send us a patch without coordinating it with us first, it will probably be immediately rejected, or sit in limbo for a long time and eventually be rejected. The reasons we do this vary from patch to patch, but some of the most common reasons are:
+>
+> **Unjustifiable Costs**: We support code in the upstream forever. Support is enormously expensive and takes up a huge amount of our time. The cost to support a change over its lifetime is often 10x or 100x or 1000x greater than the cost to write the first version of it. Many uncoordinated patches we receive are "white elephants", which would cost much more to maintain than the value they provide.
+> 
+> As an author, it may look like you're giving us free work and we're rejecting it as too expensive, but this viewpoint doesn't align with the reality of a large project which is actively supported by a small, experienced team. Writing code is cheap; maintaining it is expensive.
+>
+> By coordinating with us first, you can make sure the patch is something we consider valuable enough to put long-term support resources behind, and that you're building it in a way that we're comfortable taking over.
+> 
+> **Not a Good Fit**: Many patches aren't good fits for the upstream: they implement features we simply don't want. You can find more information in Contributing Feature Requests. Coordinating with us first helps make sure we're on the same page and interested in a feature.
+>
+> The most common type of patch along these lines is a patch which adds new configuration options. We consider additional configuration options to have an exceptionally high lifetime support cost and are very unlikely to accept them. Coordinate with us first.
+> 
+> **Not a Priority**: If you send us a patch against something which isn't a priority, we probably won't have time to look at it. We don't give special treatment to low-priority issues just because there's code written: we'd still be spending time on something lower-priority when we could be spending it on something higher-priority instead.
+> 
+> If you coordinate with us first, you can make sure your patch is in an area of the codebase that we can prioritize.
+> 
+> **Overly Ambitious Patches**: Sometimes we'll get huge patches from new contributors. These can have a lot of fundamental problems and require a huge amount of our time to review and correct. If you're interested in contributing, you'll have more success if you start small and learn as you go.
+> 
+> We can help you break a large change into smaller pieces and learn how the codebase works as you proceed through the implementation, but only if you coordinate with us first.
+> 
+> **Generality**: We often receive several feature requests which ask for similar features, and can come up with a general approach which covers all of the use cases. If you send us a patch for your use case only, the approach may be too specific. When a cleaner and more general approach is available, we usually prefer to pursue it.
+> 
+> By coordinating with us first, we can make you aware of similar use cases and opportunities to generalize an approach. These changes are often small, but can have a big impact on how useful a piece of code is.
+> 
+> **Infrastructure and Sequencing**: Sometimes patches are written against a piece of infrastructure with major planned changes. We don't want to accept these because they'll make the infrastructure changes more difficult to implement.
+> 
+> Coordinate with us first to make sure a change doesn't need to wait on other pieces of infrastructure. We can help you identify technical blockers and possibly guide you through resolving them if you're interested.

.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: https://www.sourcemod.net/donate.php

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,25 @@
+# Help us help you
+  - [ ] I have checked that my issue [doesn't exist yet](https://github.com/alliedmodders/amxmodx/issues).
+  - [ ] I have tried my absolute best to reduce the problem-space and have provided the absolute smallest test-case possible.
+  - [ ] I can always reproduce the issue with the provided description below.
+
+# Environment
+  * Operating System version: 
+  * Game/AppID (with version if applicable): 
+  * Current AMX Mod X version: 
+  * Current Metamod version:
+  - [ ] I have updated AMX Mod X to the [latest version](https://www.amxmodx.org/downloads.php) and it still happens.
+  - [ ] I have updated AMX Mod X to the [latest snapshot](https://www.amxmodx.org/snapshots.php) and it still happens.
+  - [ ] I have updated Metamod to the [latest version](https://www.amxmodx.org/downloads.php) and it still happens.
+
+# Description
+
+
+# Problematic Code (or Steps to Reproduce)
+  ```PAWN
+  // TODO(you): code here to reproduce the problem
+  ```
+
+# Logs
+* Please attach in separate files: game output, library logs, kernel logs, and any other supporting information.
+* In case of a crash, please attach minidump or dump analyze output.

.github/workflows/ci.yml

@@ -0,0 +1,137 @@
+name: Continuous Integration
+on: 
+  workflow_dispatch:
+  push:
+    branches:
+     - master
+     - 1.9-dev
+  pull_request:
+    branches:
+     - master
+     - 1.9-dev
+jobs:
+  test:
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            os_short: linux
+            compiler_cc: gcc
+            compiler_cxx: g++
+          - os: ubuntu-latest
+            os_short: linux
+            compiler_cc: clang
+            compiler_cxx: clang++        
+          - os: ubuntu-18.04
+            os_short: linux
+            compiler_cc: clang-3.9
+            compiler_cxx: clang++-3.9
+          - os: ubuntu-18.04
+            os_short: linux
+            compiler_cc: gcc-6
+            compiler_cxx: g++-6
+            compiler_install: 'g++6 g++-6-multilib'
+          - os: windows-latest
+            os_short: windows
+            compiler_cc: msvc
+          - os: windows-2016
+            os_short: windows
+            compiler_cc: msvc++14.16-vs2017-cl
+# MacOS 32 Bins seem not supported
+#           - os: macos-latest
+#             os_short: mac
+#             compiler_cc: clang
+#             compiler_cxx: clang++            
+      fail-fast: false
+    runs-on: ${{ matrix.os }}
+    name: ${{ matrix.os_short }}-${{ matrix.os }}-${{ matrix.compiler_cc }}
+    env:
+      DEPENDENCIES_FOLDER: dependencies      
+      DEPENDENCIES_ROOT: ${{ github.workspace }}/dependencies      
+      DEPENDENCIES_ROOT_WIN: ${{ github.workspace }}\dependencies              
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+          path: amxmodx
+      # Setup Python for AMBuild
+      - uses: actions/setup-python@v2
+        name: Setup Python 3.8
+        with:
+          python-version: 3.8
+      - name: Install Python dependencies
+        run: |
+          python3 -m pip install --upgrade pip setuptools wheel
+          python3 --version
+      - name: Install AMXModX dependencies (Linux)
+        if: startsWith(runner.os, 'Linux') || startsWith(runner.os, 'macOS')
+        shell: bash
+        run: |
+          mkdir -p ${{ env.DEPENDENCIES_FOLDER }}
+          cd ${{ env.DEPENDENCIES_FOLDER }}
+          
+          # Satisfy checkout-deps requirement for a "amxmodx" folder.
+          mkdir -p amxmodx
+          ../amxmodx/support/checkout-deps.sh          
+      - name: Install AMXModX dependencies (Windows)
+        if: startsWith(runner.os, 'Windows')
+        shell: cmd
+        run: |
+          mkdir %DEPENDENCIES_ROOT_WIN%\nasm
+          curl -L -o "%DEPENDENCIES_ROOT_WIN%\nasm\nasm.zip" https://www.nasm.us/pub/nasm/releasebuilds/2.13.03/win32/nasm-2.13.03-win32.zip
+          chdir %DEPENDENCIES_ROOT_WIN%\nasm
+          7z x nasm.zip
+          
+          chdir %DEPENDENCIES_ROOT_WIN%
+          git clone https://github.com/alliedmodders/ambuild
+          git clone https://github.com/alliedmodders/metamod-hl1 metamod-am
+          git clone https://github.com/alliedmodders/hlsdk
+          
+          curl -L -o "mysql-connector-c-6.1.1-win32.zip" https://downloads.mysql.com/archives/get/p/19/file/mysql-connector-c-6.1.1-win32.zip
+          7z x mysql-connector-c-6.1.1-win32.zip -o"mysql"
+          cd mysql
+          dir
+          ren mysql-connector-c-6.1.1-win32 mysql-5.5
+          move /Y mysql-5.5 ..\
+          
+          cd ..\ambuild
+          python3 setup.py install          
+      - name: Install Linux dependencies
+        if: startsWith(runner.os, 'Linux')
+        run: |
+          sudo dpkg --add-architecture i386
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            gcc-multilib g++-multilib libstdc++6 lib32stdc++6 \
+            libc6-dev libc6-dev-i386 linux-libc-dev \
+            linux-libc-dev:i386 lib32z1-dev nasm ${{ matrix.compiler_cc }} ${{ matrix.compiler_install }}
+      - name: Select compiler
+        if: startsWith(runner.os, 'Linux')
+        run: |
+          echo "CC=${{ matrix.compiler_cc }}" >> $GITHUB_ENV
+          echo "CXX=${{ matrix.compiler_cxx }}" >> $GITHUB_ENV
+          ${{ matrix.compiler_cc }} --version
+          ${{ matrix.compiler_cxx }} --version
+      - uses: ilammy/setup-nasm@v1
+      - name: Build Linux/macOS
+        if: startsWith(runner.os, 'Linux') || startsWith(runner.os, 'macOS')
+        working-directory: amxmodx
+        run: |
+          mkdir build
+          cd build
+          python3 ../configure.py --enable-optimize --metamod=${{ env.DEPENDENCIES_ROOT }}/metamod-am --hlsdk=${{ env.DEPENDENCIES_ROOT }}/hlsdk --mysql=${{ env.DEPENDENCIES_ROOT }}/mysql-5.5
+          ambuild
+      - uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: x86
+      - name: Build Windows
+        if: startsWith(runner.os, 'Windows')
+        working-directory: amxmodx
+        shell: cmd
+        run: |
+          cl.exe
+          mkdir build
+          cd build
+          python3 ../configure.py --enable-optimize --metamod=${{ env.DEPENDENCIES_ROOT_WIN }}\metamod-am --hlsdk=${{ env.DEPENDENCIES_ROOT_WIN }}\hlsdk --mysql=${{ env.DEPENDENCIES_ROOT_WIN }}\mysql-5.5
+          ambuild
+          

.gitignore

@@ -0,0 +1,90 @@
+# Binaries
+*.dll
+*.exe
+*.so
+
+# User-specific files
+*.suo
+*.user
+*.sln.docstates
+
+# Build results
+[Dd]ebug/
+[Rr]elease/
+JITDebug/
+JITRelease/
+JITDebugBinLog/
+JITReleaseBinLog/
+x64/
+build/
+[Bb]in/
+[Oo]bj/
+build/
+obj-*/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+.vscode/
+
+*_i.c
+*_p.c
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.log
+*.scc
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Backup & report files from converting an old project file to a newer
+# Visual Studio version. Backup files are not needed, because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# Files generated by Mac OS X Finder
+.DS_Store
+
+# Files generated by Windows Explorer
+Desktop.ini
+Thumbs.db
+
+# AMXX plugin build related files
+plugins/compile.dat
+plugins/compiled/
+*.amx
+*.amxx
+
+build_deps/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "public/amtl"]
+	path = public/amtl
+	url = https://github.com/alliedmodders/amtl

.travis.yml

@@ -0,0 +1,30 @@
+addons:
+  apt:
+    packages:
+    - clang-3.7
+    - lib32stdc++6
+    - lib32z1-dev
+    - libc6-dev-i386
+    - linux-libc-dev
+    - gcc-multilib
+    - g++-multilib
+    - nasm
+    sources:
+    - llvm-toolchain-precise-3.7
+    - ubuntu-toolchain-r-test
+language: cpp
+sudo: false
+compiler:
+  - clang
+install:
+  - pyenv install 3.6.3
+  - pyenv global 3.6.3
+before_script:
+  - CHECKOUT_DIR=$PWD && cd .. 
+  - chmod a+x $CHECKOUT_DIR/support/checkout-deps.sh 
+  - $CHECKOUT_DIR/support/checkout-deps.sh && cd $CHECKOUT_DIR
+script:
+  - mkdir build && cd build
+  - PATH="~/.local/bin:$PATH"
+  - CC=clang-3.7 CXX=clang-3.7 python3 ../configure.py --enable-optimize
+  - ambuild

AMBuildScript

@@ -0,0 +1,514 @@
+# vim: set sts=2 ts=8 sw=2 tw=99 et ft=python :
+import os
+import subprocess
+import locale
+
+class AMXXConfig(object):
+  def __init__(self):
+    self.binaries = []
+    self.modules = []
+    self.plugins = {}
+    self.libpc300 = None
+    self.amxxpc = None
+    self.metamod_path = None
+    self.hlsdk_path = None
+    self.mysql_path = None
+    self.generated_headers = []
+    self.versionlib = None
+    self.zlib = None
+    self.hashing = None
+    self.utf8rewind = None
+    self.csx_app = None
+    self.stdcxx_path = None
+    self.nasm_path = None
+
+  def use_auto_versioning(self):
+    if builder.backend != 'amb2':
+      return False
+    return not getattr(builder.options, 'disable_auto_versioning', False)
+
+  def detectProductVersion(self):
+    builder.AddConfigureFile('product.version')
+
+    # For OS X dylib versioning
+    import re
+    with open(os.path.join(builder.sourcePath, 'product.version'), 'r') as fp:
+      productContents = fp.read()
+    m = re.match('(\d+)\.(\d+)\.(\d+).*', productContents)
+    if m == None:
+      self.productVersion = '1.0.0'
+    else:
+      major, minor, release = m.groups()
+      self.productVersion = '{0}.{1}.{2}'.format(major, minor, release)
+
+  def detectMetamod(self):
+    metamod_path = builder.options.metamod_path
+    if not len(metamod_path):
+      metamod_path = os.getenv('METAMOD', '')
+
+    if len(metamod_path):
+      self.metamod_path = os.path.join(builder.originalCwd, metamod_path)
+      if not os.path.exists(os.path.join(self.metamod_path, 'metamod')):
+        raise Exception('Metamod path does not exist: {0}'.format(metamod_path))
+    else:
+      try_paths = [
+        os.path.join(builder.sourcePath, '..', 'metamod'),
+        os.path.join(builder.sourcePath, '..', 'metamod-am'),
+        os.path.join(builder.sourcePath, '..', 'metamod-hl1'),
+      ]
+      for try_path in try_paths:
+        if os.path.exists(os.path.join(try_path, 'metamod')):
+          self.metamod_path = os.path.normpath(try_path)
+          break
+      if not self.metamod_path:
+        raise Exception('Could not find the source code to Metamod! Try passing --metamod to configure.py.')
+
+  def detectHlsdk(self):
+    hlsdk_path = builder.options.hlsdk_path
+    if not len(hlsdk_path):
+      hlsdk_path = os.getenv('HLSDK', '')
+
+    if len(hlsdk_path):
+      self.hlsdk_path = os.path.join(builder.originalCwd, hlsdk_path)
+      if not os.path.exists(self.hlsdk_path):
+        raise Exception('HLSDK path does not exist: {0}'.format(hlsdk_path))
+    else:
+      try_paths = [
+        os.path.join(builder.sourcePath, '..', 'hlsdk'),
+      ]
+      for try_path in try_paths:
+        if os.path.exists(try_path):
+          self.hlsdk_path = os.path.normpath(try_path)
+          break
+      if not self.hlsdk_path:
+        raise Exception('Could not find the HLSDK! Try passing --hlsdk to configure.py.')
+
+  def detectMysql(self):
+    if builder.options.disable_mysql:
+      return
+
+    mysql_path = builder.options.mysql_path
+    if not len(mysql_path):
+      mysql_path = os.getenv('MYSQL55', '')
+
+    if len(mysql_path):
+      self.mysql_path = os.path.join(builder.originalCwd, mysql_path)
+      if not os.path.exists(self.mysql_path):
+        raise Exception('MySQL path does not exist: {0}'.format(mysql_path))
+    else:
+      try_paths = [
+        os.path.join(builder.sourcePath, '..', 'mysql-5.5'),
+      ]
+      for try_path in try_paths:
+        if os.path.exists(try_path):
+          self.mysql_path = os.path.normpath(try_path)
+          break
+      if not self.mysql_path:
+        raise Exception('Could not find MySQL! Try passing --mysql to configure.py.')
+
+  def detectNASM(self):
+    import subprocess
+
+    nasm_paths = [
+      getattr(builder.options, 'nasm_path', 'nasm'),
+    ]
+    if builder.target_platform == 'windows':
+      nasm_paths += [os.path.join(
+        builder.sourcePath,
+        'build_deps',
+        'nasm',
+        'nasm.exe')
+      ]
+
+    for nasm_path in nasm_paths:
+      try:
+        subprocess.check_output([nasm_path, '-v'])
+        self.nasm_path = nasm_path
+        break
+      except:
+        pass
+
+    if self.nasm_path is None:
+      raise Exception('Could not find a suitable path for nasm')
+
+  # Returns list of lines of output from the compiler
+  @staticmethod
+  def invokeCompiler(args):
+    if builder.compiler:
+      p = subprocess.Popen(builder.compiler.argv + args, stdout=subprocess.PIPE)
+      output = p.communicate()[0]
+      if hasattr(output,'encoding') and output.encoding is not None:
+          encoding = output.encoding
+      else:
+          encoding = locale.getpreferredencoding()
+      return output.decode(encoding, 'replace').split('\n')
+    return None
+
+  def configure(self):
+    builder.AddConfigureFile('pushbuild.txt')
+
+    cxx = builder.DetectCompilers()
+
+    if cxx.like('gcc'):
+      self.configure_gcc(cxx)
+    elif cxx.like('msvc'):
+      self.configure_msvc(cxx)
+
+    # Optimization
+    if builder.options.opt == '1':
+      cxx.defines += ['NDEBUG']
+
+    # Debugging
+    if builder.options.debug == '1':
+      cxx.defines += ['DEBUG', '_DEBUG']
+
+    # Platform-specifics
+    if builder.target_platform == 'linux':
+      self.configure_linux(cxx)
+    elif builder.target_platform == 'mac':
+      self.configure_mac(cxx)
+    elif builder.target_platform == 'windows':
+      self.configure_windows(cxx)
+
+    # Finish up.
+    cxx.defines += [
+      'AMX_NOPROPLIST',
+      'PAWN_CELL_SIZE=32',
+      'AMXMODX_BUILD',
+      'AMXX_USE_VERSIONLIB',
+    ]
+
+    if self.use_auto_versioning():
+      cxx.defines += ['AMXX_GENERATED_BUILD']
+      cxx.includes += [os.path.join(builder.buildPath, 'includes')]
+      cxx.includes += [os.path.join(builder.sourcePath, 'support', 'versionlib')]
+
+    cxx.includes += [os.path.join(builder.sourcePath, 'public')]
+    cxx.includes += [os.path.join(builder.sourcePath, 'public', 'sdk')]
+    cxx.includes += [os.path.join(builder.sourcePath, 'public', 'amtl')]
+    cxx.includes += [os.path.join(builder.sourcePath, 'public', 'amtl', 'amtl')]
+    cxx.includes += [os.path.join(builder.sourcePath, 'public', 'memtools')]
+    cxx.includes += [os.path.join(builder.sourcePath, 'third_party')]
+    cxx.includes += [os.path.join(builder.sourcePath, 'third_party', 'hashing')]
+    cxx.includes += [os.path.join(builder.sourcePath, 'third_party', 'zlib')]
+    cxx.includes += [os.path.join(builder.sourcePath, 'third_party', 'utf8rewind')]
+
+  def configure_gcc(self, cxx):
+    cxx.cflags += [
+      '-pipe',
+      '-fno-strict-aliasing',
+      '-Wall',
+      '-Werror',
+      '-Wno-uninitialized',
+      '-Wno-unused',
+      '-Wno-switch',
+      '-Wno-format',
+      '-Wno-format-security',
+      '-m32',
+    ]
+    cxx.cxxflags += [
+      '-Wno-invalid-offsetof',
+      '-std=c++11',
+    ]
+
+    cxx.linkflags += ['-m32']
+
+    have_gcc = cxx.vendor == 'gcc'
+    have_clang = cxx.vendor == 'clang'
+
+    if have_clang or (have_gcc and cxx.version >= '4'):
+      cxx.cflags += ['-fvisibility=hidden']
+      cxx.cxxflags += ['-fvisibility-inlines-hidden']
+      if have_clang or (have_gcc and cxx.version >= '4.6'):
+        cxx.cflags += ['-Wno-narrowing']
+      if (have_gcc and cxx.version >= '4.7') or (have_clang and cxx.version >= '3'):
+        cxx.cxxflags += ['-Wno-delete-non-virtual-dtor']
+      if have_gcc and cxx.version >= '4.8':
+        cxx.cflags += ['-Wno-unused-result', '-Wno-error=sign-compare']
+      if have_gcc and cxx.version >= '8.0':
+        cxx.cflags += ['-Wno-stringop-truncation']
+      if have_gcc and cxx.version >= '9.0':
+        cxx.cflags += ['-Wno-address-of-packed-member']		
+    if have_clang:
+      cxx.cxxflags += ['-Wno-implicit-exception-spec-mismatch']
+      if cxx.version >= '10.0':
+        cxx.cxxflags += ['-Wno-tautological-compare']
+      if cxx.version >= 'apple-clang-10.0':
+        cxx.cxxflags += [
+          '-Wno-inconsistent-missing-override',
+          '-Wno-varargs',
+        ]
+      if cxx.version >= 'apple-clang-5.1' or cxx.version >= 'clang-3.4':
+        cxx.cxxflags += ['-Wno-deprecated-register']
+      else:
+        cxx.cxxflags += ['-Wno-deprecated']
+      cxx.cflags += ['-Wno-sometimes-uninitialized']
+      if builder.target_platform == 'linux' and cxx.version >= '3.6':
+        cxx.cxxflags += ['-Wno-inconsistent-missing-override']
+      if builder.target_platform == 'linux' and cxx.version >= '3.9':
+        cxx.cxxflags += ['-Wno-varargs']
+      if builder.target_platform == 'linux' and cxx.version >= '4.0':
+        cxx.cxxflags += ['-Wno-address-of-packed-member']
+
+    if have_gcc:
+      cxx.cflags += ['-Wno-parentheses']
+      cxx.c_only_flags += ['-std=c99']
+    elif have_clang:
+      cxx.cflags += ['-Wno-logical-op-parentheses']
+
+    cxx.cxxflags += [
+      '-fno-exceptions',
+      '-fno-rtti',
+    ]
+
+    if builder.options.opt == '1':
+      cxx.cflags += ['-O2']
+
+  def configure_msvc(self, cxx):
+    if builder.options.debug == '1':
+      cxx.cflags += ['/MTd']
+      cxx.linkflags += ['/NODEFAULTLIB:libcmt']
+    else:
+      cxx.cflags += ['/MT']
+
+    cxx.defines += [
+      '_CRT_SECURE_NO_DEPRECATE',
+      '_CRT_SECURE_NO_WARNINGS',
+      '_CRT_NONSTDC_NO_DEPRECATE',
+      '_ITERATOR_DEBUG_LEVEL=0',
+    ]
+    cxx.cflags += [
+      '/W3',
+    ]
+    cxx.cxxflags += [
+      '/EHsc',
+      '/GR-',
+      '/TP',
+    ]
+    cxx.linkflags += [
+      '/MACHINE:X86',
+      '/SUBSYSTEM:WINDOWS',
+      'kernel32.lib',
+      'user32.lib',
+      'gdi32.lib',
+      'winspool.lib',
+      'comdlg32.lib',
+      'advapi32.lib',
+      'shell32.lib',
+      'ole32.lib',
+      'oleaut32.lib',
+      'uuid.lib',
+      'odbc32.lib',
+      'odbccp32.lib',
+    ]
+
+    if cxx.version >= 1900:
+      cxx.linkflags += ['legacy_stdio_definitions.lib', 'legacy_stdio_wide_specifiers.lib']
+
+    if builder.options.opt == '1':
+      cxx.cflags += ['/Ox']
+      cxx.linkflags += ['/OPT:ICF', '/OPT:REF']
+
+    if builder.options.debug == '1':
+      cxx.cflags += ['/Od', '/RTC1']
+
+    # This needs to be after our optimization flags which could otherwise disable it.
+    # Don't omit the frame pointer.
+    cxx.cflags += ['/Oy-']
+
+  def configure_linux(self, cxx):
+    cxx.defines += ['_LINUX', 'POSIX', 'LINUX']
+    cxx.linkflags  += ['-ldl', '-lm']
+    if cxx.vendor == 'gcc':
+      cxx.linkflags  += ['-static-libgcc']
+    elif cxx.vendor == 'clang':
+      cxx.linkflags  += ['-lgcc_eh']
+    if cxx.like('gcc'):
+      self.stdcxx_path = self.invokeCompiler(['-m32', '-print-file-name=' + 'libstdc++.a'])[0]
+
+  def configure_mac(self, cxx):
+    cxx.defines += ['OSX', '_OSX', 'POSIX']
+    cxx.cflags += [
+      '-mmacosx-version-min=10.7',
+      '-Wno-address-of-packed-member',
+    ]
+    cxx.linkflags += [
+      '-mmacosx-version-min=10.7',
+      '-arch', 'i386',
+      '-lstdc++',
+      '-stdlib=libc++',
+      '-framework', 'CoreServices',
+    ]
+    cxx.cxxflags += ['-stdlib=libc++']
+
+  def configure_windows(self, cxx):
+    cxx.defines += ['WIN32', '_WINDOWS']
+
+  #
+  # Low-level compiler and binary construction.
+  #
+
+  def ConfigureForModule(self, context, compiler):
+    compiler.cxxincludes += [
+      os.path.join(context.currentSourcePath),
+      os.path.join(context.currentSourcePath, 'sdk'),
+      os.path.join(self.metamod_path, 'metamod'),
+      os.path.join(self.hlsdk_path, 'common'),
+      os.path.join(self.hlsdk_path, 'dlls'),
+      os.path.join(self.hlsdk_path, 'engine'),
+      os.path.join(self.hlsdk_path, 'game_shared'),
+      os.path.join(self.hlsdk_path, 'public'),
+      os.path.join(self.hlsdk_path, 'pm_shared'),
+    ]
+    return compiler
+
+  def AddVersioning(self, binary):
+    if builder.target_platform == 'windows':
+      binary.compiler.rcdefines += [
+        'BINARY_NAME="{0}"'.format(binary.outputFile),
+        'RC_COMPILE',
+      ]
+      if self.use_auto_versioning():
+        binary.compiler.rcdefines += ['AMXX_GENERATED_BUILD']
+    elif builder.target_platform == 'mac':
+      if binary.type == 'library':
+        binary.compiler.postlink += [
+          '-compatibility_version', '1.0.0',
+          '-current_version', self.productVersion
+        ]
+    if self.use_auto_versioning():
+      binary.compiler.linkflags += [self.versionlib]
+      binary.compiler.sourcedeps += AMXX.generated_headers
+    return binary
+
+  #
+  # High level job construction for libraries, metamod plugins, modules, and
+  # executables.
+  #
+
+  def Library(self, context, name):
+    binary = context.compiler.Library(name)
+    return self.AddVersioning(binary)
+
+  def MetaPlugin(self, context, name):
+    if builder.target_platform == 'mac' or builder.target_platform == 'windows':
+      name = name + '_mm'
+    elif builder.target_platform == 'linux':
+      name = name + '_mm_i386'
+    binary = context.compiler.Library(name)
+    self.ConfigureForModule(context, binary.compiler)
+    return self.AddVersioning(binary)
+
+  def MetaModule(self, context, name):
+    if builder.target_platform == 'mac' or builder.target_platform == 'windows':
+      name = name + '_amxx'
+    elif builder.target_platform == 'linux':
+      name = name + '_amxx_i386'
+    binary = context.compiler.Library(name)
+    self.ConfigureForModule(context, binary.compiler)
+    return self.AddVersioning(binary)
+
+  def Program(self, context, name):
+    binary = context.compiler.Program(name)
+    return self.AddVersioning(binary)
+
+  def AddAssembly(self, context, binary, input_file, output_file, includes=[], extra_argv=[]):
+    if builder.target_platform == 'windows':
+      obj_type = 'win32'
+    elif builder.target_platform == 'linux':
+      obj_type = 'elf32'
+    elif builder.target_platform == 'mac':
+      obj_type = 'macho32'
+
+    input_path = os.path.join(context.currentSourcePath, input_file)
+    output_path = output_file
+
+    argv = [
+      self.nasm_path,
+      '-I{0}{1}'.format(context.currentSourcePath, os.sep),
+      input_path,
+      '-f', obj_type,
+      '-o', output_path,
+    ] + extra_argv
+
+    extra_includes = []
+    for include_file in includes:
+      extra_includes.append(os.path.join(context.currentSourcePath, include_file))
+
+    cmd_node, output_nodes = context.AddCommand(
+      inputs = [input_path] + extra_includes,
+      argv = argv,
+      outputs = [output_path])
+
+    binary.compiler.linkflags += [output_nodes[0]]
+
+AMXX = AMXXConfig()
+AMXX.detectProductVersion()
+AMXX.detectMetamod()
+AMXX.detectHlsdk()
+AMXX.detectMysql()
+AMXX.detectNASM()
+AMXX.configure()
+
+if AMXX.use_auto_versioning():
+  AMXX.generated_headers = builder.RunScript(
+    'support/Versioning',
+    { 'AMXX': AMXX }
+  )
+  AMXX.versionlib = builder.RunScript(
+    'support/versionlib/AMBuilder',
+    { 'AMXX': AMXX }
+  )
+
+AMXX.zlib = builder.RunScript(
+  'third_party/zlib/AMBuilder'
+)
+
+AMXX.hashing = builder.RunScript(
+  'third_party/hashing/AMBuilder'
+)
+
+AMXX.utf8rewind = builder.RunScript(
+  'third_party/utf8rewind/AMBuilder'
+)
+
+builder.RunBuildScripts(
+  [
+    'amxmodx/AMBuilder',
+    'compiler/amxxpc/AMBuilder',
+    'compiler/libpc300/AMBuilder',
+    'modules/cstrike/cstrike/AMBuilder',
+    'modules/cstrike/csx/AMBuilder',
+    'modules/dod/dodfun/AMBuilder',
+    'modules/dod/dodx/AMBuilder',
+    'modules/engine/AMBuilder',
+    'modules/fakemeta/AMBuilder',
+    'modules/fun/AMBuilder',
+    'modules/geoip/AMBuilder',
+    'modules/hamsandwich/AMBuilder',
+    'modules/json/AMBuilder',
+    'modules/mysqlx/AMBuilder',
+    'modules/ns/AMBuilder',
+    'modules/nvault/AMBuilder',
+    'modules/regex/AMBuilder',
+    'modules/sockets/AMBuilder',
+    'modules/sqlite/AMBuilder',
+    'modules/tfcx/AMBuilder',
+    'modules/ts/tsfun/AMBuilder',
+    'modules/ts/tsx/AMBuilder',
+  ],
+  { 'AMXX': AMXX }
+)
+
+# The csstats.dat reader is Windows-only.
+if builder.target_platform == 'windows':
+  builder.RunScript('modules/cstrike/csx/WinCSX/AMBuilder', { 'AMXX': AMXX })
+
+if builder.backend == 'amb2':
+  builder.RunBuildScripts([
+      'plugins/AMBuilder',
+      'support/PackageScript',
+    ],
+    { 'AMXX': AMXX }
+  )
+

README.md

@@ -0,0 +1,22 @@
+
+<p align="center">
+ <img src="https://github.com/alliedmodders/amxmodx/blob/master/editor/studio/AMXXLarge.bmp"/>
+</p>
+
+**AMX Mod X** is a [Metamod](https://github.com/jkivilin/metamod-p) plugin for [Half-Life 1](https://github.com/ValveSoftware/halflife). It provides comprehensive scripting for the game engine and its mods. Scripts can intercept network messages, log events, commands, client commands, set cvars, modify entities, and more. AMX Mod X also has a system for extending native scripting through modules, leading to outside support for things like MySQL and Sockets.
+
+General
+-------
+- [AMXX website](https://amxmodx.org/)
+- [Forum](https://forums.alliedmods.net/forumdisplay.php?f=3): Discussion forum including plugin/extension development
+- [General documentation](https://wiki.alliedmods.net/Category:Documentation_%28AMX_Mod_X%29): Miscellaneous information about AMXX
+- [Latest release](https://amxmodx.org/downloads.php): The latest stable AMXX release
+- [Build snapshots](https://www.amxmodx.org/downloads-new.php): Builds of recent development versions
+ 
+Development
+-----------
+- [Issue tracker](https://github.com/alliedmodders/amxmodx/issues): Issues that require back and forth communication
+- [Issue archive](https://bugs.alliedmods.net/describecomponents.cgi?product=AMX%20Mod%20X): Old issue tracker (read-only)
+- [Building AMXX](https://wiki.alliedmods.net/Building_AMX_Mod_X): Instructions on how to build AMXX itself using [AMBuild](https://github.com/alliedmodders/ambuild)
+- [AMX Mod X API](https://amxmodx.org/api/): AMX Mod X API reference generated from include files
+- [AMXX scripting](https://wiki.alliedmods.net/Category:Scripting_(AMX_Mod_X)): Pawn examples and introduction to the language

amxmodx/AMBuilder

@@ -0,0 +1,101 @@
+# vim: set sts=2 ts=8 sw=2 tw=99 et ft=python:
+import os.path
+
+binary = AMXX.MetaPlugin(builder, 'amxmodx')
+
+binary.compiler.defines += [
+  'JIT',
+  'ASM32',
+  'HAVE_STDINT_H',
+]
+
+AMXX.AddAssembly(builder, binary, 'helpers-x86.asm', 'helpers-asm.obj')
+AMXX.AddAssembly(builder, binary, 'natives-x86.asm', 'natives-asm.obj')
+AMXX.AddAssembly(builder, binary, 'amxexecn.asm', 'amxexecn-asm.obj',
+  includes=['amxdefn.asm'])
+AMXX.AddAssembly(builder, binary, 'amxjitsn.asm', 'amxjitsn-asm.obj',
+  includes=['amxdefn.asm'],
+  # Opcode sizes must be maximum width for patching to work.
+  extra_argv=['-O0'])
+
+if builder.target_platform == 'mac':
+  binary.compiler.postlink += [
+    '-Wl,-read_only_relocs,suppress'
+  ]
+elif builder.target_platform == 'windows':
+  binary.compiler.linkflags += [
+    '/EXPORT:GiveFnptrsToDll=_GiveFnptrsToDll@8,@1',
+    '/SECTION:.data,RW',
+  ]
+elif builder.target_platform == 'linux':
+  binary.compiler.postlink += [
+    binary.Dep(AMXX.stdcxx_path),
+  ]
+
+binary.compiler.linkflags += [AMXX.zlib.binary, AMXX.hashing.binary, AMXX.utf8rewind.binary]
+
+binary.sources = [
+  'meta_api.cpp',
+  'CVault.cpp',
+  'vault.cpp',
+  'float.cpp',
+  'file.cpp',
+  'modules.cpp',
+  'CMisc.cpp',
+  'CTask.cpp',
+  'string.cpp',
+  'amxmodx.cpp',
+  'CEvent.cpp',
+  'CCmd.cpp',
+  'CLogEvent.cpp',
+  'srvcmd.cpp',
+  'strptime.cpp',
+  'amxcore.cpp',
+  'amxtime.cpp',
+  'power.cpp',
+  'amxxlog.cpp',
+  'fakemeta.cpp',
+  'amxxfile.cpp',
+  'CLang.cpp',
+  'emsg.cpp',
+  'CForward.cpp',
+  'CPlugin.cpp',
+  'CModule.cpp',
+  'CMenu.cpp',
+  'util.cpp',
+  'amx.cpp',
+  'amxdbg.cpp',
+  'natives.cpp',
+  'newmenus.cpp',
+  'debugger.cpp',
+  'optimizer.cpp',
+  'format.cpp',
+  'messages.cpp',
+  'libraries.cpp',
+  'vector.cpp',
+  'sorting.cpp',
+  'nongpl_matches.cpp',
+  'CFlagManager.cpp',
+  'datastructs.cpp',
+  'trie_natives.cpp',
+  'CDataPack.cpp',
+  'datapacks.cpp',
+  'stackstructs.cpp',
+  'CTextParsers.cpp',
+  'textparse.cpp',
+  'CvarManager.cpp',
+  'cvars.cpp',
+  '../public/memtools/MemoryUtils.cpp',
+  '../public/memtools/CDetour/detours.cpp',
+  '../public/memtools/CDetour/asm/asm.c',
+  '../public/resdk/mod_rehlds_api.cpp',
+  'CLibrarySys.cpp',
+  'CGameConfigs.cpp',
+  'gameconfigs.cpp',
+  'CoreConfig.cpp',
+]
+
+if builder.target_platform == 'windows':
+  binary.sources += ['version.rc']
+
+AMXX.binaries += [builder.Add(binary)]

amxmodx/CCmd.cpp

@@ -1,33 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
 #include "CCmd.h"
@@ -35,8 +13,10 @@
 // *****************************************************
 // class CmdMngr
 // *****************************************************
-CmdMngr::CmdMngr() { 
-	memset(sortedlists,0,sizeof(sortedlists));
+
+CmdMngr::CmdMngr()
+{ 
+	memset(sortedlists, 0, sizeof(sortedlists));
 	srvcmdlist = 0;
 	clcmdlist = 0;
 	prefixHead = 0;
@@ -49,21 +29,21 @@ CmdMngr::CmdMngr() {
 
 }
 
-CmdMngr::Command::Command( CPluginMngr::CPlugin* pplugin,const char* pcmd, 
-			const char* pinfo , int pflags , int pfunc, 
-			bool pviewable, CmdMngr* pparent ) : commandline(pcmd) , info(pinfo) {
-
+CmdMngr::Command::Command(CPluginMngr::CPlugin* pplugin, const char* pcmd, const char* pinfo, int pflags, 
+							int pfunc, bool pviewable, bool pinfo_ml, CmdMngr* pparent) : commandline(pcmd), info(pinfo)
+{
 	char szCmd[64], szArg[64];
-	*szCmd = 0; *szArg=0;
-	sscanf(pcmd,"%s %s",szCmd,szArg);
-	command.assign(szCmd);
-	argument.assign(szArg);
+	*szCmd = 0; *szArg = 0;
+	sscanf(pcmd, "%s %s", szCmd, szArg);
+	command = szCmd;
+	argument = szArg;
 	plugin = pplugin;
 	flags = pflags;
 	cmdtype = 0;
 	prefix = 0;
 	function = pfunc;
 	listable = pviewable;
+	info_ml = pinfo_ml;
 	parent = pparent;
 	id = --uniqueid;
 }
@@ -73,180 +53,188 @@ CmdMngr::Command::~Command()
 	++uniqueid;
 }
 
-CmdMngr::Command* CmdMngr::registerCommand( CPluginMngr::CPlugin* plugin ,   int func , char* cmd ,  char* info , int level , bool listable )
+CmdMngr::Command* CmdMngr::registerCommand(CPluginMngr::CPlugin* plugin, int func, const char* cmd, const char* info, int level, bool listable, bool info_ml)
 {
-  Command* b = new Command( plugin ,  cmd , info ,  level , func , listable,  this );
-  if ( b == 0 ) return 0;
-  setCmdLink( &sortedlists[0] , b );
-  return b;
+	Command* b = new Command(plugin, cmd, info, level, func, listable, info_ml, this);
+	if (b == 0) return 0;
+	setCmdLink(&sortedlists[0], b);
+	
+	return b;
 }
 
-CmdMngr::Command* CmdMngr::getCmd( long int id ,int type,  int access )
+CmdMngr::Command* CmdMngr::getCmd(long int id, int type, int access)
 {
-	//if ( id >= 1024 || id < 0 ) return (Command*)id;
-	if ( id < 0 ){
-		for (CmdMngr::iterator a = begin( type ); a ; ++a){
-			if ( (*a).id == id )
+	//if (id >= 1024 || id < 0) return (Command*)id;
+	if (id < 0)
+	{
+		for (CmdMngr::iterator a = begin(type); a ; ++a)
+		{
+			if ((*a).id == id)
 				return &(*a);
 		}
+		
 		return 0;
 	}
 
-	if ( (id < buf_cmdid) || (access != buf_cmdaccess) || (type != buf_cmdtype) )
+	if ((id < buf_cmdid) || (access != buf_cmdaccess) || (type != buf_cmdtype))
 	{
-		buf_cmdptr = begin( type );
+		buf_cmdptr = begin(type);
 		buf_cmdaccess = access;
 		buf_cmdtype = type;
 		buf_cmdid = id;
-	}
-	else
-	{
+	} else {
 		int a = id;
 		id -= buf_cmdid;
 		buf_cmdid = a;
 	}
 
-	while ( buf_cmdptr )
+	while (buf_cmdptr)
 	{
-		
-		if ( (*buf_cmdptr).gotAccess(  access ) && 
-			(*buf_cmdptr).getPlugin()->isExecutable( (*buf_cmdptr).getFunction()  )
-			&& (*buf_cmdptr).isViewable() )
+		if ((*buf_cmdptr).gotAccess(access) && (*buf_cmdptr).getPlugin()->isExecutable((*buf_cmdptr).getFunction()) && (*buf_cmdptr).isViewable())
 		{
-			
-			if ( id-- == 0 ) 
+			if (id-- == 0) 
 				return &(*buf_cmdptr);
-			
 		}
-		
 		++buf_cmdptr;
 	}
 
 	return 0;		
 }
 
-int CmdMngr::getCmdNum( int type, int access )
+int CmdMngr::getCmdNum(int type, int access)
 {
-	if ( (access == buf_access) && (type == buf_type) )
-		return buf_num; // once calculated don't have to be done again
 
 	buf_access = access;
 	buf_type = type;
 	buf_num = 0;
 
-	CmdMngr::iterator a = begin( type );
+	CmdMngr::iterator a = begin(type);
 
-	while ( a )
+	while (a)
 	{
-			
-		if ( (*a).gotAccess(  access ) && 
-			(*a).getPlugin()->isExecutable( (*a).getFunction()  ) 
-			&& (*a).isViewable() )
-				++buf_num;
+		if ((*a).gotAccess(access) && (*a).getPlugin()->isExecutable((*a).getFunction()) && (*a).isViewable())
+			++buf_num;
 		++a;
 	}
 
 	return buf_num;
 }
 
-void CmdMngr::setCmdLink( CmdLink** a , Command* c, bool sorted  )
+void CmdMngr::setCmdLink(CmdLink** a, Command* c, bool sorted)
 {
-	CmdLink* np = new CmdLink( c );
+	CmdLink* np = new CmdLink(c);
 
-	if ( np == 0 ) return;
+	if (np == 0) return;
 
-	if ( sorted )
+	if (sorted)
 	{
-		while( *a ) 
+		while (*a)
 		{
-			int i = strcmp(c->getCommand(),(*a)->cmd->getCommand() );
+			int i = strcmp(c->getCommand(), (*a)->cmd->getCommand());
 
-			if ( (i<0) || (i==0) && ( strcmp( c->getArgument() , (*a)->cmd->getArgument() ) < 0 ) )
+			if ((i < 0) || ((i == 0) && (strcmp(c->getArgument(), (*a)->cmd->getArgument()) < 0)))
 				break;
-
+			
 			a = &(*a)->next;
 		}
 
 		np->next = *a;
 		*a = np;
-	}
-	else 
-	{
-		while ( *a ) a = &(*a)->next;
+	} else {
+		while (*a) a = &(*a)->next;
 		*a = np;
 	}
-
-	
 }
 
-void CmdMngr::clearCmdLink( CmdLink** phead, bool pclear )
+void CmdMngr::clearCmdLink(CmdLink** phead, bool pclear)
 {
-	while( *phead ){
+	while (*phead)
+	{
 		CmdLink* pp = (*phead)->next;
-		if ( pclear ) delete (*phead)->cmd;
+		
+		if (pclear) delete (*phead)->cmd;
 		delete *phead;
 		*phead = pp;
 	}
 }
 
-void CmdMngr::Command::setCmdType( int a ) 
+void CmdMngr::Command::setCmdType(int a)
 {
-	switch(a){
-	case CMD_ConsoleCommand: cmdtype |= 3; break;
-	case CMD_ClientCommand: cmdtype |= 1; break;
-	case CMD_ServerCommand: cmdtype |= 2; break;
+	switch (a)
+	{
+		case CMD_ConsoleCommand: cmdtype |= 3; break;
+		case CMD_ClientCommand: cmdtype |= 1; break;
+		case CMD_ServerCommand: cmdtype |= 2; break;
 	}
-	if ( cmdtype & 1 ) { // ClientCommand
-		parent->setCmdLink( &parent->sortedlists[1] , this );
-		if ( !parent->registerCmdPrefix(  this ) )
-			parent->setCmdLink( &parent->clcmdlist , this , false );
+
+	if (cmdtype & 1)	// ClientCommand
+	{
+		parent->setCmdLink(&parent->sortedlists[1], this);
+		
+		if (!parent->registerCmdPrefix(this))
+			parent->setCmdLink(&parent->clcmdlist, this, false);
 	}
-	if ( cmdtype & 2 ) { // ServerCommand
-		parent->setCmdLink( &parent->sortedlists[2] , this );
-		parent->setCmdLink( &parent->srvcmdlist , this , false );
+	
+	if (cmdtype & 2)	// ServerCommand
+	{
+		parent->setCmdLink(&parent->sortedlists[2], this);
+		parent->setCmdLink(&parent->srvcmdlist, this, false);
 	}
 }
 
-const char* CmdMngr::Command::getCmdType() const {
-	switch( cmdtype ){
-	case 1:	return"client";
-	case 2:	return "server";
-	case 3:	return "console";
+const char* CmdMngr::Command::getCmdType() const
+{
+	switch (cmdtype)
+	{
+		case 1:	return "client";
+		case 2:	return "server";
+		case 3:	return "console";
 	}
+	
 	return "unknown";
 }
 
-bool CmdMngr::registerCmdPrefix( Command* cc )
+bool CmdMngr::registerCmdPrefix(Command* cc)
 {
-	CmdPrefix** b = findPrefix( cc->getCommand() );
-	if (*b){
-		setCmdLink( &(*b)->list , cc , false );
-		cc->prefix = (*b)->name.size();
+	CmdPrefix** b = findPrefix(cc->getCommand());
+
+	if (*b)
+	{
+		setCmdLink(&(*b)->list, cc, false);
+		cc->prefix = (*b)->name.length();
 		return true;
 	}
+	
 	return false;
 }
 
-void CmdMngr::registerPrefix( const char* nn )
+void CmdMngr::registerPrefix(const char* nn)
 {
-	if ( *nn == 0 ) return;
-	CmdPrefix** b = findPrefix( nn );
+	if (*nn == 0) return;
+	CmdPrefix** b = findPrefix(nn);
+	
 	if (*b) return;
-	*b = new CmdPrefix( nn , this );
+	*b = new CmdPrefix(nn, this);
 }
 
-CmdMngr::CmdPrefix** CmdMngr::findPrefix(  const char* nn ){
+CmdMngr::CmdPrefix** CmdMngr::findPrefix(const char* nn)
+{
 	CmdPrefix** aa = &prefixHead;
-	while(*aa){
-		if ( !strncmp( (*aa)->name.c_str(), nn, (*aa)->name.size() ) ) 
+	
+	while (*aa)
+	{
+		if (!strncmp((*aa)->name.chars(), nn, (*aa)->name.length()))
 			break;
-		aa=&(*aa)->next;
+		aa = &(*aa)->next;
 	}
+	
 	return aa;
 }
 
-void CmdMngr::clearPrefix(){
-	while(prefixHead){
+void CmdMngr::clearPrefix()
+{
+	while (prefixHead)
+	{
 		CmdPrefix* a = prefixHead->next;
 		delete prefixHead;
 		prefixHead = a;
@@ -264,7 +252,8 @@ void CmdMngr::clear()
 	clearBufforedInfo();
 }
 
-void CmdMngr::clearBufforedInfo() { 
+void CmdMngr::clearBufforedInfo()
+{
 	buf_type = -1; 
 	buf_access = 0; 
 	buf_id = -1; 
@@ -273,4 +262,4 @@ void CmdMngr::clearBufforedInfo() {
 	buf_cmdaccess = 0;
 }
 
-int CmdMngr::Command::uniqueid = 0;
+int CmdMngr::Command::uniqueid = 0;

amxmodx/CCmd.h

@@ -1,33 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef COMMANDS_H
 #define COMMANDS_H
@@ -36,7 +14,8 @@
 // class CmdMngr
 // *****************************************************
 
-enum {
+enum
+{
 	CMD_ConsoleCommand,
 	CMD_ClientCommand,
 	CMD_ServerCommand
@@ -48,14 +27,18 @@ public:
 	class Command;
 	friend class Command;
 	
-	class Command {
+	class Command
+	{
 		friend class CmdMngr;
+		
 		CPluginMngr::CPlugin* plugin;
 		CmdMngr* parent;
-		String command;
-		String argument;
-		String commandline;
-		String info;
+		ke::AString command;
+		ke::AString argument;
+		ke::AString commandline;
+		ke::AString info;
+		
+		bool info_ml;
 		bool listable;
 		int function;
 		int flags;
@@ -63,33 +46,34 @@ public:
 		int cmdtype;
 		int prefix;
 		static int uniqueid;
-		Command( CPluginMngr::CPlugin* pplugin,const char* pcmd, const char* pinfo , int pflags , int pfunc, bool pviewable, CmdMngr* pparent );
+		
+		Command(CPluginMngr::CPlugin* pplugin, const char* pcmd, const char* pinfo, int pflags, int pfunc, bool pviewable, bool pinfo_ml, CmdMngr* pparent);
 		~Command();
 	public:
-
-		inline const char* getCommand() { return command.c_str(); }
-		inline const char* getArgument() { return argument.c_str(); }
-		inline const char* getCmdInfo() { return info.c_str(); }
-		inline const char* getCmdLine() { return commandline.c_str(); }
-		inline bool matchCommandLine(const char* cmd, const char* arg) 	{ return (!stricmp(command.c_str()+prefix, cmd+prefix ) && (argument.empty() || !stricmp(argument.c_str() , arg ))); }
-		inline bool matchCommand(const char* cmd) {	return (!strcmp(command.c_str(), cmd ));	}
+		inline const char* getCommand() { return command.chars(); }
+		inline const char* getArgument() { return argument.chars(); }
+		inline const char* getCmdInfo() { return info.chars(); }
+		inline const char* getCmdLine() { return commandline.chars(); }
+		inline bool matchCommandLine(const char* cmd, const char* arg) 	{return (!stricmp(command.chars() + prefix, cmd + prefix) && (!argument.length() || !stricmp(argument.chars(), arg)));}
+		inline bool matchCommand(const char* cmd) {	return (!stricmp(command.chars(), cmd)); }
 		inline int getFunction() const { return function; }
-		inline bool gotAccess(int f) const { return (!flags||((flags & f)==flags)); }
+		inline bool gotAccess(int f) const { return (!flags || ((flags & f) != 0)); }
 		inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
 		inline bool isViewable() const { return listable; }
+		inline bool isInfoML() const { return info_ml; }
 		inline int getFlags() const { return flags; }
 		inline long int getId() const { return (long int)id; }
+		
 		const char* getCmdType() const;		
-		void setCmdType( int a );
-
+		void setCmdType(int a);
 	};
 
 private:
-
 	struct CmdPrefix;
 	friend struct CmdPrefix;
 
-	struct CmdLink {
+	struct CmdLink
+	{
 		Command* cmd;
 		CmdLink* next;
 		CmdLink(Command* c): cmd(c), next(0) {}
@@ -99,36 +83,40 @@ private:
 	CmdLink* srvcmdlist;
 	CmdLink* clcmdlist;
 
-	struct CmdPrefix {
-		String name;
+	struct CmdPrefix
+	{
+		ke::AString name;
 		CmdMngr* parent;
 		CmdLink* list;
 		CmdPrefix* next;
-		CmdPrefix( const char* nn , CmdMngr* pp) : 	name(nn),parent(pp),list(0),next(0){}
-		~CmdPrefix(){  parent->clearCmdLink(&list);  }
+		CmdPrefix(const char* nn, CmdMngr* pp): name(nn), parent(pp), list(0), next(0) {}
+		~CmdPrefix() { parent->clearCmdLink(&list); }
 	} *prefixHead;
 
-	bool registerCmdPrefix( Command* cc );
-	CmdPrefix** findPrefix(  const char* nn );
+	bool registerCmdPrefix(Command* cc);
+	CmdPrefix** findPrefix(const char* nn);
 	void clearPrefix();
 
-	void setCmdLink( CmdLink** a , Command* c, bool sorted = true );
-	void clearCmdLink( CmdLink** phead, bool pclear = false  );
+	void setCmdLink(CmdLink** a, Command* c, bool sorted = true);
+	void clearCmdLink(CmdLink** phead, bool pclear = false);
 
 public:
 	CmdMngr();
-	~CmdMngr() {clear();}
+	~CmdMngr() { clear(); }
 
 	// Interface
 
-	void registerPrefix( const char* nn );
-	Command* registerCommand( CPluginMngr::CPlugin* plugin , int func , char* cmd ,  char* info , int level , bool listable );
-	Command* getCmd( long int id ,int type,  int access);
-	int getCmdNum( int type, int access );
+	void registerPrefix(const char* nn);
+	
+	Command* registerCommand(CPluginMngr::CPlugin* plugin, int func, const char* cmd, const char* info, int level, bool listable, bool info_ml);
+	Command* getCmd(long int id, int type, int access);
+	int getCmdNum(int type, int access);
+	
 	void clearBufforedInfo();
 	void clear();
 
-	class iterator {
+	class iterator
+	{
 		CmdLink *a;
 	public:
 		iterator(CmdLink*aa = 0) : a(aa) {}
@@ -138,28 +126,30 @@ public:
 		operator bool () const { return a ? true : false; }
 		Command& operator*() { return *a->cmd; }
 	};
-	inline iterator clcmdprefixbegin(const char* nn){
+
+	inline iterator clcmdprefixbegin(const char* nn)
+	{
 		CmdPrefix* a = *findPrefix(nn);
-		return iterator( a ? a->list : 0 );
+		return iterator(a ? a->list : 0);
 	}
-	inline iterator clcmdbegin() const {return iterator(clcmdlist);}
-	inline iterator srvcmdbegin() const {return iterator(srvcmdlist);}
-	inline iterator begin( int type ) const { return iterator(sortedlists[type]); }
+
+	inline iterator clcmdbegin() const { return iterator(clcmdlist); }
+	inline iterator srvcmdbegin() const { return iterator(srvcmdlist); }
+	inline iterator begin(int type) const { return iterator(sortedlists[type]); }
 	inline iterator end() const { return iterator(0); }
 
 private:
-
 	int buf_cmdid;
 	int buf_cmdtype;
 	int buf_cmdaccess;
+	
 	iterator buf_cmdptr;
 
 	int buf_id;
 	int buf_type;
 	int buf_access;
 	int buf_num;
-
 };
 
-#endif
+#endif //COMMANDS_H
 

amxmodx/CDataPack.cpp

@@ -0,0 +1,340 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ */
+
+#include "CDataPack.h"
+
+#define DATAPACK_INITIAL_SIZE 64
+
+CDataPack::CDataPack()
+{
+	m_pBase = (char *)malloc(DATAPACK_INITIAL_SIZE);
+	m_capacity = DATAPACK_INITIAL_SIZE;
+	Initialize();
+}
+
+CDataPack::~CDataPack()
+{
+	free(m_pBase);
+}
+
+void CDataPack::Initialize()
+{
+	m_curptr = m_pBase;
+	m_size = 0;
+}
+
+void CDataPack::CheckSize(size_t typesize)
+{
+	if (m_curptr - m_pBase + typesize <= m_capacity)
+	{
+		return;
+	}
+
+	size_t pos = m_curptr - m_pBase;
+	do
+	{
+		m_capacity *= 2;
+	} while (pos + typesize > m_capacity);
+
+	m_pBase = (char *)realloc(m_pBase, m_capacity);
+	m_curptr = m_pBase + pos;
+}
+
+void CDataPack::ResetSize()
+{
+	m_size = 0;
+}
+
+size_t CDataPack::CreateMemory(size_t size, void **addr)
+{
+	CheckSize(sizeof(char) + sizeof(size_t) + size);
+	size_t pos = m_curptr - m_pBase;
+
+	*(char *)m_curptr = Raw;
+	m_curptr += sizeof(char);
+
+	*(size_t *)m_curptr = size;
+	m_curptr += sizeof(size_t);
+
+	if (addr)
+	{
+		*addr = m_curptr;
+	}
+
+	m_curptr += size;
+	m_size += sizeof(char) + sizeof(size_t) + size;
+
+	return pos;
+}
+
+void CDataPack::PackCell(cell cells)
+{
+	CheckSize(sizeof(char) + sizeof(size_t) + sizeof(cell));
+
+	*(char *)m_curptr = DataPackType::Cell;
+	m_curptr += sizeof(char);
+
+	*(size_t *)m_curptr = sizeof(cell);
+	m_curptr += sizeof(size_t);
+
+	*(cell *)m_curptr = cells;
+	m_curptr += sizeof(cell);
+
+	m_size += sizeof(char) + sizeof(size_t) + sizeof(cell);
+}
+
+void CDataPack::PackFloat(float val)
+{
+	CheckSize(sizeof(char) + sizeof(size_t) + sizeof(float));
+
+	*(char *)m_curptr = DataPackType::Float;
+	m_curptr += sizeof(char);
+
+	*(size_t *)m_curptr = sizeof(float);
+	m_curptr += sizeof(size_t);
+
+	*(float *)m_curptr = val;
+	m_curptr += sizeof(float);
+
+	m_size += sizeof(char) + sizeof(size_t) + sizeof(float);
+}
+
+void CDataPack::PackString(const char *string)
+{
+	size_t len = strlen(string);
+	size_t maxsize = sizeof(char) + sizeof(size_t) + len + 1;
+	CheckSize(maxsize);
+
+	*(char *)m_curptr = DataPackType::String;
+	m_curptr += sizeof(char);
+
+	// Pack the string length first for buffer overrun checking.
+	*(size_t *)m_curptr = len;
+	m_curptr += sizeof(size_t);
+
+	// Now pack the string.
+	memcpy(m_curptr, string, len);
+	m_curptr[len] = '\0';
+	m_curptr += len + 1;
+
+	m_size += maxsize;
+}
+
+void CDataPack::Reset() const
+{
+	m_curptr = m_pBase;
+}
+
+size_t CDataPack::GetPosition() const
+{
+	return static_cast<size_t>(m_curptr - m_pBase);
+}
+
+bool CDataPack::SetPosition(size_t pos) const
+{
+	if (pos > m_size-1)
+	{
+		return false;
+	}
+	m_curptr = m_pBase + pos;
+
+	return true;
+}
+
+bool CDataPack::CanReadCell() const
+{
+	if (!IsReadable(sizeof(char) + sizeof(size_t) + sizeof(cell)))
+	{
+		return false;
+	}
+	if (*reinterpret_cast<char *>(m_curptr) != DataPackType::Cell)
+	{
+		return false;
+	}
+	if (*reinterpret_cast<size_t *>(m_curptr + sizeof(char)) != sizeof(cell))
+	{
+		return false;
+	}
+
+	return true;
+}
+
+cell CDataPack::ReadCell() const
+{
+	if (!CanReadCell())
+	{
+		return 0;
+	}
+
+	m_curptr += sizeof(char);
+	m_curptr += sizeof(size_t);
+
+	cell val = *reinterpret_cast<cell *>(m_curptr);
+	m_curptr += sizeof(cell);
+	return val;
+}
+
+bool CDataPack::CanReadFloat() const
+{
+	if (!IsReadable(sizeof(char) + sizeof(size_t) + sizeof(float)))
+	{
+		return false;
+	}
+	if (*reinterpret_cast<char *>(m_curptr) != DataPackType::Float)
+	{
+		return false;
+	}
+	if (*reinterpret_cast<size_t *>(m_curptr + sizeof(char)) != sizeof(float))
+	{
+		return false;
+	}
+
+	return true;
+}
+
+float CDataPack::ReadFloat() const
+{
+	if (!CanReadFloat())
+	{
+		return 0;
+	}
+
+	m_curptr += sizeof(char);
+	m_curptr += sizeof(size_t);
+
+	float val = *reinterpret_cast<float *>(m_curptr);
+	m_curptr += sizeof(float);
+	return val;
+}
+
+bool CDataPack::IsReadable(size_t bytes) const
+{
+	return (bytes + (m_curptr - m_pBase) > m_size) ? false : true;
+}
+
+bool CDataPack::CanReadString(size_t *len) const
+{
+	if (!IsReadable(sizeof(char) + sizeof(size_t)))
+	{
+		return false;
+	}
+	if (*reinterpret_cast<char *>(m_curptr) != DataPackType::String)
+	{
+		return false;
+	}
+
+	size_t real_len = *(size_t *)(m_curptr + sizeof(char));
+	char *str = (char *)(m_curptr + sizeof(char) + sizeof(size_t));
+
+	if ((strlen(str) != real_len) || !(IsReadable(sizeof(char) + sizeof(size_t) + real_len + 1)))
+	{
+		return false;
+	}
+
+	if (len)
+	{
+		*len = real_len;
+	}
+
+	return true;
+}
+
+const char *CDataPack::ReadString(size_t *len) const
+{
+	size_t real_len;
+	if (!CanReadString(&real_len))
+	{
+		return NULL;
+	}
+
+	m_curptr += sizeof(char);
+	m_curptr += sizeof(size_t);
+
+	char *str = (char *)m_curptr;
+	m_curptr += real_len + 1;
+
+	if (len)
+	{
+		*len = real_len;
+	}
+
+	return str;
+}
+
+void *CDataPack::GetMemory() const
+{
+	return m_curptr;
+}
+
+bool CDataPack::CanReadMemory(size_t *size) const
+{
+	if (!IsReadable(sizeof(char) + sizeof(size_t)))
+	{
+		return false;
+	}
+	if (*reinterpret_cast<char *>(m_curptr) != DataPackType::Raw)
+	{
+		return false;
+	}
+
+	size_t bytecount = *(size_t *)(m_curptr + sizeof(char));
+	if (!IsReadable(sizeof(char) + sizeof(size_t) + bytecount))
+	{
+		return false;
+	}
+
+	if (size)
+	{
+		*size = bytecount;
+	}
+
+	return true;
+}
+
+void *CDataPack::ReadMemory(size_t *size) const
+{
+	size_t bytecount;
+	if (!CanReadMemory(&bytecount))
+	{
+		return NULL;
+	}
+
+	m_curptr += sizeof(char);
+	m_curptr += sizeof(size_t);
+
+	void *ptr = m_curptr;
+	m_curptr += bytecount;
+
+	if (size)
+	{
+		*size = bytecount;
+	}
+
+	return ptr;
+}

amxmodx/CDataPack.h

@@ -0,0 +1,181 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ */
+
+#ifndef _INCLUDE_SOURCEMOD_CDATAPACK_H_
+#define _INCLUDE_SOURCEMOD_CDATAPACK_H_
+
+#include "amxmodx.h"
+#include "natives_handles.h"
+
+/**
+ * @brief Contains functions for packing data abstractly to/from plugins.
+ */
+class CDataPack
+{
+public:
+	CDataPack();
+	~CDataPack();
+
+public:
+	/**
+	 * @brief Resets the position in the data stream to the beginning.
+	 */
+	void Reset() const;
+
+	/**
+	 * @brief Retrieves the current stream position.
+	 *
+	 * @return			Index into the stream.
+	 */
+	size_t GetPosition() const;
+
+	/**
+	 * @brief Sets the current stream position.
+	 *
+	 * @param pos		Index to set the stream at.
+	 * @return			True if succeeded, false if out of bounds.
+	 */
+	bool SetPosition(size_t pos) const;
+
+	/**
+	 * @brief Reads one cell from the data stream.
+	 *
+	 * @return			A cell read from the current position.
+	 */
+	cell ReadCell() const;
+
+	/**
+	 * @brief Reads one float from the data stream.
+	 *
+	 * @return			A float read from the current position.
+	 */
+	float ReadFloat() const;
+
+	/**
+	 * @brief Returns whether or not a specified number of bytes from the current stream
+	 *  position to the end can be read.
+	 *
+	 * @param bytes		Number of bytes to simulate reading.
+	 * @return			True if can be read, false otherwise.
+	 */
+	bool IsReadable(size_t bytes) const;
+
+	/**
+	 * @brief Reads a string from the data stream.
+	 *
+	 * @param len		Optional pointer to store the string length.
+	 * @return			Pointer to the string, or NULL if out of bounds.
+	 */
+	const char *ReadString(size_t *len) const;
+
+	/**
+	 * @brief Reads the current position as a generic address.
+	 *
+	 * @return			Pointer to the memory.
+	 */
+	void *GetMemory() const;
+
+	/**
+	 * @brief Reads the current position as a generic data type.
+	 *
+	 * @param size		Optional pointer to store the size of the data type.
+	 * @return			Pointer to the data, or NULL if out of bounds.
+	 */
+	void *ReadMemory(size_t *size) const;
+
+	bool CanReadCell() const;
+	bool CanReadFloat() const;
+	bool CanReadString(size_t *len) const;
+	bool CanReadMemory(size_t *size) const;
+
+public:
+	/**
+	 * @brief Resets the used size of the stream back to zero.
+	 */
+	void ResetSize();
+
+	/**
+	 * @brief Packs one cell into the data stream.
+	 *
+	 * @param cell		Cell value to write.
+	 */
+	void PackCell(cell cells);
+
+	/**
+	 * @brief Packs one float into the data stream.
+	 *
+	 * @param val		Float value to write.
+	 */
+	void PackFloat(float val);
+
+	/**
+	 * @brief Packs one string into the data stream.
+	 * The length is recorded as well for buffer overrun protection.
+	 *
+	 * @param string	String to write.
+	 */
+	void PackString(const char *string);
+
+	/**
+	 * @brief Creates a generic block of memory in the stream.
+	 *
+	 * Note that the pointer it returns can be invalidated on further
+	 * writing, since the stream size may grow.  You may need to double back
+	 * and fetch the pointer again.
+	 *
+	 * @param size		Size of the memory to create in the stream.
+	 * @param addr		Optional pointer to store the relocated memory address.
+	 * @return			Current position of the stream beforehand.
+	 */
+	size_t CreateMemory(size_t size, void **addr);
+
+public:
+	void Initialize();
+
+private:
+	void CheckSize(size_t sizetype);
+
+private:
+	char *m_pBase;
+	mutable char *m_curptr;
+	size_t m_capacity;
+	size_t m_size;
+
+	enum DataPackType {
+		Raw,
+		Cell,
+		Float,
+		String,
+	};
+};
+
+extern NativeHandle<CDataPack> DataPackHandles;
+extern AMX_NATIVE_INFO g_DatapackNatives[];
+
+#endif //_INCLUDE_SOURCEMOD_CDATAPACK_H_

amxmodx/CEvent.cpp

@@ -1,33 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
 #include "CEvent.h"
@@ -36,7 +14,9 @@
 // class ClEvent
 // *****************************************************
 
-EventsMngr::ClEvent::ClEvent(CPluginMngr::CPlugin* plugin,  int func, int flags)
+NativeHandle<EventHook> EventHandles;
+
+EventsMngr::ClEvent::ClEvent(CPluginMngr::CPlugin* plugin, int func, int flags)
 {
 	m_Plugin = plugin;
 	m_Func = func;
@@ -45,17 +25,31 @@ EventsMngr::ClEvent::ClEvent(CPluginMngr::CPlugin* plugin,  int func, int flags)
 	m_FlagAlive = true;
 	m_FlagDead = true;
 
-	m_FlagWorld = (flags & 1) ? true : false;						// flag a
-	m_FlagPlayer = (flags & 2) ? true : false;						// flag b
-	m_FlagOnce = (flags & 4) ? true : false;						// flag c
+	m_FlagWorld = (flags & 1) ? true : false;			// flag a
+	m_FlagClient = (flags & 2) ? true : false;			// flag b
+	m_FlagOnce = (flags & 4) ? true : false;			// flag c
+	
 	if (flags & 24)
 	{
-		m_FlagAlive = (flags & 16) ? true : false;				// flag e
-		m_FlagDead = (flags & 8) ? true : false;				// flag d
+		m_FlagAlive = (flags & 16) ? true : false;		// flag e
+		m_FlagDead = (flags & 8) ? true : false;		// flag d
+	}
+
+	if (m_FlagClient)
+	{
+		m_FlagPlayer = true;
+		m_FlagBot = true;
+
+		if (flags & 96)
+		{
+			m_FlagPlayer = (flags & 32) ? true : false;	 // flag f
+			m_FlagBot = (flags & 64) ? true : false;	 // flag g
+		}
 	}
 
 	m_Stamp = 0.0f;
 	m_Done = false;
+	m_State = FSTATE_ACTIVE;
 
 	m_Conditions = NULL;
 }
@@ -64,12 +58,14 @@ EventsMngr::ClEvent::~ClEvent()
 {
 	cond_t *tmp1 = m_Conditions;
 	cond_t *tmp2 = NULL;
+	
 	while (tmp1)
 	{
 		tmp2 = tmp1->next;
 		delete tmp1;
 		tmp1 = tmp2;
 	}
+	
 	m_Conditions = NULL;
 }
 
@@ -82,14 +78,17 @@ void EventsMngr::NextParam()
 
 	MsgDataEntry *tmp = NULL;
 	int tmpSize = 0;
+	
 	if (m_ParseVault)
 	{
 		// copy to tmp
 		tmp = new MsgDataEntry[m_ParseVaultSize];
+		
 		if (!tmp)
 		{
 			return;		// :TODO: Error report !!
 		}
+		
 		memcpy(tmp, m_ParseVault, m_ParseVaultSize * sizeof(MsgDataEntry));
 		tmpSize = m_ParseVaultSize;
 		delete [] m_ParseVault;
@@ -102,6 +101,7 @@ void EventsMngr::NextParam()
 		m_ParseVaultSize = INITIAL_PARSEVAULT_SIZE;
 
 	m_ParseVault = new MsgDataEntry[m_ParseVaultSize];
+	
 	if (tmp)
 	{
 		memcpy(m_ParseVault, tmp, tmpSize * sizeof(MsgDataEntry));
@@ -119,7 +119,11 @@ EventsMngr::EventsMngr()
 {
 	m_ParseVault = NULL;
 	m_ParseVaultSize = 0;
-	m_CurrentMsgType = -1;
+	m_ParseMsgType = -1;
+	m_ReadVault = NULL;
+	m_ReadVaultSize = 0;
+	m_ReadPos = -1;
+	m_ReadMsgType = -1;
 	clearEvents();
 }
 
@@ -128,7 +132,6 @@ EventsMngr::~EventsMngr()
 	clearEvents();
 }
 
-
 CPluginMngr::CPlugin * EventsMngr::ClEvent::getPlugin()
 {
 	return m_Plugin;
@@ -169,8 +172,8 @@ void EventsMngr::ClEvent::registerFilter(char *filter)
 	tmpCond->paramId = atoi(filter);
 
 	// rest of line
-	tmpCond->sValue.assign(value);
-	tmpCond->fValue = atof(value);
+	tmpCond->sValue = value;
+	tmpCond->fValue = static_cast<float>(atof(value));
 	tmpCond->iValue = atoi(value);
 	
 	tmpCond->next = NULL;
@@ -178,28 +181,41 @@ void EventsMngr::ClEvent::registerFilter(char *filter)
 	if (m_Conditions)
 	{
 		cond_t *tmp = m_Conditions;
+		
 		while (tmp->next)
 			tmp = tmp->next;
+		
 		tmp->next = tmpCond;
-
 	}
 	else
 		m_Conditions = tmpCond;
 }
 
-EventsMngr::ClEvent* EventsMngr::registerEvent(CPluginMngr::CPlugin* plugin, int func, int flags, int msgid)
+void EventsMngr::ClEvent::setForwardState(ForwardState state)
+{
+	m_State = state;
+}
+
+
+int EventsMngr::registerEvent(CPluginMngr::CPlugin* plugin, int func, int flags, int msgid)
 {
-	// validate parameter
 	if (msgid < 0 || msgid >= MAX_AMX_REG_MSG)
-		return NULL;
+	{
+		return 0;
+	}
 
-	ClEvent *event = new ClEvent(plugin, func, flags);
-	if (!event)
-		return NULL;
+	auto event = ke::AutoPtr<ClEvent>(new ClEvent(plugin, func, flags));
 
-	m_Events[msgid].put(event);
+	int handle = EventHandles.create(event.get());
+	
+	if (!handle)
+	{
+		return 0;
+	}
 
-	return event;
+	m_Events[msgid].append(ke::Move(event));
+
+	return handle;
 }
 
 void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int index)
@@ -207,46 +223,46 @@ void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int in
 	if (msg_type < 0 || msg_type > MAX_AMX_REG_MSG)
 		return;
 
-	m_CurrentMsgType = msg_type;
-
 	m_ParseNotDone = false;
-	m_Timer = timer;
 
 	// don't parse if nothing to do
-	if (!m_Events[msg_type].size())
+	if (!m_Events[msg_type].length())
 		return;
 
-	for(ClEventVecIter iter = m_Events[msg_type].begin(); iter; ++iter)
+	m_ParseMsgType = msg_type;
+	m_Timer = timer;
+
+	for (auto &event : m_Events[msg_type])
 	{
-		if ((*iter).m_Done)
+		if (event->m_Done)
 			continue;
 
-
-		if (!(*iter).m_Plugin->isExecutable((*iter).m_Func))
+		if (!event->m_Plugin->isExecutable(event->m_Func))
 		{
-			(*iter).m_Done = true;
+			event->m_Done = true;
 			continue;
 		}
 
 		if (pPlayer)
 		{
-			if (!(*iter).m_FlagPlayer || (pPlayer->IsAlive() ? !(*iter).m_FlagAlive : !(*iter).m_FlagDead ) )
+			if (!event->m_FlagClient || (pPlayer->IsBot() ? !event->m_FlagBot : !event->m_FlagPlayer) || (pPlayer->IsAlive() ? !event->m_FlagAlive : !event->m_FlagDead))
 			{
-				(*iter).m_Done = true;
+				event->m_Done = true;
 				continue;
 			}
 		}
-		else if (!(*iter).m_FlagWorld)
+		else if (!event->m_FlagWorld)
 		{
-			(*iter).m_Done = true;
+			event->m_Done = true;
 			continue;
 		}
 
-		if ((*iter).m_FlagOnce && (*iter).m_Stamp == (float)(*timer))
+		if (event->m_FlagOnce && event->m_Stamp == *timer)
 		{
-			(*iter).m_Done = true;
+			event->m_Done = true;
 			continue;
 		}
+		
 		m_ParseNotDone = true;
 	}
 
@@ -257,6 +273,7 @@ void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int in
 		m_ParseVault[0].type = MSG_INTEGER;
 		m_ParseVault[0].iValue = index;
 	}
+	
 	m_ParseFun = &m_Events[msg_type];
 }
 
@@ -266,7 +283,6 @@ void EventsMngr::parseValue(int iValue)
 	if (!m_ParseNotDone || !m_ParseFun)
 		return;
 
-
 	// grow if needed
 	++m_ParsePos;
 	NextParam();
@@ -276,33 +292,35 @@ void EventsMngr::parseValue(int iValue)
 
 	// loop through the registered funcs, and decide whether they have to be called or not
 	// if they shouldnt, their m_Done is set to true
-	for (ClEventVecIter iter = m_ParseFun->begin(); iter; ++iter)
+	for (auto &event : *m_ParseFun)
 	{
-		if ((*iter).m_Done)
+		if (event->m_Done)
 			continue;		// already skipped; don't bother with parsing
 
 		// loop through conditions
 		bool execute = false;
 		bool anyConditions = false;
-		for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next)
+		
+		for (auto condIter = event->m_Conditions; condIter; condIter = condIter->next)
 		{
 			if (condIter->paramId == m_ParsePos)
 			{
 				anyConditions = true;
-				switch(condIter->type)
+				switch (condIter->type)
 				{
-				case '=': if (condIter->iValue == iValue) execute=true; break;
-				case '!': if (condIter->iValue != iValue) execute=true; break;
-				case '&': if (iValue & condIter->iValue) execute=true; break;
-				case '<': if (iValue < condIter->iValue) execute=true; break;
-				case '>': if (iValue > condIter->iValue) execute=true; break;
+					case '=': if (condIter->iValue == iValue) execute = true; break;
+					case '!': if (condIter->iValue != iValue) execute = true; break;
+					case '&': if (iValue & condIter->iValue) execute = true; break;
+					case '<': if (iValue < condIter->iValue) execute = true; break;
+					case '>': if (iValue > condIter->iValue) execute = true; break;
 				}
 				if (execute)
 					break;
 			}
 		}
+		
 		if (anyConditions && !execute)
-			(*iter).m_Done = true;		// don't execute
+			event->m_Done = true;		// don't execute
 	}
 }
 
@@ -312,7 +330,6 @@ void EventsMngr::parseValue(float fValue)
 	if (!m_ParseNotDone || !m_ParseFun)
 		return;
 
-
 	// grow if needed
 	++m_ParsePos;
 	NextParam();
@@ -322,32 +339,35 @@ void EventsMngr::parseValue(float fValue)
 
 	// loop through the registered funcs, and decide whether they have to be called or not
 	// if they shouldnt, their m_Done is set to true
-	for (ClEventVecIter iter = m_ParseFun->begin(); iter; ++iter)
+	for (auto &event : *m_ParseFun)
 	{
-		if ((*iter).m_Done)
+		if (event->m_Done)
 			continue;		// already skipped; don't bother with parsing
 
 		// loop through conditions
 		bool execute = false;
 		bool anyConditions = false;
-		for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next)
+		
+		for (auto condIter = event->m_Conditions; condIter; condIter = condIter->next)
 		{
 			if (condIter->paramId == m_ParsePos)
 			{
 				anyConditions = true;
-				switch(condIter->type)
+				switch (condIter->type)
 				{
-				case '=': if (condIter->fValue == fValue) execute=true; break;
-				case '!': if (condIter->fValue != fValue) execute=true; break;
-				case '<': if (fValue < condIter->fValue) execute=true; break;
-				case '>': if (fValue > condIter->fValue) execute=true; break;
+					case '=': if (condIter->fValue == fValue) execute = true; break;
+					case '!': if (condIter->fValue != fValue) execute = true; break;
+					case '<': if (fValue < condIter->fValue) execute = true; break;
+					case '>': if (fValue > condIter->fValue) execute = true; break;
 				}
+				
 				if (execute)
 					break;
 			}
 		}
+		
 		if (anyConditions && !execute)
-			(*iter).m_Done = true;		// don't execute
+			event->m_Done = true;		// don't execute
 	}
 }
 
@@ -366,129 +386,161 @@ void EventsMngr::parseValue(const char *sz)
 
 	// loop through the registered funcs, and decide whether they have to be called or not
 	// if they shouldnt, their m_Done is set to true
-	for (ClEventVecIter iter = m_ParseFun->begin(); iter; ++iter)
+	for (auto &event : *m_ParseFun)
 	{
-		if ((*iter).m_Done)
+		if (event->m_Done)
 			continue;		// already skipped; don't bother with parsing
 
 		// loop through conditions
 		bool execute = false;
 		bool anyConditions = false;
-		for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next)
+		
+		for (auto condIter = event->m_Conditions; condIter; condIter = condIter->next)
 		{
 			if (condIter->paramId == m_ParsePos)
 			{
 				anyConditions = true;
-				switch(condIter->type)
+				switch (condIter->type)
 				{
-				case '=': if (!strcmp(sz, condIter->sValue.c_str())) execute=true; break;
-				case '!': if (strcmp(sz, condIter->sValue.c_str())) execute=true; break;
-				case '&': if (strstr(sz, condIter->sValue.c_str())) execute=true; break;
+					case '=': if (!strcmp(sz, condIter->sValue.chars())) execute = true; break;
+					case '!': if (strcmp(sz, condIter->sValue.chars())) execute = true; break;
+					case '&': if (strstr(sz, condIter->sValue.chars())) execute = true; break;
 				}
+				
 				if (execute)
 					break;
 			}
 		}
+		
 		if (anyConditions && !execute)
-			(*iter).m_Done = true;		// don't execute
+			event->m_Done = true;		// don't execute
 	}
 }
 
 void EventsMngr::executeEvents()
 {
-	int err;
-
+	static unsigned int reentrant = 0;
 	if (!m_ParseFun)
 	{
 		return;
 	}
 
-#ifdef ENABLEEXEPTIONS
-	try
+	// Store old read data, which are either default values or previous event data
+	int oldMsgType = m_ReadMsgType, oldReadPos = m_ReadPos;
+	MsgDataEntry *oldReadVault = m_ReadVault, *readVault = NULL;
+	
+	// We have a re-entrant call
+	if (reentrant++)
 	{
-#endif		// #ifdef ENABLEEXEPTIONS
-		for (ClEventVecIter iter = m_ParseFun->begin(); iter; ++iter)
+		// Create temporary read vault
+		readVault = new MsgDataEntry[m_ParsePos + 1];
+		m_ReadVault = readVault;
+	} else if (m_ReadVaultSize != m_ParseVaultSize) {
+		// Extend read vault size if necessary
+		delete [] m_ReadVault;
+		m_ReadVault = new MsgDataEntry[m_ParseVaultSize];
+		m_ReadVaultSize = m_ParseVaultSize;
+		
+		// Update old read vault so we don't restore to a wrong pointer
+		oldReadVault = m_ReadVault;
+	}
+
+	// Copy data over to readvault
+	m_ReadPos = m_ParsePos;
+	m_ReadMsgType = m_ParseMsgType;
+
+	if (m_ParseVault)
+	{
+		memcpy(m_ReadVault, m_ParseVault, (m_ParsePos + 1) * sizeof(MsgDataEntry));
+	}
+
+	// Reset this here so we don't trigger re-entrancy for unregistered messages
+	auto parseFun = m_ParseFun;
+	m_ParseFun = nullptr;
+
+	auto lastSize = parseFun->length();
+	for(auto i = 0u; i < lastSize; i++)
+	{
+		auto &event = parseFun->at(i);
+
+		if (event->m_Done) 
 		{
-			if ( (*iter).m_Done ) 
-			{
-				(*iter).m_Done = false;
-				continue;
-			}
-
-			(*iter).m_Stamp = (float)*m_Timer;
-
-			if ((err = amx_Exec((*iter).m_Plugin->getAMX(), NULL, (*iter).m_Func, 1, m_ParseVault ? m_ParseVault[0].iValue : 0)) != AMX_ERR_NONE)
-			{
-				LogError((*iter).m_Plugin->getAMX(), err, "");
-			}
+			event->m_Done = false;
+			continue;
 		}
+		
+		event->m_Stamp = *m_Timer;
 
-#ifdef ENABLEEXEPTIONS
+		if (event->m_State == FSTATE_ACTIVE)
+		{
+			executeForwards(event->m_Func, static_cast<cell>(m_ReadVault ? m_ReadVault[0].iValue : 0));
+		}
 	}
-	catch( ... )
-	{
-		AMXXLOG_Log( "[AMXX] fatal error at event execution");
-	}
-#endif		// #ifdef ENABLEEXEPTIONS
+	
+	// Restore old read data, either resetting to default or to previous event data
+	m_ReadMsgType = oldMsgType;
+	m_ReadPos = oldReadPos;
+	m_ReadVault = oldReadVault;
+	
+	delete [] readVault;
 
-	m_CurrentMsgType = -1;
-	m_ParseFun = NULL;
+	--reentrant;
 }
 
 int EventsMngr::getArgNum() const
 {
-	return m_ParsePos + 1;
+	return m_ReadPos + 1;
 }
 
 const char* EventsMngr::getArgString(int a) const
 {
-	if ( a < 0 || a > m_ParsePos )
+	if (a < 0 || a > m_ReadPos)
 		return "";
 
 	static char var[32];
 
-	switch(m_ParseVault[a].type)
+	switch (m_ReadVault[a].type)
 	{
-	case MSG_INTEGER: 
-		sprintf( var, "%d", m_ParseVault[a].iValue );
-		return var;
-	case MSG_STRING: 
-		return m_ParseVault[a].sValue;
-	default:
-		sprintf( var, "%g", m_ParseVault[a].fValue );
-		return var;
+		case MSG_INTEGER: 
+			sprintf(var, "%d", m_ReadVault[a].iValue);
+			return var;
+		case MSG_STRING: 
+			return m_ReadVault[a].sValue;
+		default:
+			sprintf(var, "%g", m_ReadVault[a].fValue);
+			return var;
 	}
 }
 
 int EventsMngr::getArgInteger(int a) const
 {
-	if ( a < 0 || a > m_ParsePos )
+	if (a < 0 || a > m_ReadPos)
 		return 0;
 
-	switch(m_ParseVault[a].type)
+	switch (m_ReadVault[a].type)
 	{
-	case MSG_INTEGER:
-		return m_ParseVault[a].iValue;
-	case MSG_STRING:
-		return atoi(m_ParseVault[a].sValue);
-	default:
-		return (int)m_ParseVault[a].fValue; 
+		case MSG_INTEGER:
+			return m_ReadVault[a].iValue;
+		case MSG_STRING:
+			return atoi(m_ReadVault[a].sValue);
+		default:
+			return (int)m_ReadVault[a].fValue; 
 	}
 }
 
 float EventsMngr::getArgFloat(int a) const
 {
-	if ( a < 0 || a > m_ParsePos )
+	if (a < 0 || a > m_ReadPos)
 		return 0.0f;
 
-	switch(m_ParseVault[a].type)
+	switch (m_ReadVault[a].type)
 	{
-	case MSG_INTEGER:
-		return m_ParseVault[a].iValue;
-	case MSG_STRING:
-		return atof(m_ParseVault[a].sValue);
-	default:
-		return m_ParseVault[a].fValue; 
+		case MSG_INTEGER:
+			return static_cast<float>(m_ReadVault[a].iValue);
+		case MSG_STRING:
+			return static_cast<float>(atof(m_ReadVault[a].sValue));
+		default:
+			return m_ReadVault[a].fValue; 
 	}
 }
 
@@ -498,6 +550,9 @@ void EventsMngr::clearEvents(void)
 	{
 		m_Events[i].clear();
 	}
+
+	EventHandles.clear();
+
 	// delete parsevault
 	if (m_ParseVault)
 	{
@@ -505,6 +560,14 @@ void EventsMngr::clearEvents(void)
 		m_ParseVault = NULL;
 		m_ParseVaultSize = 0;
 	}
+
+	if (m_ReadVault)
+	{
+		delete [] m_ReadVault;
+		m_ReadVault = NULL;
+		m_ReadVaultSize = 0;
+		m_ReadPos = -1;
+	}
 }
 
 int EventsMngr::getEventId(const char* msg)
@@ -516,28 +579,29 @@ int EventsMngr::getEventId(const char* msg)
 		CS_EventsIds id;
 	} table[] =
 	{
-		{ "CS_DeathMsg" ,	CS_DeathMsg  },
-			//		{ "CS_RoundEnd" ,	CS_RoundEnd  },
-			//		{ "CS_RoundStart" , CS_RoundStart  },
-			//		{ "CS_Restart" ,	CS_Restart  },
-		{ "" ,				CS_Null  }
+		{"CS_DeathMsg",		CS_DeathMsg},
+//		{"CS_RoundEnd",		CS_RoundEnd},
+//		{"CS_RoundStart",	CS_RoundStart},
+//		{"CS_Restart",		CS_Restart},
+		{"",				CS_Null}
 	};
 
 	// if msg is a number, return it
 	int pos = atoi(msg);
+	
 	if (pos != 0)
 		return pos;
 
 	// try to find in table first
-	for (pos = 0; table[ pos ].id != CS_Null; ++pos )
-		if ( !strcmp( table[ pos ].name , msg ) )
-			return table[ pos ].id;
+	for (pos = 0; table[pos].id != CS_Null; ++pos)
+		if (!strcmp(table[pos].name, msg))
+			return table[pos].id;
 
 	// find the id of the message
-	return pos = GET_USER_MSG_ID(PLID, msg , 0 );
+	return pos = GET_USER_MSG_ID(PLID, msg, 0);
 }
 
 int EventsMngr::getCurrentMsgType()
 {
-	return m_CurrentMsgType;
+	return m_ReadMsgType;
 }

amxmodx/CEvent.h

@@ -1,40 +1,21 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef __CEVENTS_H__
 #define __CEVENTS_H__
 
-#define MAX_AMX_REG_MSG MAX_REG_MSGS+16
+#include "natives_handles.h"
+
+#define MAX_AMX_REG_MSG MAX_REG_MSGS + 16
  
-enum {
+enum
+{
 	CS_DEATHMSG = MAX_REG_MSGS,
 //	CS_ROUNDEND,
 //	CS_ROUNDSTART,
@@ -67,28 +48,31 @@ public:
 
 	class ClEvent
 	{
-		friend class EventsMngr;		// events manager may access our private members
+		friend class EventsMngr;				// events manager may access our private members
 
 		int m_Func;								// function to be executed
 		CPluginMngr::CPlugin *m_Plugin;			// the plugin this ClEvent class is assigned to
 
 		// flags
-		bool m_FlagPlayer;
+		bool m_FlagClient;
 		bool m_FlagWorld;
 		bool m_FlagOnce;
 		bool m_FlagDead;
 		bool m_FlagAlive;
+		bool m_FlagPlayer;
+		bool m_FlagBot;
 
 		float m_Stamp;	// for 'once' flag
 
 		bool m_Done;
+		ForwardState m_State;
 		
 		// conditions
 		struct cond_t
 		{
 			int paramId;				// the message parameter id
 
-			String sValue;				// value (string)
+			ke::AString sValue;				// value (string)
 			float fValue;				// value (float)
 			int iValue;					// value (int)
 			int type;					// type (can be int, float, string)
@@ -100,12 +84,13 @@ public:
 
 	public:
 		// constructors & destructors
-		ClEvent(CPluginMngr::CPlugin* plugin,  int func, int flags);
+		ClEvent(CPluginMngr::CPlugin* plugin, int func, int flags);
 		~ClEvent();
 
 		inline CPluginMngr::CPlugin* getPlugin();
 		inline int getFunction();
 		void registerFilter(char* filter);			// add a condition
+		void setForwardState(ForwardState value);
 	};
 
 private:
@@ -116,44 +101,54 @@ private:
 		const char* sValue;
 		MsgParamType type;
 	};
+
 	MsgDataEntry *m_ParseVault;
+	MsgDataEntry *m_ReadVault;
 	int m_ParseVaultSize;
-	void NextParam();				// make sure a new parameter can be added
+	int m_ReadVaultSize;
+	void NextParam();			// make sure a new parameter can be added
 
-	typedef CList<ClEvent> ClEventVec;
-	typedef ClEventVec::iterator ClEventVecIter;
-
-	ClEventVec m_Events[MAX_AMX_REG_MSG];
-	ClEventVec *m_ParseFun;	// current Event vector
+	ke::Vector<ke::AutoPtr<ClEvent>> m_Events[MAX_AMX_REG_MSG];
+	ke::Vector<ke::AutoPtr<ClEvent>> *m_ParseFun; // current Event vector
 
 	bool m_ParseNotDone;
 	int m_ParsePos;				// is args. num. - 1
+	int m_ReadPos;
 	float* m_Timer;
 	
-	ClEvent* getValidEvent(ClEvent* a );
+	ClEvent* getValidEvent(ClEvent* a);
 
-	int m_CurrentMsgType;
+	int m_ParseMsgType;
+	int m_ReadMsgType;
 public:
 	EventsMngr();
 	~EventsMngr();
 
 	// Interface
 
-	ClEvent* registerEvent(CPluginMngr::CPlugin* plugin, int func, int flags, int msgid);
+	int registerEvent(CPluginMngr::CPlugin* plugin, int func, int flags, int msgid);
+
 	void parserInit(int msg_type, float* timer, CPlayer* pPlayer, int index);
 	void parseValue(int iValue);
 	void parseValue(float fValue);
 	void parseValue(const char *sz);
 	void executeEvents();
-	int getArgNum() const; //{ return (parsePos+1); }
+	
+	int getArgNum() const;		//{ return (parsePos + 1); }
 	const char* getArgString(int a) const;
 	int getArgInteger(int a) const;
 	float getArgFloat(int a) const;
 	void clearEvents(void);
-	static int getEventId( const char* msg );
+	static int getEventId(const char* msg);
 	int getCurrentMsgType();
 };
 
-#endif // #ifdef __CEVENTS_H__
+struct EventHook
+{
+	explicit EventHook(EventsMngr::ClEvent *event) : m_event(event) {}
+	EventsMngr::ClEvent *m_event;
+};
 
+extern NativeHandle<EventHook> EventHandles;
 
+#endif //__CEVENTS_H__

amxmodx/CFile.cpp

@@ -1,126 +0,0 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
-
-#include <ctype.h>
-#include "amxmodx.h"
-#include "CFile.h"
-
-// *****************************************************
-// class File
-// *****************************************************
-File::File( const char* n, const char* m )
-{
-  fp = fopen( n , m );
-}
-
-File::~File( )
-{
-  if ( fp )
-    fclose( fp );
-}
-
-File::operator bool ( ) const
-{
-  return fp && !feof(fp);
-}
-
-File& operator<<( File& f, const String& n )
-{
-  if ( f ) fputs( n.c_str() , f.fp ) ;
-  return f;
-}
-
-File& operator<<( File& f, const char* n )
-{
-  if ( f ) fputs( n , f.fp ) ;
-  return f;
-}
-
-File& operator<<( File& f, int n )
-{
-  if ( f ) fprintf( f.fp , "%d" , n ) ;
-  return f;
-}
-
-
-File& operator<<( File& f, const char& c )
-{
-  if ( f ) fputc( c , f.fp ) ;
-  return f;
-}
-
-File& operator>>( File& f, String& n )
-{
-  if ( !f ) return f;
-  char temp[1024];
-  fscanf( f.fp , "%s", temp );
-  n.assign(temp);
-  return f;
-}
-
-File& operator>>( File& f, char* n )
-{
-  if ( f ) fscanf( f.fp , "%s", n );
-  return f;
-}
-
-int File::getline( char* buf, int sz )
-{
-  int a = sz;
-  char *origBuf = buf;
-  if ( *this )
-  {
-    int c;
-    while ( sz-- && (c = getc( (*this).fp)) && c != EOF && c != '\n'  )
-      *buf++ = c;
-    *buf = 0;
-  }
-
-  // trim 0x0a and 0x0d characters at the end
-  while (buf != origBuf)
-  {
-    if (*buf == 0x0a || *buf == 0x0d)
-		*buf = 0;
-	--buf;
-  }
-
-  return a - sz;
-}
-
-File& File::skipWs( )
-{
-  if ( !*this ) return *this;
-  int c;
-  while( isspace( c = getc( fp ) ) ){};
-  ungetc( c , fp );
-  return *this;
-}
-

amxmodx/CFile.h

@@ -1,58 +0,0 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
-
-#include <stdio.h>
-#include "CString.h"
-
-// *****************************************************
-// class File
-// *****************************************************
-
-class File
-{
-	FILE* fp;
-
-public:
-	File( const char* n, const char* m );
-	~File( );
-	operator bool ( ) const;
-	friend File& operator<<( File& f, const String& n );
-	friend File& operator<<( File& f, const char* n );
-	friend File& operator<<( File& f, const char& c );
-	friend File& operator<<( File& f, int n );
-	friend File& operator>>( File& f, String& n );
-	friend File& operator>>( File& f, char* n );
-	int getline( char* buf, int sz );
-	File& skipWs( );
-};
-
-
-

amxmodx/CFileSystem.h

@@ -0,0 +1,255 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef _INCLUDE_CFILESYSTEM_H_
+#define _INCLUDE_CFILESYSTEM_H_
+
+#include <FileSystem.h> // IFileSystem, FileSystemSeek_t, FileHandle_t (HLSDK)
+#include <stdio.h>      // FILE*
+
+extern IFileSystem* g_FileSystem;
+
+class ValveFile;
+class SystemFile;
+
+class FileObject
+{
+	public:
+
+		virtual ~FileObject() {};
+
+		virtual size_t Read(void* pOut, size_t size) = 0;
+		virtual char* ReadLine(char* pOut, size_t size) = 0;
+		virtual size_t Write(const void* pData, size_t size) = 0;
+
+		virtual bool Seek(int pos, int seek_type) = 0;
+		virtual int Tell() = 0;
+		virtual int Flush() = 0;
+
+		virtual bool HasError() = 0;
+
+		virtual bool EndOfFile() = 0;
+		virtual void Close() = 0;
+
+		virtual ValveFile *AsValveFile()
+		{
+			return nullptr;
+		}
+
+		virtual SystemFile *AsSystemFile()
+		{
+			return nullptr;
+		}
+};
+
+class ValveFile : public FileObject
+{
+	public:
+
+		ValveFile(FileHandle_t handle) : handle_(handle) {}
+
+		~ValveFile()
+		{
+			Close();
+		}
+
+		static bool Exists(const char* file)
+		{
+			return g_FileSystem->FileExists(file);
+		}
+
+		static ValveFile* Open(const char* filename, const char* mode, const char* pathID)
+		{
+			FileHandle_t handle = g_FileSystem->OpenFromCacheForRead(filename, mode, pathID);
+
+			if (!handle)
+			{
+				return nullptr;
+			}
+
+			return new ValveFile(handle);
+		}
+
+		static bool Delete(const char* filename, const char* pathID)
+		{
+			if (!Exists(filename))
+			{
+				return false;
+			}
+
+			g_FileSystem->RemoveFile(filename, pathID);
+
+			if (Exists(filename))
+			{
+				return false;
+			}
+
+			return true;
+		}
+
+		size_t Read(void* pOut, size_t size) override
+		{
+			return static_cast<size_t>(g_FileSystem->Read(pOut, size, handle_));
+		}
+
+		char* ReadLine(char* pOut, size_t size) override
+		{
+			return g_FileSystem->ReadLine(pOut, size, handle_);
+		}
+
+		size_t Write(const void* pData, size_t size) override
+		{
+			return static_cast<size_t>(g_FileSystem->Write(pData, size, handle_));
+		}
+
+		bool Seek(int pos, int seek_type) override
+		{
+			g_FileSystem->Seek(handle_, pos, static_cast<FileSystemSeek_t>(seek_type));
+			return !HasError();
+		}
+
+		int Tell() override
+		{
+			return g_FileSystem->Tell(handle_);
+		}
+
+		bool HasError() override
+		{
+			return !handle_ || !g_FileSystem->IsOk(handle_);
+		}
+
+		int Flush() override
+		{
+			g_FileSystem->Flush(handle_);
+			return 0;
+		}
+
+		bool EndOfFile() override
+		{
+			return g_FileSystem->EndOfFile(handle_);
+		}
+
+		void Close() override
+		{
+			if (handle_)
+			{
+				g_FileSystem->Close(handle_);
+				handle_ = nullptr;;
+			}
+		}
+
+		virtual ValveFile* AsValveFile()
+		{
+			return this;
+		}
+
+		FileHandle_t handle() const
+		{
+			return handle_;
+		}
+
+	private:
+
+		FileHandle_t handle_;
+};
+
+
+class SystemFile : public FileObject
+{
+	public:
+
+		SystemFile(FILE* fp) : fp_(fp) {}
+
+		~SystemFile()
+		{
+			Close();
+		}
+
+		static SystemFile* Open(const char* path, const char* mode)
+		{
+			FILE* fp = fopen(path, mode);
+
+			if (!fp)
+			{
+				return nullptr;
+			}
+
+			return new SystemFile(fp);
+		}
+
+		static bool Delete(const char* path)
+		{
+			return unlink(path) == 0;
+		}
+
+		size_t Read(void* pOut, size_t size) override
+		{
+			return fread(pOut, 1, size, fp_);
+		}
+
+		char* ReadLine(char* pOut, size_t size) override
+		{
+			return fgets(pOut, size, fp_);
+		}
+
+		size_t Write(const void* pData, size_t size) override
+		{
+			return fwrite(pData, 1, size, fp_);
+		}
+
+		bool Seek(int pos, int seek_type) override
+		{
+			return fseek(fp_, pos, seek_type) == 0;
+		}
+
+		int Tell() override
+		{
+			return ftell(fp_);
+		}
+
+		bool HasError() override
+		{
+			return ferror(fp_) != 0;
+		}
+
+		int Flush() override
+		{
+			return fflush(fp_);
+		}
+
+		bool EndOfFile() override
+		{
+			return feof(fp_) != 0;
+		}
+
+		void Close() override
+		{
+			if (fp_)
+			{
+				fclose(fp_);
+				fp_ = nullptr;
+			}
+		}
+
+		virtual SystemFile* AsSystemFile()
+		{
+			return this;
+		}
+
+		FILE* handle() const
+		{
+			return fp_;
+		}
+
+	private:
+
+		FILE* fp_;
+};
+
+#endif // _INCLUDE_CFILESYSTEM_H_

amxmodx/CFlagManager.cpp

@@ -0,0 +1,410 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "sh_list.h"
+#include "amxmodx.h"
+
+#include "CFlagManager.h"
+
+void CFlagManager::SetFile(const char *Filename)
+{
+	m_strConfigFile = build_pathname("%s/%s", get_localinfo("amxx_configsdir", "addons/amxmodx/configs"), Filename);
+
+	CreateIfNotExist();
+}
+
+const int CFlagManager::LoadFile(const int force)
+{
+	CheckIfDisabled();
+	// If we're disabled get the hell out.  now.
+	if (m_iDisabled)
+	{
+		return 0;
+	}
+	// if we're not forcing this, and NeedToLoad says we dont have to
+	// then just stop
+	if (!force && !NeedToLoad())
+	{
+		return 0;
+	}
+
+	this->Clear();
+
+
+	// We need to load the file
+
+	FILE *File;
+
+	File=fopen(GetFile(),"r");
+
+	if (!File)
+	{
+		AMXXLOG_Log("[AMXX] FlagManager: Cannot open file \"%s\" (FILE pointer null!)", GetFile());
+		return -1;
+	}
+
+	// Trying to copy this almost exactly as other configs are read...
+	char Line[512];
+	char TempLine[512];
+
+	char Command[256];
+	char Flags[256];
+
+	
+	while (!feof(File) && fgets(Line, sizeof(Line), File))
+	{
+		char *nonconst= Line;
+
+		// Strip out comments
+		while (*nonconst)
+		{
+			if (*nonconst==';') // End the line at comments
+			{
+				*nonconst='\0';
+			}
+			else
+			{
+				nonconst++;
+			}
+		}
+
+		Command[0]='\0';
+		Flags[0]='\0';
+
+		// Extract the command
+		strncopy(TempLine, Line, sizeof(TempLine));
+
+		nonconst = TempLine;
+
+		char *start=NULL;
+		char *end=NULL;
+
+		// move up line until the first ", mark this down as the start
+		// then find the second " and mark it down as the end
+		while (*nonconst!='\0')
+		{
+			if (*nonconst=='"')
+			{
+				if (start==NULL)
+				{
+					start=nonconst+1;
+				}
+				else
+				{
+					end=nonconst;
+					goto done_with_command;
+				}
+			}
+			nonconst++;
+		}
+done_with_command:
+
+		// invalid line?
+		if (start==NULL || end==NULL)
+		{
+			// TODO: maybe warn for an invalid non-commented line?
+			continue;
+		}
+
+		*end='\0';
+
+		strncpy(Command,start,sizeof(Command)-1);
+
+		// Now do the same thing for the flags
+		nonconst=++end;
+
+		start=NULL;
+		end=NULL;
+
+		// move up line until the first ", mark this down as the start
+		// then find the second " and mark it down as the end
+		while (*nonconst!='\0')
+		{
+			if (*nonconst=='"')
+			{
+				if (start==NULL)
+				{
+					start=nonconst+1;
+				}
+				else
+				{
+					end=nonconst;
+					goto done_with_flags;
+				}
+			}
+			nonconst++;
+		}
+done_with_flags:
+		// invalid line?
+		if (start==NULL || end==NULL)
+		{
+			// TODO: maybe warn for an invalid non-commented line?
+			continue;
+		}
+
+		*end='\0';
+
+		strncpy(Flags,start,sizeof(Flags)-1);
+
+		//if (!isalnum(*Command))
+		if (*Command == '"' || *Command == '\0')
+		{
+			continue;
+		}
+
+		// Done sucking the command and flags out of the line
+		// now insert this command into the linked list
+
+		AddFromFile(const_cast<const char*>(&Command[0]),&Flags[0]);
+
+		nonconst = Line;
+		*nonconst = '\0';
+	}
+
+	fclose(File);
+
+	return 1;
+}
+
+/**
+ * This gets called from LoadFile
+ * Do NOT flag the entries as NeedToWrite
+ * No comment is passed from the file because
+ * this should never get written
+ */
+void CFlagManager::AddFromFile(const char *Command, const char *Flags)
+{
+	CFlagEntry *Entry=new CFlagEntry;
+
+	Entry->SetName(Command);
+	Entry->SetFlags(Flags);
+
+	// Link it
+	m_FlagList.push_back(Entry);
+
+}
+
+void CFlagManager::LookupOrAdd(const char *Command, int &Flags, AMX *Plugin)
+{
+	if (m_iDisabled) // if disabled in core.ini stop
+	{
+		return;
+	}
+	
+	int TempFlags=Flags;
+	if (TempFlags==-1)
+	{
+		TempFlags=0;
+	}
+
+	List<CFlagEntry *>::iterator	 iter;
+	List<CFlagEntry *>::iterator	 end;
+
+	iter=m_FlagList.begin();
+	end=m_FlagList.end();
+
+	while (iter!=end)
+	{
+		if (strcmp((*iter)->GetName()->chars(),Command)==0)
+		{
+			CFlagEntry *Entry=(*iter);
+
+			if (Entry->IsHidden()) // "!" flag, exclude this function
+			{
+				return;
+			}
+			// Found, byref the new flags
+			Flags=Entry->Flags();
+
+			// Move it to the back of the list for faster lookup for the rest
+			m_FlagList.erase(iter);
+
+			m_FlagList.push_back(Entry);
+			return;
+		}
+		iter++;
+	}
+
+	// was not found, add it
+
+	CFlagEntry *Entry=new CFlagEntry;
+
+	Entry->SetName(Command);
+	Entry->SetFlags(TempFlags);
+
+	if (Plugin)
+	{
+		CPluginMngr::CPlugin* a = g_plugins.findPluginFast(Plugin);
+
+		if (a)
+		{
+			Entry->SetComment(a->getName());
+		}
+	}
+
+	// This entry was added from a register_* native
+	// it needs to be written during map change
+	Entry->SetNeedWritten(1);
+
+	// Link it
+	m_FlagList.push_back(Entry);
+
+}
+
+void CFlagManager::WriteCommands(void)
+{
+	if (m_iDisabled)
+	{
+		return;
+	}
+
+	List<CFlagEntry *>::iterator	 iter;
+	List<CFlagEntry *>::iterator	 end;
+	FILE							*File;
+	int								 NeedToRead=0;
+
+	// First off check the modified time of this file
+	// if it matches the stored modified time, then update
+	// after we write so we do not re-read next map
+	struct stat TempStat;
+
+	stat(GetFile(), &TempStat);
+
+
+
+	if (TempStat.st_mtime != m_Stat.st_mtime)
+	{
+		NeedToRead=1;
+	};
+
+
+	File = fopen(GetFile(), "a");
+	
+	if (!File)
+	{
+		return;
+	}
+
+	iter=m_FlagList.begin();
+	end=m_FlagList.end();
+
+
+
+	while (iter!=end)
+	{
+		if ((*iter)->NeedWritten())
+		{
+			if ((*iter)->GetComment()->length())
+			{
+				fprintf(File,"\"%s\" \t\"%s\" ; %s\n",(*iter)->GetName()->chars(),(*iter)->GetFlags()->chars(),(*iter)->GetComment()->chars());
+			}
+			else
+			{
+				fprintf(File,"\"%s\" \t\"%s\"\n",(*iter)->GetName()->chars(),(*iter)->GetFlags()->chars());
+			}
+			(*iter)->SetNeedWritten(0);
+		}
+		++iter;
+	}
+
+	fclose(File);
+
+
+	// If NeedToRead was 0, then update the timestamp
+	// that was saved so we do not re-read this file
+	// next map
+	if (!NeedToRead)
+	{
+		stat(GetFile(), &TempStat);
+
+		m_Stat.st_mtime=TempStat.st_mtime;
+
+	}
+
+}
+
+int CFlagManager::ShouldIAddThisCommand(const AMX *amx, const cell *params, const char *cmdname) const
+{
+	// If flagmanager is disabled then ignore this
+	if (m_iDisabled)
+	{
+		return 0;
+	}
+	
+	
+	// If 5th param exists it was compiled after this change was made
+	// if it does not exist, try our logic at the end of this function
+	// 5th param being > 0 means explicit yes
+	// < 0 means auto detect (default is -1), treat it like there was no 5th param
+	// 0 means explicit no
+
+	if ((params[0] / sizeof(cell)) >= 5)
+	{
+		if (params[5]>0) // This command was explicitly told to be included
+		{
+			return 1;
+		}
+		else if (params[5]==0) // this command was explicitly told to NOT be used
+		{
+			return 0;
+		}
+	}
+
+	// auto detect if we should use this command
+
+	// if command access is -1 (default, not set to ADMIN_ALL or any other access), then no
+	if (params[3]==-1)
+	{
+		return 0;
+	}
+
+
+	// if command is (or starts with) "say", then no
+	if (strncmp(cmdname,"say",3)==0)
+	{
+		return 0;
+	}
+
+
+	// else use it
+	return 1;
+}
+
+void CFlagManager::Clear(void)
+{
+	List<CFlagEntry *>::iterator	 iter;
+	List<CFlagEntry *>::iterator	 end;
+
+	iter=m_FlagList.begin();
+	end=m_FlagList.end();
+
+	while (iter!=end)
+	{
+		delete (*iter);
+
+		++iter;
+	}
+
+	m_FlagList.clear();
+}
+
+void CFlagManager::CheckIfDisabled(void)
+{
+	if (atoi(get_localinfo("disableflagman","0"))==0)
+	{
+		m_iDisabled=0;
+	}
+	else
+	{
+		m_iDisabled=1;
+	}
+}

amxmodx/CFlagManager.h

@@ -0,0 +1,231 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef CFLAGMANAGER_H
+#define CFLAGMANAGER_H
+
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "sh_list.h"
+#include "amxmodx.h"
+#include "CLibrarySys.h"
+
+class CFlagEntry
+{
+private:
+	ke::AString		m_strName;			// command name ("amx_slap")
+	ke::AString		m_strFlags;			// string flags ("a","b")
+	ke::AString		m_strComment;		// comment to write ("; admincmd.amxx")
+	int				m_iFlags;			// bitmask flags
+	int				m_iNeedWritten;		// write this command on map change?
+	int				m_iHidden;			// set to 1 when the command is set to "!" access in
+										// the .ini file: this means do not process this command
+
+public:
+
+	CFlagEntry()
+	{
+		m_iNeedWritten=0;
+		m_iFlags=0;
+		m_iHidden=0;
+	};
+	const int NeedWritten(void) const
+	{
+		return m_iNeedWritten;
+	};
+
+	void SetNeedWritten(const int i=1)
+	{
+		m_iNeedWritten=i;
+	};
+
+	const ke::AString *GetName(void) const
+	{
+		return &m_strName;
+	};
+
+	const ke::AString *GetFlags(void) const
+	{
+		return &m_strFlags;
+	};
+
+	const ke::AString *GetComment(void) const
+	{
+		return &m_strComment;
+	};
+
+	const int Flags(void) const
+	{
+		return m_iFlags;
+	};
+
+	void SetName(const char *data)
+	{
+		m_strName = data;
+	};
+	void SetFlags(const char *flags)
+	{
+		// If this is a "!" entry then stop
+		if (flags && flags[0]=='!')
+		{
+			SetHidden(1);
+			return;
+		}
+
+		m_strFlags = flags;
+		m_iFlags=UTIL_ReadFlags(flags);
+	};
+	void SetFlags(const int flags)
+	{
+		m_iFlags=flags;
+
+		char FlagsString[32];
+		UTIL_GetFlags(FlagsString, flags);
+
+		m_strFlags = FlagsString;
+	};
+	void SetComment(const char *comment)
+	{
+		m_strComment = comment;
+	};
+	void SetHidden(int i=1)
+	{
+		m_iHidden=i;
+	};
+	int IsHidden(void) const
+	{
+		return m_iHidden;
+	};
+};
+class CFlagManager
+{
+private:
+	List<CFlagEntry *>		 m_FlagList;
+	ke::AString				 m_strConfigFile;
+	struct stat				 m_Stat;
+	int						 m_iForceRead;
+	int						 m_iDisabled;
+	
+
+	void CreateIfNotExist(void) const
+	{
+		FILE *fp;
+		
+		fp = fopen(GetFile(), "r");
+
+		if (!fp)
+		{
+			// File does not exist, create the header
+			fp = fopen(GetFile(), "a");
+
+			if (fp)
+			{
+				fprintf(fp,"; This file will store the commands used by plugins, and their access level\n");
+				fprintf(fp,"; To change the access of a command, edit the flags beside it and then\n");
+				fprintf(fp,";   change the server's map.\n;\n");
+				fprintf(fp,"; Example: If I wanted to change the amx_slap access to require\n");
+				fprintf(fp,";          RCON access (flag \"l\") I would change this:\n");
+				fprintf(fp,";          \"amx_slap\"  \"e\" ; admincmd.amxx\n");
+				fprintf(fp,";          To this:\n");
+				fprintf(fp,";          \"amx_slap\"  \"l\" ; admincmd.amxx\n;\n");
+				fprintf(fp,"; To disable a specific command from being used with the command manager\n");
+				fprintf(fp,";   and to only use the plugin-specified access set the flag to \"!\"\n;\n");
+				fprintf(fp,"; NOTE: The plugin name at the end is just for reference to what plugin\n");
+				fprintf(fp,";       uses what commands.  It is ignored.\n\n");
+				fclose(fp);
+			};
+		}
+		else
+		{
+			fclose(fp);
+		}
+	};
+	/**
+	 * Returns 1 if the timestamp for the file is different than the one we have loaded
+	 * 0 otherwise
+	 */
+	inline int NeedToLoad(void)
+	{
+		struct stat TempStat;
+
+		stat(GetFile(), &TempStat);
+
+		// If the modified timestamp does not match the stored
+		// timestamp than we need to re-read this file.
+		// Otherwise, ignore the file.
+		if (TempStat.st_mtime != m_Stat.st_mtime)
+		{
+			// Save down the modified timestamp
+			m_Stat.st_mtime=TempStat.st_mtime;
+			return 1;
+		};
+
+		return 0;
+
+	};
+public:
+
+	CFlagManager()
+	{
+		memset(&m_Stat,0x0,sizeof(struct stat));
+		m_iDisabled=0;
+		m_iForceRead=0;
+	};
+	~CFlagManager()
+	{
+	};
+
+	/**
+	 * Sets the filename in relation to amxmodx/configs
+	 */
+	void SetFile(const char *Filename="cmdaccess.ini");
+
+	const char *GetFile(void) const	{ return m_strConfigFile.chars(); };
+	
+	/**
+	 * Parse the file, and load all entries
+	 * Returns 1 on success, 0 on refusal (no need to), and -1 on error
+	 */
+	const int LoadFile(const int force=0);
+
+	/**
+	 * Checks if the command exists in the list
+	 * If it does, it byrefs the flags for it
+	 * If it does not, it adds it to the list
+	 * These are added from register_*cmd calls
+	 */
+	void LookupOrAdd(const char *Command, int &Flags, AMX *Plugin);
+
+
+	/**
+	 * Write the commands back to the file
+	 */
+	void WriteCommands(void);
+
+	/**
+	 * Add this straight from the cmdaccess.ini file
+	 */
+	void AddFromFile(const char *Command, const char *Flags);
+
+	/**
+	 * Checks if this command should be added to flagman or not
+	 * This is only checked when adding commands from the register_* natives
+	 * If an admin manually adds a command to cmdaccess.ini it will be used
+	 *   regardless of whatever this function would say should be done with it
+	 */
+	int ShouldIAddThisCommand(const AMX *amx, const cell *params, const char *cmdname) const;
+
+	void Clear(void);
+
+	void CheckIfDisabled(void);
+};
+
+#endif // CFLAGMANAGER_H

amxmodx/CForward.cpp

@@ -1,46 +1,28 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
+#include "debugger.h"
+#include "binlog.h"
 
 CForward::CForward(const char *name, ForwardExecType et, int numParams, const ForwardParam *paramTypes)
 {
 	m_FuncName = name;
 	m_ExecType = et;
 	m_NumParams = numParams;
+	
 	memcpy((void *)m_ParamTypes, paramTypes, numParams * sizeof(ForwardParam));
+	
 	// find funcs
 	int func;
-	AMXForward *tmp = NULL;
 	m_Funcs.clear();
+	
 	for (CPluginMngr::iterator iter = g_plugins.begin(); iter; ++iter)
 	{
 		if ((*iter).isValid() && amx_FindPublic((*iter).getAMX(), name, &func) == AMX_ERR_NONE)
@@ -48,9 +30,11 @@ CForward::CForward(const char *name, ForwardExecType et, int numParams, const Fo
 			AMXForward tmp;
 			tmp.pPlugin = &(*iter);
 			tmp.func = func;
-			m_Funcs.push_back(tmp);
+			m_Funcs.append(tmp);
 		}
 	}
+
+	m_Name = name;
 }
 
 cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
@@ -62,42 +46,63 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 
 	cell globRetVal = 0;
 
-	unsigned int id = 0;
-
-	AMXForwardList::iterator iter;
-
-	for (iter = m_Funcs.begin(); iter != m_Funcs.end(); iter++)
+	for (size_t i = 0; i < m_Funcs.length(); ++i)
 	{
+		auto iter = &m_Funcs[i];
+
 		if (iter->pPlugin->isExecutable(iter->func))
 		{
-			// handle strings & arrays
+			// Get debug info
+			AMX *amx = iter->pPlugin->getAMX();
+			Debugger *pDebugger = (Debugger *)amx->userdata[UD_DEBUGGER];
+			
+			if (pDebugger)
+				pDebugger->BeginExec();
+			
+			// handle strings & arrays & values by reference
 			int i;
+			
 			for (i = 0; i < m_NumParams; ++i)
 			{
 				if (m_ParamTypes[i] == FP_STRING || m_ParamTypes[i] == FP_STRINGEX)
 				{
+					const char *str = reinterpret_cast<const char*>(params[i]);
 					cell *tmp;
-					amx_Allot(iter->pPlugin->getAMX(),
-						(m_ParamTypes[i] == FP_STRING) ? strlen(reinterpret_cast<const char*>(params[i]))+1 : STRINGEX_MAXLENGTH,
-						&realParams[i], &tmp);
-					amx_SetString(tmp, (const char *)(params[i]), 0, 0);
+					if (!str)
+						str = "";
+					amx_Allot(amx, (m_ParamTypes[i] == FP_STRING) ? strlen(str) + 1 : STRINGEX_MAXLENGTH, &realParams[i], &tmp);
+					amx_SetStringOld(tmp, str, 0, 0);
 					physAddrs[i] = tmp;
 				}
 				else if (m_ParamTypes[i] == FP_ARRAY)
 				{
 					cell *tmp;
-					amx_Allot(iter->pPlugin->getAMX(), preparedArrays[params[i]].size,
-						&realParams[i], &tmp);
+					amx_Allot(amx, preparedArrays[params[i]].size, &realParams[i], &tmp);
 					physAddrs[i] = tmp;
+					
 					if (preparedArrays[params[i]].type == Type_Cell)
 					{
 						memcpy(tmp, preparedArrays[params[i]].ptr, preparedArrays[params[i]].size * sizeof(cell));
+					} else {
+						char *data = (char*)preparedArrays[params[i]].ptr;
+						
+						for (unsigned int j = 0; j < preparedArrays[params[i]].size; ++j)
+							*tmp++ = (static_cast<cell>(*data++)) & 0xFF;
+					}
+				}
+				else if (m_ParamTypes[i] == FP_CELL_BYREF || m_ParamTypes[i] == FP_FLOAT_BYREF)
+				{
+					cell *tmp;
+					amx_Allot(amx, 1, &realParams[i], &tmp);
+					physAddrs[i] = tmp;
+
+					if (m_ParamTypes[i] == FP_CELL_BYREF)
+					{
+						memcpy(tmp, reinterpret_cast<cell *>(params[i]), sizeof(cell));
 					}
 					else
 					{
-						char *data = (char*)preparedArrays[params[i]].ptr;
-						for (unsigned int j = 0; j < preparedArrays[params[i]].size; ++j)
-							*tmp++ = (static_cast<cell>(*data++)) & 0xFF;
+						memcpy(tmp, reinterpret_cast<REAL *>(params[i]), sizeof(REAL));
 					}
 				}
 				else
@@ -105,25 +110,52 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 					realParams[i] = params[i];
 				}
 			}
+			
+			//Push the parameters in reverse order. Weird, unfriendly part of Small 3.0!
+			for (i = m_NumParams-1; i >= 0; i--)
+			{
+				amx_Push(amx, realParams[i]);
+			}
+			
 			// exec
-			cell retVal;
-			int err = amx_Execv(iter->pPlugin->getAMX(), &retVal, iter->func, m_NumParams, realParams);
+			cell retVal = 0;
+#if defined BINLOG_ENABLED
+			g_BinLog.WriteOp(BinLog_CallPubFunc, iter->pPlugin->getId(), iter->func);
+#endif
+
+			int err = amx_ExecPerf(amx, &retVal, iter->func);
 			// log runtime error, if any
 			if (err != AMX_ERR_NONE)
-				LogError(iter->pPlugin->getAMX(), err, "");
+			{
+				//Did something else set an error?
+				if (pDebugger && pDebugger->ErrorExists())
+				{
+					//we don't care, something else logged the error.
+				}
+				else if (err != -1)
+				{
+					//nothing logged the error so spit it out anyway
+					LogError(amx, err, NULL);
+				}
+			}
+			
+			amx->error = AMX_ERR_NONE;
+			
+			if (pDebugger)
+				pDebugger->EndExec();
 
-			// cleanup strings & arrays
+			// cleanup strings & arrays & values by reference
 			for (i = 0; i < m_NumParams; ++i)
 			{
 				if (m_ParamTypes[i] == FP_STRING)
 				{
-					amx_Release(iter->pPlugin->getAMX(), realParams[i]);
+					amx_Release(amx, realParams[i]);
 				}
 				else if (m_ParamTypes[i] == FP_STRINGEX)
 				{
 					// copy back
-					amx_GetString(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
-					amx_Release(iter->pPlugin->getAMX(), realParams[i]);
+					amx_GetStringOld(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
+					amx_Release(amx, realParams[i]);
 				}
 				else if (m_ParamTypes[i] == FP_ARRAY)
 				{
@@ -134,50 +166,70 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 						if (preparedArrays[params[i]].type == Type_Cell)
 						{
 							memcpy(preparedArrays[params[i]].ptr, tmp, preparedArrays[params[i]].size * sizeof(cell));
-						}
-						else
-						{
+						} else {
 							char *data = (char*)preparedArrays[params[i]].ptr;
+							
 							for (unsigned int j = 0; j < preparedArrays[params[i]].size; ++j)
 								*data++ = static_cast<char>(*tmp++ & 0xFF);
 						}
 					}
-					amx_Release(iter->pPlugin->getAMX(), realParams[i]);
+					amx_Release(amx, realParams[i]);
+				}
+				else if (m_ParamTypes[i] == FP_CELL_BYREF || m_ParamTypes[i] == FP_FLOAT_BYREF)
+				{
+					//copy back
+					cell *tmp = physAddrs[i];
+					if (m_ParamTypes[i] == FP_CELL_BYREF)
+					{
+						memcpy(reinterpret_cast<cell *>(params[i]), tmp, sizeof(cell));
+					}
+					else
+					{
+						memcpy(reinterpret_cast<REAL *>(params[i]), tmp, sizeof(REAL));
+					}
+					amx_Release(amx, realParams[i]);
 				}
 			}
 
 			// decide what to do (based on exectype and retval)
 			switch (m_ExecType)
 			{
-			case ET_IGNORE:
-				break;
-			case ET_STOP:
-				if (retVal > 0)
-					return retVal;
-			case ET_STOP2:
-				if (retVal == 1)
-					return 1;
-				else if (retVal > globRetVal)
-					globRetVal = retVal;
-				break;
-			case ET_CONTINUE:
-				if (retVal > globRetVal)
-					globRetVal = retVal;
-				break;
+				case ET_IGNORE:
+					break;
+				case ET_STOP:
+					if (retVal > 0)
+						return retVal;
+				case ET_STOP2:
+					if (retVal == 1)
+						return 1;
+					else if (retVal > globRetVal)
+						globRetVal = retVal;
+					break;
+				case ET_CONTINUE:
+					if (retVal > globRetVal)
+						globRetVal = retVal;
+					break;
 			}
 		}
 	}
+	
 	return globRetVal;
 }
 
 void CSPForward::Set(int func, AMX *amx, int numParams, const ForwardParam *paramTypes)
 {
+	char name[sNAMEMAX];
 	m_Func = func;
 	m_Amx = amx;
 	m_NumParams = numParams;
 	memcpy((void *)m_ParamTypes, paramTypes, numParams * sizeof(ForwardParam));
 	m_HasFunc = true;
 	isFree = false;
+	name[0] = '\0';
+	amx_GetPublic(amx, func, name);
+	m_Name = name;
+	m_ToDelete = false;
+	m_InExec = false;
 }
 
 void CSPForward::Set(const char *funcName, AMX *amx, int numParams, const ForwardParam *paramTypes)
@@ -187,6 +239,9 @@ void CSPForward::Set(const char *funcName, AMX *amx, int numParams, const Forwar
 	memcpy((void *)m_ParamTypes, paramTypes, numParams * sizeof(ForwardParam));
 	m_HasFunc = (amx_FindPublic(amx, funcName, &m_Func) == AMX_ERR_NONE);
 	isFree = false;
+	m_Name = funcName;
+	m_ToDelete = false;
+	m_InExec = false;
 }
 
 cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
@@ -199,41 +254,63 @@ cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 	cell realParams[FORWARD_MAX_PARAMS];
 	cell *physAddrs[FORWARD_MAX_PARAMS];
 
-	if (!m_HasFunc)
+	if (!m_HasFunc || m_ToDelete)
 		return 0;
-	
+
 	CPluginMngr::CPlugin *pPlugin = g_plugins.findPluginFast(m_Amx);
 	if (!pPlugin->isExecutable(m_Func))
 		return 0;
 
-	// handle strings & arrays
+	m_InExec = true;
+
+	Debugger *pDebugger = (Debugger *)m_Amx->userdata[UD_DEBUGGER];
+	if (pDebugger)
+		pDebugger->BeginExec();
+
+	// handle strings & arrays & values by reference
 	int i;
+	
 	for (i = 0; i < m_NumParams; ++i)
 	{
 		if (m_ParamTypes[i] == FP_STRING || m_ParamTypes[i] == FP_STRINGEX)
 		{
+			const char *str = reinterpret_cast<const char*>(params[i]);
+			if (!str)
+				str = "";
 			cell *tmp;
-			amx_Allot(m_Amx,
-				(m_ParamTypes[i] == FP_STRING) ? strlen(reinterpret_cast<const char*>(params[i]))+1 : STRINGEX_MAXLENGTH,
-				&realParams[i], &tmp);
-			amx_SetString(tmp, (const char *)(params[i]), 0, 0);
+			amx_Allot(m_Amx, (m_ParamTypes[i] == FP_STRING) ? strlen(str) + 1 : STRINGEX_MAXLENGTH, &realParams[i], &tmp);
+			amx_SetStringOld(tmp, str, 0, 0);
 			physAddrs[i] = tmp;
 		}
 		else if (m_ParamTypes[i] == FP_ARRAY)
 		{
 			cell *tmp;
-			amx_Allot(m_Amx, preparedArrays[params[i]].size,
-				&realParams[i], &tmp);
+			amx_Allot(m_Amx, preparedArrays[params[i]].size, &realParams[i], &tmp);
 			physAddrs[i] = tmp;
+			
 			if (preparedArrays[params[i]].type == Type_Cell)
 			{
 				memcpy(tmp, preparedArrays[params[i]].ptr, preparedArrays[params[i]].size * sizeof(cell));
+			} else {
+				char *data = (char*)preparedArrays[params[i]].ptr;
+				
+				for (unsigned int j = 0; j < preparedArrays[params[i]].size; ++j)
+					*tmp++ = (static_cast<cell>(*data++)) & 0xFF;
+			}
+		}
+		else if (m_ParamTypes[i] == FP_CELL_BYREF || m_ParamTypes[i] == FP_FLOAT_BYREF)
+		{
+			cell *tmp;
+			amx_Allot(m_Amx, 1, &realParams[i], &tmp);
+			physAddrs[i] = tmp;
+
+			if (m_ParamTypes[i] == FP_CELL_BYREF)
+			{
+				memcpy(tmp, reinterpret_cast<cell *>(params[i]), sizeof(cell));
 			}
 			else
 			{
-				char *data = (char*)preparedArrays[params[i]].ptr;
-				for (unsigned int j = 0; j < preparedArrays[params[i]].size; ++j)
-					*tmp++ = (static_cast<cell>(*data++)) & 0xFF;
+				memcpy(tmp, reinterpret_cast<REAL *>(params[i]), sizeof(REAL));
 			}
 		}
 		else
@@ -241,12 +318,36 @@ cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 			realParams[i] = params[i];
 		}
 	}
-
+	
+	for (i = m_NumParams - 1; i >= 0; i--)
+		amx_Push(m_Amx, realParams[i]);
+	
 	// exec
-	cell retVal;
-	amx_Execv(m_Amx, &retVal, m_Func, m_NumParams, realParams);
+	cell retVal = 0;
+#if defined BINLOG_ENABLED
+	g_BinLog.WriteOp(BinLog_CallPubFunc, pPlugin->getId(), m_Func);
+#endif
+	int err = amx_ExecPerf(m_Amx, &retVal, m_Func);
+	if (err != AMX_ERR_NONE)
+	{
+		//Did something else set an error?
+		if (pDebugger && pDebugger->ErrorExists())
+		{
+			//we don't care, something else logged the error.
+		}
+		else if (err != -1)
+		{
+			//nothing logged the error so spit it out anyway
+			LogError(m_Amx, err, NULL);
+		}
+	}
+	
+	if (pDebugger)
+		pDebugger->EndExec();
+	
+	m_Amx->error = AMX_ERR_NONE;
 
-	// cleanup strings & arrays
+	// cleanup strings & arrays & values by reference
 	for (i = 0; i < m_NumParams; ++i)
 	{
 		if (m_ParamTypes[i] == FP_STRING)
@@ -256,7 +357,7 @@ cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 		else if (m_ParamTypes[i] == FP_STRINGEX)
 		{
 			// copy back
-			amx_GetString(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
+			amx_GetStringOld(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
 			amx_Release(m_Amx, realParams[i]);
 		}
 		else if (m_ParamTypes[i] == FP_ARRAY)
@@ -268,28 +369,48 @@ cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 				if (preparedArrays[params[i]].type == Type_Cell)
 				{
 					memcpy(preparedArrays[params[i]].ptr, tmp, preparedArrays[params[i]].size * sizeof(cell));
-				}
-				else
-				{
+				} else {
 					char *data = (char*)preparedArrays[params[i]].ptr;
+					
 					for (unsigned int j = 0; j < preparedArrays[params[i]].size; ++j)
 						*data++ = static_cast<char>(*tmp++ & 0xFF);
 				}
 			}
 			amx_Release(m_Amx, realParams[i]);
 		}
+		else if (m_ParamTypes[i] == FP_CELL_BYREF || m_ParamTypes[i] == FP_FLOAT_BYREF)
+		{
+			//copy back
+			cell *tmp = physAddrs[i];
+			if (m_ParamTypes[i] == FP_CELL_BYREF)
+			{
+				memcpy(reinterpret_cast<cell *>(params[i]), tmp, sizeof(cell));
+			}
+			else
+			{
+				memcpy(reinterpret_cast<REAL *>(params[i]), tmp, sizeof(REAL));
+			}
+			amx_Release(m_Amx, realParams[i]);
+		}
 	}
 
+	m_InExec = false;
+
 	return retVal;
 }
 
 int CForwardMngr::registerForward(const char *funcName, ForwardExecType et, int numParams, const ForwardParam * paramTypes)
 {
-	int retVal = m_Forwards.size() << 1;
+	int retVal = m_Forwards.length() << 1;
 	CForward *tmp = new CForward(funcName, et, numParams, paramTypes);
+	
 	if (!tmp)
+	{
 		return -1;				// should be invalid
-	m_Forwards.push_back(tmp);
+	}
+	
+	m_Forwards.append(tmp);
+	
 	return retVal;
 }
 
@@ -297,105 +418,153 @@ int CForwardMngr::registerSPForward(int func, AMX *amx, int numParams, const For
 {
 	int retVal = -1;
 	CSPForward *pForward;
+	
 	if (!m_FreeSPForwards.empty())
 	{
 		retVal = m_FreeSPForwards.front();
 		pForward = m_SPForwards[retVal >> 1];
 		pForward->Set(func, amx, numParams, paramTypes);
+		
 		if (pForward->getFuncsNum() == 0)
 			return -1;
+		
 		m_FreeSPForwards.pop();
-	}
-	else
-	{
-		retVal = (m_SPForwards.size() << 1) | 1;
+	} else {
+		retVal = (m_SPForwards.length() << 1) | 1;
 		pForward = new CSPForward();
+		
 		if (!pForward)
 			return -1;
+		
 		pForward->Set(func, amx, numParams, paramTypes);
+		
 		if (pForward->getFuncsNum() == 0)
 		{
-			return -1;
 			delete pForward;
+			return -1;
 		}
 					 
-		m_SPForwards.push_back(pForward);
+		m_SPForwards.append(pForward);
 	}
+	
 	return retVal;
 }
 
 int CForwardMngr::registerSPForward(const char *funcName, AMX *amx, int numParams, const ForwardParam *paramTypes)
 {
-	int retVal = (m_SPForwards.size() << 1) | 1;
+	int retVal = (m_SPForwards.length() << 1) | 1;
 	CSPForward *pForward;
+	
 	if (!m_FreeSPForwards.empty())
 	{
 		retVal = m_FreeSPForwards.front();
-		pForward = m_SPForwards[retVal>>1];		// >>1 because unregisterSPForward pushes the id which contains the sp flag
+		pForward = m_SPForwards[retVal>>1];			// >>1 because unregisterSPForward pushes the id which contains the sp flag
 		pForward->Set(funcName, amx, numParams, paramTypes);
+		
 		if (pForward->getFuncsNum() == 0)
 			return -1;
+		
 		m_FreeSPForwards.pop();
-	}
-	else
-	{
+	} else {
 		pForward = new CSPForward();
+		
 		if (!pForward)
 			return -1;
+		
 		pForward->Set(funcName, amx, numParams, paramTypes);
+		
 		if (pForward->getFuncsNum() == 0)
 		{
 			delete pForward;
 			return -1;
 		}
-		m_SPForwards.push_back(pForward);
+		
+		m_SPForwards.append(pForward);
 	}
+	
 	return retVal;
 }
 
 bool CForwardMngr::isIdValid(int id) const
 {
-	return (id >= 0) && ((id & 1) ?
-		(static_cast<size_t>(id >> 1) < m_SPForwards.size()) :
-		(static_cast<size_t>(id >> 1) < m_Forwards.size()));
+	return (id >= 0) && ((id & 1) ? (static_cast<size_t>(id >> 1) < m_SPForwards.length()) : (static_cast<size_t>(id >> 1) < m_Forwards.length()));
 }
 
 cell CForwardMngr::executeForwards(int id, cell *params)
 {
-	int retVal = (id & 1) ? m_SPForwards[id >> 1]->execute(params, m_TmpArrays) : 
-		m_Forwards[id >> 1]->execute(params, m_TmpArrays);
+	int retVal;
+	if (id & 1)
+	{
+		CSPForward *fwd = m_SPForwards[id >> 1];
+		retVal = fwd->execute(params, m_TmpArrays);
+		if (fwd->m_ToDelete)
+		{
+			fwd->m_ToDelete = false;
+			unregisterSPForward(id);
+		}
+	} else {
+		retVal = m_Forwards[id >> 1]->execute(params, m_TmpArrays);
+	}
+
 	m_TmpArraysNum = 0;
+	
 	return retVal;
 }
 
+const char *CForwardMngr::getFuncName(int id) const
+{
+	if (!isIdValid(id))
+	{
+		return "";
+	}
+	return (id & 1) ? m_SPForwards[id >> 1]->getFuncName() : m_Forwards[id >> 1]->getFuncName();
+}
+
+int CForwardMngr::getFuncsNum(int id) const
+{
+	if (!isIdValid(id))
+	{
+		return 0;
+	}
+	return (id & 1) ? m_SPForwards[id >> 1]->getFuncsNum() : m_Forwards[id >> 1]->getFuncsNum();
+}
+
 int CForwardMngr::getParamsNum(int id) const
 {
-	return (id & 1) ? m_SPForwards[id >> 1]->getParamsNum() :
-		m_Forwards[id >> 1]->getParamsNum();
+	return (id & 1) ? m_SPForwards[id >> 1]->getParamsNum() : m_Forwards[id >> 1]->getParamsNum();
 }
 
 ForwardParam CForwardMngr::getParamType(int id, int paramNum) const
 {
-	return (id & 1) ? m_SPForwards[id >> 1]->getParamType(paramNum) :
-		m_Forwards[id >> 1]->getParamType(paramNum);
+	if (!isIdValid(id))
+	{
+		return FP_DONE;
+	}
+	return (id & 1) ? m_SPForwards[id >> 1]->getParamType(paramNum) : m_Forwards[id >> 1]->getParamType(paramNum);
 }
 
 void CForwardMngr::clear()
 {
-	for (ForwardVec::iterator iter = m_Forwards.begin(); iter != m_Forwards.end(); ++iter)
+	size_t i;
+
+	for (i = 0; i < m_Forwards.length(); ++i)
 	{
-		delete *iter;
+		delete m_Forwards[i];
 	}
-	SPForwardVec::iterator spIter;
-	for (spIter = m_SPForwards.begin(); spIter != m_SPForwards.end(); ++spIter)
+
+	for (i = 0; i < m_SPForwards.length(); ++i)
 	{
-		delete (*spIter);
+		delete m_SPForwards[i];
 	}
 
 	m_Forwards.clear();
 	m_SPForwards.clear();
+	
 	while (!m_FreeSPForwards.empty())
+	{
 		m_FreeSPForwards.pop();
+	}
+
 	m_TmpArraysNum = 0;
 }
 
@@ -407,74 +576,160 @@ bool CForwardMngr::isSPForward(int id) const
 void CForwardMngr::unregisterSPForward(int id)
 {
 	//make sure the id is valid
-	if ( !isIdValid(id) || m_SPForwards.at(id >> 1)->isFree )
+	if (!isIdValid(id) || m_SPForwards.at(id >> 1)->isFree)
+	{
 		return;
+	}
 
-	m_SPForwards.at(id >> 1)->isFree = true;
+	CSPForward *fwd = m_SPForwards.at(id >> 1);
 
-	m_FreeSPForwards.push(id);
+	if (fwd->m_InExec)
+	{
+		fwd->m_ToDelete = true;
+	} else {
+		fwd->isFree = true;
+		m_FreeSPForwards.push(id);
+	}
+}
+
+int CForwardMngr::duplicateSPForward(int id)
+{
+	if (!isIdValid(id) || m_SPForwards.at(id >> 1)->isFree)
+	{
+		return -1;
+	}
+
+	CSPForward *fwd = m_SPForwards.at(id >> 1);
+	
+	return registerSPForward(fwd->m_Func, fwd->m_Amx, fwd->m_NumParams, fwd->m_ParamTypes);
+}
+
+int CForwardMngr::isSameSPForward(int id1, int id2)
+{
+	if (!isIdValid(id1) || !isIdValid(id2))
+	{
+		return false;
+	}
+
+	CSPForward *fwd1 = m_SPForwards.at(id1 >> 1);
+	CSPForward *fwd2 = m_SPForwards.at(id2 >> 1);
+
+	if (fwd1->isFree || fwd2->isFree)
+	{
+		return false;
+	}
+
+	return ((fwd1->m_Amx == fwd2->m_Amx)
+			&& (fwd1->m_Func == fwd2->m_Func)
+			&& (fwd1->m_NumParams == fwd2->m_NumParams));
+}
+
+int registerForwardC(const char *funcName, ForwardExecType et, cell *list, size_t num)
+{
+	ForwardParam params[FORWARD_MAX_PARAMS];
+	
+	for (size_t i=0; i<num; i++)
+	{
+		params[i] = static_cast<ForwardParam>(list[i]);
+	}
+	
+	return g_forwards.registerForward(funcName, et, num, params);
 }
 
 int registerForward(const char *funcName, ForwardExecType et, ...)
 {
 	int curParam = 0;
+	
 	va_list argptr;
 	va_start(argptr, et);
+	
 	ForwardParam params[FORWARD_MAX_PARAMS];
 	ForwardParam tmp;
+	
 	while (true)
 	{
 		if (curParam == FORWARD_MAX_PARAMS)
 			break;
+		
 		tmp = (ForwardParam)va_arg(argptr, int);
+		
 		if (tmp == FP_DONE)
 			break;
+		
 		params[curParam] = tmp;
 		++curParam;
 	}
+	
 	va_end(argptr);
+	
 	return g_forwards.registerForward(funcName, et, curParam, params);
 }
 
+int registerSPForwardByNameC(AMX *amx, const char *funcName, cell *list, size_t num)
+{
+	ForwardParam params[FORWARD_MAX_PARAMS];
+	
+	for (size_t i=0; i<num; i++)
+		params[i] = static_cast<ForwardParam>(list[i]);
+
+	return g_forwards.registerSPForward(funcName, amx, num, params);
+}
+
 int registerSPForwardByName(AMX *amx, const char *funcName, ...)
 {
 	int curParam = 0;
+	
 	va_list argptr;
 	va_start(argptr, funcName);
+	
 	ForwardParam params[FORWARD_MAX_PARAMS];
 	ForwardParam tmp;
+	
 	while (true)
 	{
 		if (curParam == FORWARD_MAX_PARAMS)
 			break;
+		
 		tmp = (ForwardParam)va_arg(argptr, int);
+		
 		if (tmp == FP_DONE)
 			break;
+		
 		params[curParam] = tmp;
 		++curParam;
 	}
+	
 	va_end(argptr);
+	
 	return g_forwards.registerSPForward(funcName, amx, curParam, params);
 }
 
 int registerSPForward(AMX *amx, int func, ...)
 {
 	int curParam = 0;
+	
 	va_list argptr;
 	va_start(argptr, func);
+	
 	ForwardParam params[FORWARD_MAX_PARAMS];
 	ForwardParam tmp;
+	
 	while (true)
 	{
 		if (curParam == FORWARD_MAX_PARAMS)
 			break;
+		
 		tmp = (ForwardParam)va_arg(argptr, int);
+		
 		if (tmp == FP_DONE)
 			break;
+		
 		params[curParam] = tmp;
 		++curParam;
 	}
+	
 	va_end(argptr);
+	
 	return g_forwards.registerSPForward(func, amx, curParam, params);
 }
 
@@ -484,28 +739,60 @@ cell executeForwards(int id, ...)
 		return -1;
 
 	cell params[FORWARD_MAX_PARAMS];
+	
 	int paramsNum = g_forwards.getParamsNum(id);
+	
 	va_list argptr;
 	va_start(argptr, id);
+
+	ForwardParam param_type;
+	
 	for (int i = 0; i < paramsNum && i < FORWARD_MAX_PARAMS; ++i)
 	{
-		if (g_forwards.getParamType(id, i) == FP_FLOAT)
+		param_type = g_forwards.getParamType(id, i);
+		if (param_type == FP_FLOAT)
 		{
 			REAL tmp = (REAL)va_arg(argptr, double);			// floats get converted to doubles
-			params[i] = *(cell*)&tmp;
+			params[i] = amx_ftoc(tmp);
 		}
-		params[i] = (cell)va_arg(argptr, cell);
+		else if(param_type == FP_FLOAT_BYREF)
+		{
+			REAL *tmp = reinterpret_cast<REAL *>(va_arg(argptr, double*));
+			params[i] = reinterpret_cast<cell>(tmp);
+		}
+		else if(param_type == FP_CELL_BYREF)
+		{
+			cell *tmp = reinterpret_cast<cell *>(va_arg(argptr, cell*));
+			params[i] = reinterpret_cast<cell>(tmp);
+		}
+		else
+			params[i] = (cell)va_arg(argptr, cell);
 	}
+	
 	va_end(argptr);
+	
 	return g_forwards.executeForwards(id, params);
 }
 
 cell CForwardMngr::prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type, bool copyBack)
 {
+	if (m_TmpArraysNum >= FORWARD_MAX_PARAMS)
+	{
+#ifdef MEMORY_TEST
+		m_validateAllAllocUnits();
+#endif // MEMORY_TEST
+		
+		AMXXLOG_Log("[AMXX] Forwards with more than 32 parameters are not supported (tried to prepare array # %d).", m_TmpArraysNum + 1);
+		m_TmpArraysNum = 0;
+		
+		return -1;
+	}
+	
 	m_TmpArrays[m_TmpArraysNum].ptr = ptr;
 	m_TmpArrays[m_TmpArraysNum].size = size;
 	m_TmpArrays[m_TmpArraysNum].type = type;
 	m_TmpArrays[m_TmpArraysNum].copyBack = copyBack;
+
 	return m_TmpArraysNum++;
 }
 

amxmodx/CForward.h

@@ -1,33 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 /*
 	CForward.h
@@ -46,7 +24,10 @@
 #ifndef FORWARD_H
 #define FORWARD_H
 
-const int FORWARD_MAX_PARAMS = 16;
+#include <stdarg.h>
+#include "sh_stack.h"
+
+const int FORWARD_MAX_PARAMS = 32;
 
 enum ForwardExecType
 {
@@ -65,6 +46,8 @@ enum ForwardParam
 	FP_STRING,						// string
 	FP_STRINGEX,					// string; will be updated to the last function's value
 	FP_ARRAY,						// array; use the return value of prepareArray.
+	FP_CELL_BYREF,                  // cell; pass by reference
+	FP_FLOAT_BYREF,                 // float; pass by reference
 };
 
 // for prepareArray
@@ -77,7 +60,9 @@ enum ForwardArrayElemType
 struct ForwardPreparedArray
 {
 	void *ptr;
+	
 	ForwardArrayElemType type;
+	
 	unsigned int size;
 	bool copyBack;
 };
@@ -88,31 +73,45 @@ class CForward
 	const char *m_FuncName;
 	ForwardExecType m_ExecType;
 	int m_NumParams;
+	ke::AString m_Name;
+	
 	struct AMXForward
 	{
 		CPluginMngr::CPlugin *pPlugin;
 		int func;
 	};
-	typedef CVector<AMXForward> AMXForwardList;
+	
+	typedef ke::Vector<AMXForward> AMXForwardList;
+	
 	AMXForwardList m_Funcs;
 	ForwardParam m_ParamTypes[FORWARD_MAX_PARAMS];
+
 public:
 	CForward(const char *name, ForwardExecType et, int numParams, const ForwardParam * paramTypes);
-	CForward()
-	{ }			// leaves everything unitialized'
+	CForward() {}		// leaves everything unitialized'
+	
 	cell execute(cell *params, ForwardPreparedArray *preparedArrays);
+	
 	int getParamsNum() const
 	{
 		return m_NumParams;
 	}
+	
 	int getFuncsNum() const
 	{
-		return m_Funcs.size();
+		return m_Funcs.length();
 	}
+
+	const char *getFuncName() const
+	{
+		return m_Name.chars();
+	}
+	
 	ForwardParam getParamType(int paramId) const
 	{
 		if (paramId < 0 || paramId >= m_NumParams)
 			return FP_DONE;
+		
 		return m_ParamTypes[paramId];
 	}
 };
@@ -120,12 +119,18 @@ public:
 // Single plugin forward
 class CSPForward
 {
-	const char *m_FuncName;
+	friend class CForwardMngr;
 	int m_NumParams;
+	
 	ForwardParam m_ParamTypes[FORWARD_MAX_PARAMS];
 	AMX *m_Amx;
+	
 	int m_Func;
 	bool m_HasFunc;
+	ke::AString m_Name;
+	bool m_InExec;
+	bool m_ToDelete;
+
 public:
 	bool isFree;
 public:
@@ -134,41 +139,49 @@ public:
 	void Set(int func, AMX *amx, int numParams, const ForwardParam * paramTypes);
 
 	cell execute(cell *params, ForwardPreparedArray *preparedArrays);
+	
 	int getParamsNum() const
 	{
 		return m_NumParams;
 	}
+	
 	int getFuncsNum() const
 	{
 		return (m_HasFunc) ? 1 : 0;
 	}
+
+	const char *getFuncName() const
+	{
+		return m_Name.chars();
+	}
+	
 	ForwardParam getParamType(int paramId) const
 	{
 		if (paramId < 0 || paramId >= m_NumParams)
 			return FP_DONE;
+		
 		return m_ParamTypes[paramId];
 	}
 };
 
 class CForwardMngr
 {
-	typedef CVector<CForward*> ForwardVec;
-	typedef CVector<CSPForward*> SPForwardVec;
-	typedef CQueue<int> FreeSPVec;					// Free SP Forwards
+	typedef ke::Vector<CForward*> ForwardVec;
+	typedef ke::Vector<CSPForward*> SPForwardVec;
+	typedef CStack<int> FreeSPVec;							// Free SP Forwards
 
 	ForwardVec m_Forwards;
 
 	SPForwardVec m_SPForwards;
 	FreeSPVec m_FreeSPForwards;								// so we don't have to free memory
 
-	ForwardPreparedArray m_TmpArrays[FORWARD_MAX_PARAMS];		// used by prepareArray
+	ForwardPreparedArray m_TmpArrays[FORWARD_MAX_PARAMS];	// used by prepareArray
 	int m_TmpArraysNum;
 public:
 
 	CForwardMngr()
 	{ m_TmpArraysNum = 0; }
-	~CForwardMngr()
-	{ }
+	~CForwardMngr() {}
 
 	// Interface
 	// Register normal forward
@@ -176,23 +189,31 @@ public:
 	// Register single plugin forward
 	int registerSPForward(const char *funcName, AMX *amx, int numParams, const ForwardParam * paramTypes);
 	int registerSPForward(int func, AMX *amx, int numParams, const ForwardParam * paramTypes);
+	
 	// Unregister single plugin forward
 	void unregisterSPForward(int id);
+	int duplicateSPForward(int id);
+	int isSameSPForward(int id1, int id2);
+	
 	// execute forward
 	cell executeForwards(int id, cell *params);
-	void clear();		// delete all forwards
+	void clear();							// delete all forwards
+	
 	bool isIdValid(int id) const;			// check whether forward id is valid
 	bool isSPForward(int id) const;			// check whether forward is single plugin
 	int getParamsNum(int id) const;			// get num of params of a forward
 	int getFuncsNum(int id) const;			// get num of found functions of a forward
+	const char *getFuncName(int id) const;	// get the function name
+	
 	ForwardParam getParamType(int id, int paramId) const;
-	cell prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type,
-		bool copyBack);		// prepare array
+	cell prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type, bool copyBack);		// prepare array
 };
 
 // (un)register forward
 int registerForward(const char *funcName, ForwardExecType et, ...);
+int registerForwardC(const char *funcName, ForwardExecType et, cell *list, size_t num);
 int registerSPForwardByName(AMX *amx, const char *funcName, ...);
+int registerSPForwardByNameC(AMX *amx, const char *funcName, cell *list, size_t num);
 int registerSPForward(AMX *amx, int func, ...);
 void unregisterSPForward(int id);
 
@@ -202,5 +223,4 @@ cell executeForwards(int id, ...);
 cell prepareCellArray(cell *ptr, unsigned int size, bool copyBack = false);
 cell prepareCharArray(char *ptr, unsigned int size, bool copyBack = false);
 
-#endif
-
+#endif //FORWARD_H

amxmodx/CFrameAction.h

@@ -0,0 +1,61 @@
+#ifndef FRAMEACTION_H
+#define FRAMEACTION_H
+
+#include "amxmodx.h"
+#include <amtl/am-deque.h>
+#include <amtl/am-autoptr.h>
+
+class CFrameActionMngr
+{
+public:
+
+	class CFrameAction
+	{
+	public:
+		CFrameAction(int callbackForward, cell callbackData) :
+			m_callbackForward(callbackForward),
+			m_callbackData(callbackData)
+		{
+
+		}
+
+		~CFrameAction()
+		{
+			unregisterSPForward(m_callbackForward);
+		}
+
+		void Execute()
+		{
+			executeForwards(m_callbackForward, m_callbackData);
+		}
+
+	public:
+		int m_callbackForward;
+		cell m_callbackData;
+	};
+
+public:
+
+	void AddFrameAction(int callbackForward, cell callbackData)
+	{
+		m_requestedFrames.append(new CFrameAction(callbackForward, callbackData));
+	}
+
+	void ExecuteFrameCallbacks()
+	{
+		// In case a frame callback requests another frame, newly added frames won't be executed this way
+		int callbacksToRun = m_requestedFrames.length();
+		while (callbacksToRun--)
+		{
+			ke::AutoPtr<CFrameAction> action = ke::Move(m_requestedFrames.front());
+			m_requestedFrames.popFront();
+			action->Execute();
+		}
+	}
+
+private:
+	ke::Deque<ke::AutoPtr<CFrameAction>> m_requestedFrames;
+
+};
+
+#endif // FRAMEACTION_H

amxmodx/CGameConfigs.h

@@ -0,0 +1,198 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef _INCLUDE_GAMECONFIG_H_
+#define _INCLUDE_GAMECONFIG_H_
+
+#include <IGameConfigs.h>
+#include "CLibrarySys.h"
+#include <amtl/am-autoptr.h>
+#include <amtl/am-vector.h>
+#include <amtl/am-string.h>
+#include <amtl/am-refcounting.h>
+#include <sm_stringhashmap.h>
+#include <sm_namehashset.h>
+
+class CGameConfig 
+	:
+	public ITextListener_SMC,
+	public IGameConfig,
+	public ke::Refcounted <CGameConfig>
+{
+	friend class CGameConfigManager;
+
+	public:
+
+		CGameConfig(const char *file);
+		~CGameConfig();
+
+	public:
+
+		bool Reparse(char *error, size_t maxlength);
+		bool EnterFile(const char *file, char *error, size_t maxlength);
+
+	public: // ITextListener_SMC
+
+		SMCResult ReadSMC_NewSection(const SMCStates *states, const char *name);
+		SMCResult ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value);
+		SMCResult ReadSMC_LeavingSection(const SMCStates *states);
+
+	public: // IGameConfig
+
+		const char* GetKeyValue(const char *key);
+		bool        GetOffset(const char *key, TypeDescription *value);
+		bool        GetOffsetByClass(const char *classname, const char *key, TypeDescription *value);
+		bool        GetMemSig(const char *key, void **addr);
+		bool        GetAddress(const char *key, void **addr);
+
+	public: // NameHashSet
+
+		static inline bool matches(const char *key, const CGameConfig *value)
+		{
+			return strcmp(key, value->m_File) == 0;
+		}
+
+	private:
+
+		struct OffsetClass
+		{
+			StringHashMap<TypeDescription> list;
+		};
+
+		typedef StringHashMap<ke::AutoPtr<OffsetClass>> OffsetClassMap;
+		typedef StringHashMap<TypeDescription> OffsetMap;
+
+		char                       m_File[PLATFORM_MAX_PATH];
+		char                       m_CurrentPath[PLATFORM_MAX_PATH];
+
+		OffsetMap                  m_Offsets;
+		OffsetClassMap             m_OffsetsByClass;
+		StringHashMap<ke::AString> m_Keys;
+		StringHashMap<void*>       m_Sigs;
+
+		int                        m_ParseState;
+		unsigned int               m_IgnoreLevel;
+
+		char                       m_Class[64];
+		char                       m_Offset[64];
+		char                       m_Game[256];
+
+		bool                       m_FoundOffset;
+		bool                       m_MatchedClasses;
+		bool                       m_ShouldBeReadingDefault;
+		bool                       m_HadGame;
+		bool                       m_MatchedGame;
+		bool                       m_HadEngine;
+		bool                       m_MatchedEngine;
+		bool                       m_MatchedPlatform;
+
+		unsigned int               m_CustomLevel;
+		ITextListener_SMC*         m_CustomHandler;
+
+		struct AddressConf
+		{
+			char    m_SignatureName[64];
+			size_t  m_ReadCount;
+			int     m_ReadBytes[8];
+
+			AddressConf(const char *sigName, size_t sigLength, size_t readCount, int *read);
+			AddressConf() {}
+		};
+
+		char m_Address[64];
+		char m_AddressSignature[64];
+		int  m_AddressReadCount;
+		int  m_AddressRead[8];
+		StringHashMap<AddressConf> m_Addresses;
+
+		char m_pEngine[64];
+};
+
+class CGameMasterReader : public ITextListener_SMC
+{
+	public:
+
+		void ReadSMC_ParseStart();
+
+		SMCResult ReadSMC_NewSection(const SMCStates *states, const char *name);
+		SMCResult ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value);
+		SMCResult ReadSMC_LeavingSection(const SMCStates *states);
+
+	public:
+
+		ke::Vector<ke::AString>* m_FileList;
+
+		unsigned int m_State;
+		unsigned int m_IgnoreLevel;
+
+		char         m_CurrentPath[PLATFORM_MAX_PATH];
+
+		bool         m_HadEngine;
+		bool         m_MatchedEngine;
+		bool         m_HadGame;
+		bool         m_MatchedGame;
+};
+
+class CGameConfigManager : public IGameConfigManager
+{
+	public:
+
+		CGameConfigManager();
+		~CGameConfigManager();
+
+	public: // IGameConfigManager
+
+		bool LoadGameConfigFile(const char *file, IGameConfig **pConfig, char *error, size_t maxlength);
+		void CloseGameConfigFile(IGameConfig *cfg);
+		void AddUserConfigHook(const char *sectionname, ITextListener_SMC *listener);
+		void RemoveUserConfigHook(const char *sectionname, ITextListener_SMC *listener);
+
+	public:
+
+		void OnAmxxStartup();
+		void RemoveCachedConfig(CGameConfig *config);
+
+	private:
+
+		NameHashSet<CGameConfig*> m_Lookup;
+
+	public:
+
+		StringHashMap<ITextListener_SMC*> m_customHandlers;
+};
+
+#define GET_OFFSET(classname, member)												\
+	static int member = -1;															\
+	if (member == -1)																\
+	{                                                                               \
+		TypeDescription type;                                                       \
+		if (!CommonConfig->GetOffsetByClass(classname, #member, &type) || type.fieldOffset < 0)\
+		{																			\
+			LogError(amx, AMX_ERR_NATIVE, "Invalid %s offset. Native %s is disabled", #member, __FUNCTION__);\
+			return 0;																\
+		}																			\
+		member = type.fieldOffset;                                                  \
+	}
+
+#define GET_OFFSET_NO_ERROR(classname, member)                                      \
+	static int member = -1;                                                         \
+	if (member == -1)                                                               \
+	{                                                                               \
+		TypeDescription type;                                                       \
+		if (!CommonConfig->GetOffsetByClass(classname, #member, &type) || type.fieldOffset < 0)\
+		{                                                                           \
+			return;                                                                 \
+		}                                                                           \
+		member = type.fieldOffset;                                                  \
+	}
+
+extern CGameConfigManager ConfigManager;
+extern IGameConfig *CommonConfig;
+
+#endif // _INCLUDE_GAMECONFIG_H_

amxmodx/CLang.h

@@ -1,61 +1,64 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef _INCLUDE_CLANG_H
 #define _INCLUDE_CLANG_H
 
+#include "sh_tinyhash.h"
+#include "sm_stringhashmap.h"
+#include <ITextParsers.h>
+
 #define LANG_SERVER 0
 #define LANG_PLAYER -1
 
-struct md5Pair
-{
-	String file;
-	String val;
-};
-
-struct keyEntry
-{
-	String key;
-	uint32_t hash;
-};
+#define ERR_BADKEY	1	// Lang key not found
+#define ERR_BADLANG 2	// Invalid lang
 
 struct sKeyDef
 {
-	sKeyDef() { key = -1; def = 0; }
-	~sKeyDef() { if (def) delete def; }
+	ke::AutoString* definition;
 	int key;
-	String *def;
 };
 
-class CLangMngr
+struct lang_err
+{
+	lang_err() : last(0.0f)
+	{
+	};
+	float last;
+};
+
+class defentry
+{
+public:
+	defentry() : definition(NULL)
+	{
+	};
+	defentry(const defentry &src)
+	{
+		definition = src.definition;
+	}
+	~defentry()
+	{
+	}
+	ke::AString *definition;
+};
+
+struct keytbl_val
+{
+	keytbl_val() : index(-1)
+	{
+	};
+	int index;
+};
+
+class CLangMngr : public ITextListener_INI
 {
 	class CLang
 	{
@@ -68,92 +71,57 @@ class CLangMngr
 		~CLang();
 
 		// Get the definition
-		const char *GetDef(const char *key);
+		const char *GetDef(int key, int &status);
 		// Add definitions to this language
-		void MergeDefinitions(CQueue <sKeyDef*> & vec);
+		void MergeDefinitions(ke::Vector <sKeyDef> & vec);
 		// Reset this language
 		void Clear();
 
 		// compare this language to a language name
 		friend bool operator == (const CLang &left, const char *right)
 		{
-			return strcmp(left.m_LanguageName, right)==0 ? true : false;
+			return strcmp(left.m_LanguageName, right) == 0 ? true : false;
 		}
+		
 		// Get language name
 		const char *GetName() { return m_LanguageName; }
-		// Save to file
-		bool Save(FILE *fp, int &defOffset, uint32_t &curOffset);
-		bool SaveDefinitions(FILE *fp, uint32_t &curOffset);
-		// Load
-		bool Load(FILE *fp);
 		void SetMngr(CLangMngr *l) { m_LMan = l; }
 		// Get number of entries
-		int Entries() { return m_LookUpTable.size(); }
-		// Make a hash from a string; convert to lowercase first if needed
-		static uint32_t MakeHash(const char *src, bool makeLower = false);
+		int Entries();
 	protected:
-
-		// An entry in the language
-		class LangEntry
-		{
-			// the definition hash
-			uint32_t m_DefHash;
-			// index into the lookup table?
-			int key;
-			// the definition
-			String m_pDef;
-			// is this from the cache or not?
-			bool m_isCache;
-		public:
-			// Set
-			void SetKey(int key);
-			void SetDef(const char *pDef);
-			void SetCache(bool c);
-			// Get
-			uint32_t GetDefHash();
-			int GetKey();
-			const char *GetDef();
-			int GetDefLength();
-			bool GetCache();
-
-			// Constructors / destructors
-			LangEntry();
-			LangEntry(int key);
-			LangEntry(int key, const char *pDef);
-			LangEntry(const LangEntry &other);
-			LangEntry(int pKey, uint32_t defHash, const char *pDef);
-
-			// Reset
-			void Clear();
-		};
-
-		// Get (construct if needed) an entry
-		LangEntry * GetEntry(int key);
-
-		typedef CVector<LangEntry*>	LookUpVec;
-		typedef LookUpVec::iterator	LookUpVecIter;
+		typedef THash<int, defentry> LookUpVec;
+		typedef LookUpVec::iterator	 LookUpVecIter;
 
 		char m_LanguageName[3];
 
 		// our lookup table
 		LookUpVec m_LookUpTable;
+		int m_entries;
 		CLangMngr *m_LMan;
 	public:
-		LangEntry *AddEntry(int pKey, uint32_t defHash, const char *def, bool cache);
+		void AddEntry(int key, const char *definition);
 	};
-
+public:
 	// Merge definitions into a language
-	void MergeDefinitions(const char *lang, CQueue <sKeyDef*> &tmpVec);
-	// strip lowercase; make lower if needed
-	static size_t strip(char *str, char *newstr, bool makelower=false);
+	void MergeDefinitions(const char *lang, ke::Vector <sKeyDef> &tmpVec);
 
-	typedef CVector<CLang*> LangVec;
-	typedef CVector<CLang*>::iterator LangVecIter;
+public: // ITextListener_INI
+	void ReadINI_ParseStart();
+	void ReadINI_ParseEnd(bool halted);
+	bool ReadINI_NewSection(const char *section, bool invalid_tokens, bool close_bracket, bool extra_tokens, unsigned int *curtok);
+	bool ReadINI_KeyValue(const char *key, const char *value, bool invalid_tokens, bool equal_token, bool quotes, unsigned int *curtok);
+
+private:
+	// strip lowercase; make lower if needed
+	static size_t strip(char *str, char *newstr, bool makelower = false);
+
+	typedef ke::Vector<CLang*> LangVec;
 	
 	LangVec m_Languages;
 
-	CVector<md5Pair *> FileList;
-	CVector<keyEntry*> KeyList;
+	StringHashMap<time_t> FileList;
+	ke::Vector<ke::AString *> KeyList;
+	THash<ke::AString, keytbl_val> KeyTable;
 
 	// Get a lang object (construct if needed)
 	CLang * GetLang(const char *name);
@@ -165,30 +133,19 @@ class CLangMngr
 public:
 	// Merge a definitions file
 	int MergeDefinitionFile(const char *file);
-	// Get a definition from a lang name and a kyer
-	const char *GetDef(const char *langName, const char *key);
-	// Format a string
-	const char *Format(const char *src, ...);
+	// Get a definition from a lang name and a key
+	const char *GetDef(const char *langName, const char *key, int &status);
 	// Format a string for an AMX plugin
 	char *FormatAmxString(AMX *amx, cell *params, int parm, int &len);
-	char *FormatString(const char *fmt, va_list &ap);
-	// Save
-	bool Save(const char *filename);
-	// Load
-	bool Load(const char *filename);
-	// Cache
-	bool LoadCache(const char *filename);
-	bool SaveCache(const char *filename);
+	void InvalidateCache();
 	// Get index
-	int GetKeyEntry(String &key);
+	int GetKeyEntry(ke::AString &key);
 	int GetKeyEntry(const char *key);
-	int GetKeyHash(int key);
 	// Get key from index
 	const char *GetKey(int key);
 	// Add key
-	int AddKeyEntry(String &key);
-	// Make a hash from a string; convert to lowercase first if needed
-	uint32_t MakeHash(const char *src, bool makeLower);
+	int AddKeyEntry(ke::AString &key);
+	int AddKeyEntry(const char *key);
 
 	// Get the number of languages
 	int GetLangsNum();
@@ -200,6 +157,8 @@ public:
 	// When a language id in a format string in FormatAmxString is LANG_PLAYER, the glob id decides which language to take.
 	void SetDefLang(int id);
 
+	inline int GetDefLang() const { return m_CurGlobId; }
+
 	// Reset
 	void Clear();
 

amxmodx/CLibrarySys.cpp

@@ -0,0 +1,388 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "CLibrarySys.h"
+#include <amxmodx.h>
+#include <amtl/os/am-fsutil.h>
+#include <amtl/os/am-path.h>
+#include <amtl/os/am-system-errors.h>
+
+LibrarySystem g_LibSys;
+
+/******************/
+/* Directory Code */
+/******************/
+
+CDirectory::CDirectory(const char *path)
+{
+#if defined PLATFORM_WINDOWS
+
+	char newpath[PLATFORM_MAX_PATH];
+	ke::SafeSprintf(newpath, sizeof(newpath), "%s\\*.*", path);
+
+	m_dir = FindFirstFile(newpath, &m_fd);
+
+	if (!IsValid())
+	{
+		m_fd.cFileName[0] = '\0';
+	}
+
+#elif defined PLATFORM_POSIX
+
+	m_dir = opendir(path);
+
+	if (IsValid())
+	{
+		m_ep = readdir(m_dir); // TODO: we need to read past "." and ".."!
+		ke::SafeSprintf(m_origpath, sizeof(m_origpath), "%s", path);
+	}
+	else
+	{
+		m_ep = nullptr;
+	}
+#endif
+}
+
+CDirectory::~CDirectory()
+{
+	if (IsValid())
+	{
+#if defined PLATFORM_WINDOWS
+
+		FindClose(m_dir);
+
+#elif defined PLATFORM_POSIX
+
+		closedir(m_dir);
+#endif
+	}
+}
+
+DirHandle CDirectory::GetHandle()
+{
+	return m_dir;
+}
+
+void CDirectory::NextEntry()
+{
+#if defined PLATFORM_WINDOWS
+
+	if (FindNextFile(m_dir, &m_fd) == 0)
+	{
+		FindClose(m_dir);
+		m_dir = INVALID_HANDLE_VALUE;
+	}
+
+#elif defined PLATFORM_POSIX
+
+	if (!(m_ep = readdir(m_dir)))
+	{
+		closedir(m_dir);
+		m_dir = nullptr;
+	}
+#endif
+}
+
+bool CDirectory::IsEntryValid()
+{
+	return IsValid();
+}
+
+bool CDirectory::IsEntryDirectory()
+{
+#if defined PLATFORM_WINDOWS
+
+	return ((m_fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
+
+#elif defined PLATFORM_POSIX
+
+	char temppath[PLATFORM_MAX_PATH];
+	ke::SafeSprintf(temppath, sizeof(temppath), "%s/%s", m_origpath, GetEntryName());
+
+	return ke::file::IsDirectory(temppath);
+
+#endif
+}
+
+bool CDirectory::IsEntryFile()
+{
+#if defined PLATFORM_WINDOWS
+
+	return !(m_fd.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE));
+
+#elif defined PLATFORM_POSIX
+
+	char temppath[PLATFORM_MAX_PATH];
+	ke::SafeSprintf(temppath, sizeof(temppath), "%s/%s", m_origpath, GetEntryName());
+
+	return ke::file::IsFile(temppath);
+
+#endif
+}
+
+const char* CDirectory::GetEntryName()
+{
+#if defined PLATFORM_WINDOWS
+
+	return m_fd.cFileName;
+
+#elif defined PLATFORM_POSIX
+
+	return m_ep ? m_ep->d_name : "";
+
+#endif
+}
+
+bool CDirectory::MoreFiles()
+{
+	return IsValid();
+}
+
+bool CDirectory::IsValid()
+{
+#if defined PLATFORM_WINDOWS
+
+	return (m_dir != INVALID_HANDLE_VALUE);
+
+#elif defined PLATFORM_POSIX
+
+	return (m_dir != nullptr);
+#endif
+}
+
+
+/****************/
+/* Library Code */
+/****************/
+
+CLibrary::CLibrary(ke::RefPtr<ke::SharedLib> lib) : lib_(lib)
+{}
+
+void CLibrary::CloseLibrary()
+{
+	delete this;
+}
+
+void *CLibrary::GetSymbolAddress(const char* symname)
+{
+	return lib_->lookup(symname);
+}
+
+
+/***********************/
+/* Library System Code */
+/***********************/
+
+bool LibrarySystem::PathExists(const char *path)
+{
+	return ke::file::PathExists(path);
+}
+
+bool LibrarySystem::IsPathFile(const char* path)
+{
+	return ke::file::IsFile(path);
+}
+
+bool LibrarySystem::IsPathDirectory(const char* path)
+{
+	return ke::file::IsDirectory(path);
+}
+
+CDirectory *LibrarySystem::OpenDirectory(const char* path)
+{
+	CDirectory* dir = new CDirectory(path);
+
+	if (!dir->IsValid())
+	{
+		delete dir;
+		return nullptr;
+	}
+
+	return dir;
+}
+
+CLibrary* LibrarySystem::OpenLibrary(const char* path, char* error, size_t maxlength)
+{
+	ke::RefPtr<ke::SharedLib> lib = ke::SharedLib::Open(path, error, maxlength);
+
+	if (!lib)
+	{
+		return nullptr;
+	}
+
+	return new CLibrary(lib);
+}
+
+void LibrarySystem::GetPlatformError(char* error, size_t maxlength)
+{
+#if defined PLATFORM_WINDOWS
+
+	return GetPlatformErrorEx(GetLastError(), error, maxlength);
+
+#elif defined PLATFORM_POSIX
+
+	return GetPlatformErrorEx(errno, error, maxlength);
+#endif
+}
+
+void LibrarySystem::GetPlatformErrorEx(int code, char* error, size_t maxlength)
+{
+	if (error && maxlength)
+	{
+		ke::FormatSystemErrorCode(code, error, maxlength);
+	}
+}
+
+void LibrarySystem::GetLoaderError(char* buffer, size_t maxlength)
+{
+	ke::FormatSystemError(buffer, maxlength);
+}
+
+void LibrarySystem::CloseDirectory(CDirectory *dir)
+{
+	delete dir;
+}
+
+size_t LibrarySystem::PathFormat(char* buffer, size_t len, const char* fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	size_t mylen = ke::path::FormatVa(buffer, len, fmt, ap);
+	va_end(ap);
+
+	return mylen;
+}
+
+char* LibrarySystem::PathFormat(const char* fmt, ...)
+{
+	static char buffer[PLATFORM_MAX_PATH];
+
+	va_list ap;
+	va_start(ap, fmt);
+	ke::path::FormatVa(buffer, sizeof(buffer), fmt, ap);
+	va_end(ap);
+
+	return buffer;
+}
+
+const char* LibrarySystem::GetFileExtension(const char* filename)
+{
+	size_t len, end;
+
+	len = strlen(filename);
+
+	/* Minimum string length for filename with ext would be 3; example: a.a */
+	if (len < 3)
+	{
+		return nullptr;
+	}
+
+	end = len - 1;
+
+	for (size_t i = end; i <= end; i--)
+	{
+		if (filename[i] == PLATFORM_SEP_CHAR || filename[i] == PLATFORM_SEP_ALTCHAR)
+		{
+			break;
+		}
+
+		if (filename[i] == '.' && i != end && i != 0)
+		{
+			return &filename[++i];
+		}
+	}
+
+	return nullptr;
+}
+
+bool LibrarySystem::CreateFolder(const char* path)
+{
+	return ke::file::CreateDirectory(path, 0775);
+}
+
+size_t LibrarySystem::GetFileFromPath(char* buffer, size_t maxlength, const char* path)
+{
+	size_t length = strlen(path);
+
+	for (size_t i = length - 1; i <= length - 1; i--)
+	{
+		if (path[i] == '/'
+#if defined PLATFORM_WINDOWS
+			|| path[i] == '\\'
+#endif
+			)
+		{
+			return ke::SafeSprintf(buffer, maxlength, "%s", &path[i + 1]);
+		}
+	}
+
+	/* We scanned and found no path separator */
+	return ke::SafeSprintf(buffer, maxlength, "%s", path);
+}
+
+bool LibrarySystem::FileTime(const char* path, FileTimeType type, time_t* pTime)
+{
+	struct stat s;
+
+	if (stat(path, &s) != 0)
+	{
+		return false;
+	}
+
+	switch (type)
+	{
+		case FileTime_LastAccess:
+		{
+			*pTime = s.st_atime;
+			break;
+		}
+		case FileTime_Created:
+		{
+			*pTime = s.st_ctime;
+			break;
+		}
+		case FileTime_LastChange:
+		{
+			*pTime = s.st_mtime;
+			break;
+		}
+		default:
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool LibrarySystem::DoesPlatformMatch(const char *platform)
+{
+	return strcmp(platform, PLATFORM_NAME) == 0;
+}
+
+bool LibrarySystem::IsPlatformCompatible(const char *platform, bool *hadPrimaryMatch)
+{
+	if (DoesPlatformMatch(platform))
+	{
+#if defined PLATFORM_COMPAT_ALT
+		*hadPrimaryMatch = true;
+#endif
+		return true;
+	}
+
+#if defined PLATFORM_COMPAT_ALT
+	/* If entry hasn't been found for the primary platform name, check for compatible alternate */
+	if (!*hadPrimaryMatch)
+	{
+		return strcmp(platform, PLATFORM_COMPAT_ALT) == 0;
+	}
+#endif
+
+	return false;
+}

amxmodx/CLibrarySys.h

@@ -0,0 +1,107 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef _INCLUDE_LIBRARY_SYS_H_
+#define _INCLUDE_LIBRARY_SYS_H_
+
+#include "amx.h"        // cell
+#include <platform_helpers.h>
+#include <amtl/os/am-shared-library.h>
+
+enum FileTimeType
+{
+	FileTime_LastAccess = 0,  /* Last access (not available on FAT) */
+	FileTime_Created    = 1,  /* Creation (not available on FAT) */
+	FileTime_LastChange = 2,  /* Last modification */
+};
+
+class CDirectory
+{
+	public:
+
+		CDirectory(const char* path);
+		~CDirectory();
+
+	public:
+
+		bool MoreFiles();
+		void NextEntry();
+		const char* GetEntryName();
+		bool IsEntryDirectory();
+		bool IsEntryFile();
+		bool IsEntryValid();
+
+	public:
+
+		bool IsValid();
+		DirHandle GetHandle();
+
+	private:
+
+#if defined PLATFORM_WINDOWS
+
+		HANDLE           m_dir;
+		WIN32_FIND_DATAA m_fd;
+
+#elif defined PLATFORM_POSIX
+
+		DIR*             m_dir;
+		struct dirent*   m_ep;
+		char             m_origpath[PLATFORM_MAX_PATH];
+#endif
+};
+
+class CLibrary
+{
+	public:
+
+		CLibrary(ke::RefPtr<ke::SharedLib> lib);
+
+	public:
+
+		void CloseLibrary();
+		void *GetSymbolAddress(const char* symname);
+
+	private:
+
+		ke::RefPtr<ke::SharedLib> lib_;
+};
+
+class LibrarySystem
+{
+	public:
+
+		CLibrary* OpenLibrary(const char* path, char* error = nullptr, size_t maxlength = 0);
+		CDirectory* OpenDirectory(const char* path);
+		void CloseDirectory(CDirectory *dir);
+
+		bool PathExists(const char* path);
+		bool IsPathFile(const char* path);
+		bool IsPathDirectory(const char* path);
+
+		void GetPlatformError(char* error, size_t maxlength);
+		void GetPlatformErrorEx(int code, char* error, size_t maxlength);
+
+		size_t PathFormat(char* buffer, size_t len, const char* fmt, ...);
+		char*  PathFormat(const char* fmt, ...);
+
+		const char* GetFileExtension(const char* filename);
+		bool CreateFolder(const char* path);
+		size_t GetFileFromPath(char* buffer, size_t maxlength, const char* path);
+
+		bool FileTime(const char* path, FileTimeType type, time_t* pTime);
+		void GetLoaderError(char* buffer, size_t maxlength);
+
+		bool DoesPlatformMatch(const char* platform);
+		bool IsPlatformCompatible(const char *platform, bool *hadPrimaryMatch);
+};
+
+extern LibrarySystem g_LibSys;
+
+#endif // _INCLUDE_LIBRARY_SYS_H_

amxmodx/CList.h

@@ -1,313 +0,0 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
-
-#ifndef CLIST_H
-#define CLIST_H
-
-// *****************************************************
-// class CList
-// *****************************************************
-// Linked list
-template <typename T, typename F = char* >
-class CList
-{
-private:
-	// One list element
-	class CElement
-	{
-		T *m_pObject;						// pointer to the object
-		CElement *m_pNext;					// pointer to the next element
-		CElement *m_pPrev;					// pointer to the previous element
-	public:
-		// dereference operator
-		T& operator* ()
-		{
-			return *m_pObject;
-		}
-
-		// constructor
-		CElement(T *pObj)
-		{
-			m_pObject = pObj;
-			m_pNext = NULL;
-			m_pPrev = NULL;
-		}
-
-		// destructor
-		~CElement()
-		{
-			delete m_pObject;
-			if (m_pNext)
-				m_pNext->m_pPrev = m_pPrev;
-			if (m_pPrev)
-				m_pPrev->m_pNext = m_pNext;
-		}
-
-		// returns object pointer
-		T *GetObj()
-		{
-			return m_pObject;
-		}
-
-		// returns next element pointer
-		CElement *GetNext()
-		{
-			return m_pNext;
-		}
-
-		// sets next element
-		void SetNext(CElement *newNext)
-		{
-			m_pNext = newNext;
-		}
-
-		// returns previous element pointer
-		CElement *GetPrev()
-		{
-			return m_pPrev;
-		}
-
-		// sets previous element
-		void SetPrev(CElement *newPrev)
-		{
-			m_pPrev = newPrev;
-		}
-	};
-
-	// CList<T,F> class
-	CElement *m_pHead;					// head of the linked list
-	CElement *m_pTail;					// tail of the linked list
-public:
-	// iterator class
-	class iterator
-	{
-		friend class CList<T,F>;
-		CList<T,F> *m_pList;			// The list that created this iterator
-		CElement *m_CurPos;				// Current position in the list
-	public:
-		iterator()
-		{
-			m_pList = NULL;
-			m_CurPos = NULL;
-		}
-
-		// constructor based on list, element
-		iterator(CList<T,F> *pList, CElement *startPos)
-		{
-			m_pList = pList;
-			m_CurPos = startPos;
-		}
-
-		// constructor based on other iterator
-		iterator(const iterator &other)
-		{
-			m_pList = other.m_pList;
-			m_CurPos = other.m_CurPos;
-		}
-
-		// dereference operator
-		T & operator* () const
-		{
-			return *m_CurPos->GetObj();
-		}
-
-		T * operator-> () const
-		{
-			return m_CurPos->GetObj();
-		}
-
-		// validity check operator
-		inline operator bool () const
-		{
-			return m_pList!=NULL && m_CurPos!=NULL && m_CurPos->GetObj()!=NULL;
-		}
-
-		// pre increment operator
-		inline iterator& operator ++ ()
-		{
-			m_CurPos = m_CurPos->GetNext();
-			return *this;
-		}
-
-		// post increment operator
-		inline iterator operator++(int)
-		{
-			iterator tmp(*this);
-			m_CurPos = m_CurPos->next;
-			return tmp;
-		}
-
-		// returns iterator that points to next element
-		iterator GetNext()
-		{
-			iterator tmp(*this);
-			return ++tmp;
-		}
-
-		iterator remove()
-		{
-			return m_pList->remove(*this);
-		}
-		iterator put(T *obj)
-		{
-			return m_pList->put(obj, *this);
-		}
-	};
-
-	CList<T,F>()
-	{
-		m_pHead = NULL;
-		m_pTail = NULL;
-	}
-	~CList<T,F>()
-	{
-		clear();
-	}
-
-	// removes the object referenced by where
-	// sets where to the next object
-	// returns an iterator pointing to the next object
-	iterator remove(iterator &where)
-	{
-		iterator tmp(where.GetNext());
-		if (where.m_CurPos == m_pHead)
-			m_pHead = where.m_CurPos->GetNext();
-		if (where.m_CurPos == m_pTail)
-			m_pTail = where.m_CurPos->GetPrev();
-		delete where.m_CurPos;
-		where = tmp;
-		return tmp;
-	}
-
-	// puts an element to the end of the list
-	// returns an iterator pointing to it
-	iterator put_back(T *pObj)
-	{
-		CElement *pTmp = new CElement(pObj);
-		if (!m_pHead)
-		{
-			m_pHead = pTmp;
-			m_pTail = pTmp;
-		}
-		else
-		{
-			pTmp->SetNext(NULL);
-			pTmp->SetPrev(m_pTail);
-			m_pTail->SetNext(pTmp);
-			m_pTail = pTmp;
-		}
-		return iterator(this, pTmp);
-	}
-
-	iterator put_front(T *pObj)
-	{
-		CElement *pTmp = new CElement(pObj);
-		if (!m_pHead)
-		{
-			m_pHead = pTmp;
-			m_pTail = pTmp;
-		}
-		else
-		{
-			pTmp->SetNext(m_pHead);
-			pTmp->SetPrev(NULL);
-			m_pHead->SetPrev(pTmp);
-			m_pHead = pTmp;
-		}
-		return iterator(this, pTmp);
-	}
-
-	// alias for put_back
-	iterator put(T *pObj)
-	{
-		return put_back(pObj);
-	}
-
-	// puts an element after where
-	// alters where to point to the new element
-	// returns an iterator pointing to the new element
-	iterator put(T *pObj, iterator &where)
-	{
-		CElement *pTmp = new CElement(pObj);
-		if (where.m_CurPos->GetNext())
-			where.m_CurPos->GetNext()->SetPrev(pTmp);
-		else		// where = tail
-			m_pTail = pTmp;
-
-		pTmp->SetPrev(where.m_CurPos);
-		pTmp->SetNext(where.m_CurPos->GetNext());
-
-		where.m_CurPos->SetNext(pTmp);
-		return ++where;
-	}
-
-	iterator begin()
-	{
-		return iterator(this, m_pHead);
-	}
-
-	void clear()
-	{
-		iterator iter = begin();
-		while (iter) iter.remove();
-	}
-
-	iterator find(iterator startOn, const F &desc)
-	{
-		iterator iter = startOn;
-		while(iter)
-		{
-			if (*iter == desc)
-				break;
-			++iter;
-		}
-		return iter;
-	}
-
-	iterator find(const F &desc)
-	{
-		return find(begin(), desc);
-	}
-
-	int size()
-	{
-		iterator iter = begin();
-		int i=0;
-		while (iter)
-		{
-			++i;
-			++iter;
-		}
-		return i;
-	}
-};
-#endif
-

amxmodx/CLogEvent.cpp

@@ -1,250 +1,324 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
 #include "CLogEvent.h"
 
+NativeHandle<LogEventHook> LogEventHandles;
+
 // *****************************************************
 // class LogEventsMngr
 // *****************************************************
-LogEventsMngr::LogEventsMngr() {
-  logCurrent = logCounter = 0;
-  logcmplist = 0;
-  arelogevents = false;
-  memset( logevents, 0, sizeof(logevents) );
+
+LogEventsMngr::LogEventsMngr()
+{
+	logCurrent = logCounter = 0;
+	logcmplist = 0;
+	arelogevents = false;
+	memset(logevents, 0, sizeof(logevents));
 }
 
-LogEventsMngr::~LogEventsMngr() {
-  clearLogEvents();
+LogEventsMngr::~LogEventsMngr()
+{
+	clearLogEvents();
 }
 
-int LogEventsMngr::CLogCmp::compareCondition(const char* string){
-  if ( logid == parent->logCounter )
-    return result;
-  logid = parent->logCounter;
-  if ( in ) return result = strstr( string , text.c_str() ) ? 0 : 1;
-  return result = strcmp(string,text.c_str());
+int LogEventsMngr::CLogCmp::compareCondition(const char* string)
+{
+	if (logid == parent->logCounter)
+		return result;
+	
+	logid = parent->logCounter;
+	
+	if (in)
+		return result = strstr(string, text.chars()) ? 0 : 1;
+	
+	return result = strcmp(string,text.chars());
 }
 
-LogEventsMngr::CLogCmp* LogEventsMngr::registerCondition(char* filter){
+LogEventsMngr::CLogCmp* LogEventsMngr::registerCondition(char* filter)
+{
 	char* temp = filter;
 	// expand "1=message"
-    while ( isdigit(*filter) )
+
+	while (isdigit(*filter))
 		++filter;
-    bool in = (*filter=='&');
-    *filter++ = 0;
-    int pos = atoi(temp);
-	if ( pos < 0 || pos >= MAX_LOGARGS) pos = 0;
+
+	bool in = (*filter=='&');
+	*filter++ = 0;
+	int pos = atoi(temp);
+	
+	if (pos < 0 || pos >= MAX_LOGARGS)
+		pos = 0;
+	
 	CLogCmp* c = logcmplist;
-	while( c ) {
-		if ( (c->pos==pos) && (c->in==in) && !strcmp(c->text.c_str(), filter))
+	
+	while (c)
+	{
+		if ((c->pos == pos) && (c->in == in) && !strcmp(c->text.chars(), filter))
 			return c;
 		c = c->next;
 	}
-	return logcmplist = new CLogCmp( filter , in , pos , logcmplist,this );
+	
+	return logcmplist = new CLogCmp(filter, in, pos, logcmplist, this);
 }
 
-void LogEventsMngr::CLogEvent::registerFilter( char* filter ){
-	CLogCmp *cmp = parent->registerCondition( filter );
-	if ( cmp == 0 ) return;
-	for(LogCond* c = filters; c ; c = c->next){
-		if ( c->argnum == cmp->pos ){
-			c->list = new LogCondEle( cmp , c->list );
+void LogEventsMngr::CLogEvent::registerFilter(char* filter)
+{
+	CLogCmp *cmp = parent->registerCondition(filter);
+	if (cmp == 0) return;
+	
+	for (LogCond* c = filters; c; c = c->next)
+	{
+		if (c->argnum == cmp->pos)
+		{
+			c->list = new LogCondEle(cmp, c->list);
 			return;
 		}
 	}
-	LogCondEle* aa = new LogCondEle( cmp , 0 );
-	if ( aa == 0 ) return;
-	filters = new LogCond( cmp->pos , aa  , filters );
+	
+	LogCondEle* aa = new LogCondEle(cmp, 0);
+	
+	if (aa == 0)
+		return;
+
+	filters = new LogCond(cmp->pos, aa, filters);
 }
 
-void LogEventsMngr::setLogString( char* frmt, va_list& vaptr ) {
+void LogEventsMngr::setLogString(const char* frmt, va_list& vaptr)
+{
 	++logCounter;
-	int len = vsnprintf (logString, 255 , frmt, vaptr );
-	if ( len == - 1) {
+	int len = vsnprintf(logString, 255, frmt, vaptr);
+	
+	if (len == - 1)
+	{
 		len = 255;
 		logString[len] = 0;
 	}
-	if ( len ) logString[--len] = 0;
+	
+	if (len)
+		logString[--len] = 0;
+	
 	logArgc = 0;
 }
 
-void LogEventsMngr::setLogString( char* frmt, ...  ) {
+void LogEventsMngr::setLogString(const char* frmt, ...)
+{
 	++logCounter;
 	va_list logArgPtr;
-	va_start ( logArgPtr , frmt );
-	int len = vsnprintf(logString, 255 , frmt, logArgPtr );
-	if ( len == - 1) {
+	va_start(logArgPtr, frmt);
+	int len = vsnprintf(logString, 255, frmt, logArgPtr);
+	
+	if (len == - 1)
+	{
 		len = 255;
 		logString[len] = 0;
 	}
-	va_end ( logArgPtr );
-	if ( len ) logString[--len] = 0;
+	
+	va_end(logArgPtr);
+	
+	if (len)
+		logString[--len] = 0;
+	
 	logArgc = 0;
 }
 
-void LogEventsMngr::parseLogString(   ) {
-  register const char* b = logString;
-  register int a;
-  while( *b && logArgc < MAX_LOGARGS ){
-    a = 0;
-    if ( *b == '"' ) {
-      ++b;
-      while ( *b && *b != '"' && a < 127 ) 
-		  logArgs[logArgc][a++] = *b++;
-      logArgs[logArgc++][a] = 0;
-      if ( *b) b+=2; // thanks to double terminator
-    }
-    else if ( *b == '('  ) {
-      ++b;
-      while ( *b && *b != ')' && a < 127 ) 
-		  logArgs[logArgc][a++] = *b++;
-      logArgs[logArgc++][a] = 0;
-      if ( *b) b+=2;
-    }
-    else {
-      while ( *b && *b != '(' && *b != '"' && a < 127 ) 
-		  logArgs[logArgc][a++] = *b++;
-      if ( *b ) --a;
-      logArgs[logArgc++][a] = 0;
-    }
-  }
+void LogEventsMngr::parseLogString()
+{
+	register const char* b = logString;
+	register int a;
+	
+	while (*b && logArgc < MAX_LOGARGS)
+	{
+		a = 0;
+		
+		if (*b == '"')
+		{
+			++b;
+			
+			while (*b && *b != '"' && a < 127) 
+				logArgs[logArgc][a++] = *b++;
+			
+			logArgs[logArgc++][a] = 0;
+			if (*b) b+=2; // thanks to double terminator
+		}
+		else if (*b == '(')
+		{
+			++b;
+			
+			while (*b && *b != ')' && a < 127) 
+				logArgs[logArgc][a++] = *b++;
+			
+			logArgs[logArgc++][a] = 0;
+			if (*b) b+=2;
+		} else {
+			while (*b && *b != '(' && *b != '"' && a < 127) 
+			logArgs[logArgc][a++] = *b++;
+			if (*b) --a;
+			logArgs[logArgc++][a] = 0;
+		}
+	}
 }
 
-LogEventsMngr::CLogEvent* LogEventsMngr::registerLogEvent( CPluginMngr::CPlugin* plugin,  int func, int pos )
+void LogEventsMngr::CLogEvent::setForwardState(ForwardState state)
 {
-  if ( pos < 1 || pos > MAX_LOGARGS)
-    return 0;
-  arelogevents = true;
-  CLogEvent** d = &logevents[pos];
-  while(*d) d = &(*d)->next;
-  return *d = new CLogEvent( plugin , func, this );
+	m_State = state;
+}
+
+int LogEventsMngr::registerLogEvent(CPluginMngr::CPlugin* plugin, int func, int pos)
+{
+	if (pos < 1 || pos > MAX_LOGARGS)
+	{
+		return 0;
+	}
+
+	arelogevents = true;
+	auto d = &logevents[pos];
+
+	while (*d)
+	{
+		d = &(*d)->next;
+	}
+
+	auto logevent = new CLogEvent(plugin, func, this);
+	auto handle = LogEventHandles.create(logevent);
+
+	if (!handle)
+	{
+		return 0;
+	}
+
+	*d = logevent;
+
+	return handle;
 }
 
 void LogEventsMngr::executeLogEvents()
 {
-    int err;
-    bool valid;
-    for(CLogEvent* a = logevents[ logArgc ]; a ; a = a->next){
+	bool valid;
+
+	for (CLogEvent* a = logevents[logArgc]; a; a = a->next)
+	{
+		if (a->m_State != FSTATE_ACTIVE)
+		{
+			continue;
+		}
+
 		valid = true;
-		for( CLogEvent::LogCond* b = a->filters; b ; b = b->next){
+
+		for (CLogEvent::LogCond* b = a->filters; b; b = b->next)
+		{
 			valid = false;
-			for( CLogEvent::LogCondEle* c = b->list; c ; c = c->next) {
-				if ( c->cmp->compareCondition( logArgs[b->argnum] ) == 0 ){
+
+			for (CLogEvent::LogCondEle* c = b->list; c; c = c->next)
+			{
+				if (c->cmp->compareCondition(logArgs[b->argnum]) == 0)
+				{
 					valid = true;
 					break;
 				}
 			}
-			if (!valid) break;
+
+			if (!valid)
+				break;
 		}
-		
-#ifdef ENABLEEXEPTIONS
-		try
+
+		if (valid)
 		{
-#endif
-			
-			if (valid){
-				if ((err = amx_Exec(a->plugin->getAMX(), NULL , a->func , 0)) != AMX_ERR_NONE)
-					LogError(a->plugin->getAMX(), err, "");
-			}
-			
-#ifdef ENABLEEXEPTIONS
+			executeForwards(a->func);
 		}
-		catch( ... )
+	}
+}
+
+void LogEventsMngr::clearLogEvents()
+{
+	logCurrent = logCounter = 0;
+	arelogevents = false;
+	
+	for (int i = 0; i < MAX_LOGARGS + 1; ++i)
+	{
+		CLogEvent **a = &logevents[i];
+		while (*a)
 		{
-			AMXXLOG_Log( "[AMXX] fatal error at log forward function execution");
+			CLogEvent* bb = (*a)->next;
+			delete *a;
+			*a = bb;
 		}
-#endif
-		
-    }
+	}
+	
+	clearConditions();
+
+	LogEventHandles.clear();
 }
 
-void LogEventsMngr::clearLogEvents(){
-  logCurrent = logCounter = 0;
-  arelogevents = false;
-  for(int i = 0; i < MAX_LOGARGS + 1; ++i){
-    CLogEvent **a = &logevents[i];
-    while(*a){
-      CLogEvent* bb = (*a)->next;
-      delete *a;
-      *a = bb;
-    }
-  }
-  clearConditions();
+void LogEventsMngr::clearConditions()
+{
+	while (logcmplist)
+	{
+		CLogCmp* a = logcmplist->next;
+		delete logcmplist;
+		logcmplist = a;
+	}
 }
 
-void LogEventsMngr::clearConditions() {
-  while (logcmplist){
-    CLogCmp* a = logcmplist->next;
-    delete logcmplist;
-    logcmplist = a;
-  }
-}
-
-LogEventsMngr::CLogEvent::LogCond::~LogCond() {  
-	while( list ) {
+LogEventsMngr::CLogEvent::LogCond::~LogCond()
+{
+	while (list)
+	{
 		LogCondEle* cc = list->next;
 		delete list;
 		list = cc;
 	}
 }
 
-LogEventsMngr::CLogEvent::~CLogEvent() {
-	while( filters ) {
+LogEventsMngr::CLogEvent::~CLogEvent()
+{
+	while (filters)
+	{
 		LogCond* cc = filters->next;
 		delete filters;
 		filters = cc;
 	}
 }
 
-LogEventsMngr::CLogEvent *LogEventsMngr::getValidLogEvent( CLogEvent * a )
+LogEventsMngr::CLogEvent *LogEventsMngr::getValidLogEvent(CLogEvent * a)
 {
 	bool valid;
-	while(a){
+	
+	while (a)
+	{
 		valid = true;
-		for( CLogEvent::LogCond* b = a->filters; b ; b = b->next){
+		
+		for (CLogEvent::LogCond* b = a->filters; b; b = b->next)
+		{
 			valid = false;
-			for( CLogEvent::LogCondEle* c = b->list; c ; c = c->next) {
-				if ( c->cmp->compareCondition( logArgs[b->argnum] ) == 0 ){
+
+			for (CLogEvent::LogCondEle* c = b->list; c; c = c->next)
+			{
+				if (c->cmp->compareCondition(logArgs[b->argnum]) == 0)
+				{
 					valid = true;
 					break;
 				}
 			}
+			
 			if (!valid) break;
 		}
-		if (!valid){
+		
+		if (!valid)
+		{
 			a = a->next;
 			continue;
 		}
+		
 		return a;
 	}
+	
 	return 0;
 }

amxmodx/CLogEvent.h

@@ -1,33 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef LOGEVENTS_H
 #define LOGEVENTS_H
@@ -35,131 +13,156 @@
 #define MAX_LOGARGS 12
 
 #include <stdarg.h>
+#include "natives_handles.h"
 
 // *****************************************************
 // class LogEventsMngr
 // *****************************************************
 
-class LogEventsMngr {
-
-  char logString[256];
-  char logArgs[MAX_LOGARGS][128];
-  int logArgc;
-  int logCounter;
-  int logCurrent;
-  bool arelogevents;
+class LogEventsMngr
+{
+	char logString[256];
+	char logArgs[MAX_LOGARGS][128];
+	int logArgc;
+	int logCounter;
+	int logCurrent;
+	bool arelogevents;
 
 public:
-  class CLogCmp;
-  class iterator;
-  class CLogEvent;
-
-  friend class CLogEvent;
-  friend class CLogCmp;
-  friend class iterator;
-
-  class CLogCmp 
-  {
-	friend class LogEventsMngr;
+	class CLogCmp;
+	class iterator;
+	class CLogEvent;
 	friend class CLogEvent;
-	LogEventsMngr* parent;
-    String text;
-    int logid;
-    int pos;
-    int result;
-    bool in;
-    CLogCmp *next;
-    CLogCmp( const char* s, bool r, int p, CLogCmp *n, LogEventsMngr* mg ) : text(s) {
-      logid = result = 0;
-      pos = p;
-	  parent = mg;
-      in = r;
-      next = n;
-    }
-  public:
-
-	int compareCondition(const char* string);
-  };
-
-private:
-
-  CLogCmp *logcmplist;
-
-public:
-
-  class CLogEvent {
-	friend class LogEventsMngr;
+	friend class CLogCmp;
 	friend class iterator;
-	struct LogCondEle {
-		CLogCmp *cmp;
-		LogCondEle *next;
-		LogCondEle(CLogCmp *c, LogCondEle *n): cmp(c) , next(n) { }
+
+	class CLogCmp 
+	{
+		friend class LogEventsMngr;
+		friend class CLogEvent;
+		
+		LogEventsMngr* parent;
+		ke::AString text;
+		
+		int logid;
+		int pos;
+		int result;
+		bool in;
+		
+		CLogCmp *next;
+		
+		CLogCmp(const char* s, bool r, int p, CLogCmp *n, LogEventsMngr* mg) : text(s)
+		{
+			logid = result = 0;
+			pos = p;
+			parent = mg;
+			in = r;
+			next = n;
+		}
+	
+	public:
+		int compareCondition(const char* string);
 	};
-	struct LogCond {
-		int argnum;
-		LogCondEle *list;
-		LogCond *next;
-		LogCond( int a , LogCondEle* ee , LogCond* n ) : argnum(a) , list(ee), next(n)  {}
-		~LogCond();
-	};
-    CPluginMngr::CPlugin *plugin;
-    int func;
-    LogCond *filters;
-    LogEventsMngr* parent;
-    CLogEvent *next;
-    CLogEvent(CPluginMngr::CPlugin *p,int f, LogEventsMngr* ppp) : plugin(p),func(f), filters(0),parent(ppp) ,next(0) { }
-    ~CLogEvent();
-  public:
-	inline CPluginMngr::CPlugin *getPlugin() { return plugin; }
-	void registerFilter( char* filter );
-	inline int getFunction() { return func; }
-  };
 
 private:
-
-  CLogEvent *logevents[MAX_LOGARGS+1];
-  CLogEvent *getValidLogEvent( CLogEvent * a );
-  CLogCmp* registerCondition(char* filter);
-  void clearConditions();
-
+	CLogCmp *logcmplist;
 public:
 
-  LogEventsMngr();
-  ~LogEventsMngr();
+	class CLogEvent
+	{
+		friend class LogEventsMngr;
+		friend class iterator;
+		
+		struct LogCondEle
+		{
+			CLogCmp *cmp;
+			LogCondEle *next;
+			LogCondEle(CLogCmp *c, LogCondEle *n): cmp(c), next(n) {}
+		};
+	
+		struct LogCond
+		{
+			int argnum;
+			
+			LogCondEle *list;
+			LogCond *next;
+			LogCond(int a, LogCondEle* ee, LogCond* n) : argnum(a), list(ee), next(n) {}
+			~LogCond();
+		};
+		
+		CPluginMngr::CPlugin *plugin;
+		
+		int func;
+		
+		LogCond *filters;
+		LogEventsMngr* parent;
+
+		ForwardState m_State;
+
+		CLogEvent *next;
+		CLogEvent(CPluginMngr::CPlugin *p, int f, LogEventsMngr* ppp) : plugin(p), func(f), filters(nullptr), parent(ppp), m_State(FSTATE_ACTIVE), next(nullptr) {}
+		~CLogEvent();
+	public:
+		inline CPluginMngr::CPlugin *getPlugin() { return plugin; }
+		void registerFilter(char* filter);
+		void setForwardState(ForwardState value);
+		inline int getFunction() { return func; }
+	};
+
+private:
+	CLogEvent *logevents[MAX_LOGARGS + 1];
+	CLogEvent *getValidLogEvent(CLogEvent * a);
+	CLogCmp* registerCondition(char* filter);
+	
+	void clearConditions();
+public:
+	LogEventsMngr();
+	~LogEventsMngr();
 
 	// Interface
+	int registerLogEvent(CPluginMngr::CPlugin* plugin, int func, int pos);
+	inline bool logEventsExist() { return arelogevents; } 
+	
+	void setLogString(const char* frmt, va_list& vaptr);
+	void setLogString(const char* frmt, ...);
+	void parseLogString();
+	void executeLogEvents();
+	
+	inline const char* getLogString() { return logString; }
+	inline int getLogArgNum() { return logArgc; }
+	inline const char* getLogArg(int i) { return (i < 0 || i >= logArgc) ? "" : logArgs[i]; }
+	void clearLogEvents();
 
+	class iterator
+	{
+		CLogEvent* a;
+		LogEventsMngr* b;
+	
+	public:
+		inline iterator(CLogEvent*aa, LogEventsMngr* bb) : a(aa), b(bb) {}
+			
+		inline iterator& operator++()
+		{
+			a = b->getValidLogEvent(a->next);
+			return *this;
+		}
 
-  CLogEvent* registerLogEvent( CPluginMngr::CPlugin* plugin,  int func, int pos );
-  inline bool logEventsExist() { return arelogevents; } 
-  void setLogString( char* frmt, va_list& vaptr );
-  void setLogString( char* frmt , ... );
-  void parseLogString(  );
-  void executeLogEvents();
-  inline const char* getLogString() { return logString; }
-  inline int getLogArgNum() { return logArgc; }
-  inline const char* getLogArg( int i ) { return ( i < 0 || i >=  logArgc ) ? "" : logArgs[ i ]; }
-  void clearLogEvents();
-
-
-  class iterator {
-	  CLogEvent* a;
-	  LogEventsMngr* b;
-  public:
-	  inline iterator(CLogEvent*aa,LogEventsMngr* bb) : a(aa), b(bb) {}
-	  inline iterator& operator++() {
-		  a = b->getValidLogEvent( a->next );
-		  return *this;
-	  }
-	  inline bool operator==(const iterator& c) const { return a == c.a; }
-	  inline bool operator!=(const iterator& c) const  { return !operator==(c); }
-	  CLogEvent& operator*() { return *a; }
-	  operator bool ( ) const { return a ? true : false; }
-  };
-  inline iterator begin() { return iterator(getValidLogEvent(logevents[ logArgc ]),this); }
-  inline iterator end() { return iterator(0,this); }
+		inline bool operator==(const iterator& c) const { return a == c.a; }
+		inline bool operator!=(const iterator& c) const { return !operator == (c); }
+		CLogEvent& operator*() { return *a; }
+		operator bool () const { return a ? true : false; }
+	};
+	
+	inline iterator begin() { return iterator(getValidLogEvent(logevents[logArgc]), this); }
+	inline iterator end() { return iterator(0, this); }
 };
 
-#endif
+struct LogEventHook
+{
+	explicit LogEventHook(LogEventsMngr::CLogEvent *logevent) : m_logevent(logevent) {}
+	LogEventsMngr::CLogEvent *m_logevent;
+};
 
+extern NativeHandle<LogEventHook> LogEventHandles;
 
+#endif //LOGEVENTS_H

amxmodx/CMenu.cpp

@@ -1,33 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
 #include "CMenu.h"
@@ -35,60 +13,101 @@
 // *****************************************************
 // class MenuMngr
 // *****************************************************
-MenuMngr::MenuCommand::MenuCommand( CPluginMngr::CPlugin *a, int mi, int k, int f ) {
+MenuMngr::MenuCommand::MenuCommand(CPluginMngr::CPlugin *a, int mi, int k, int f, bool new_menu)
+{
 	plugin = a;
 	keys = k;
 	menuid = mi;
-	function = f;
 	next = 0;
+	is_new_menu = new_menu;
+
+	function = f;
 }
 
 MenuMngr::~MenuMngr() 
 {
 	clear();
+	MenuMngr::MenuIdEle::uniqueid = 0;
 }
 
 int MenuMngr::findMenuId(const char* name, AMX* amx)
 {
-  for( MenuIdEle* b = headid; b ; b = b->next) {
-    if ( (!b->amx || amx == b->amx) && strstr(name,b->name.c_str()) )
-      return b->id;
-  }
-  return 0;
+	for (MenuIdEle* b = headid; b; b = b->next)
+	{
+		if ((!amx || !b->amx || amx == b->amx) && strstr(name,b->name.chars()))
+			return b->id;
+	}
+	
+	return 0;
 }
 
-int MenuMngr::registerMenuId(const char* n, AMX* a )
+int MenuMngr::registerMenuId(const char* n, AMX* a)
 {
-  int id = findMenuId( n, a );
-  if (id) return id;
-  headid = new MenuIdEle( n, a , headid  );
-  if (!headid)
-	  return 0;			// :TODO: Better error report
-  return headid->id;
+	int id = findMenuId(n, a);
+	
+	if (id)
+	{
+		return id;
+	}
+	
+	headid = new MenuIdEle(n, a, headid);
+	
+	return headid->id;
 }
 
-void MenuMngr::registerMenuCmd( CPluginMngr::CPlugin *a,int mi, int k , int f  ) 
+void MenuMngr::registerMenuCmd(CPluginMngr::CPlugin *a, int mi, int k, int f, bool from_new_menu) 
 {
-	MenuCommand** temp = &headcmd;
-	while(*temp) temp = &(*temp)->next;
-	*temp = new MenuCommand(a,mi, k,f);
+	MenuCommand **temp = &headcmd;
+	if (from_new_menu)
+	{
+		MenuCommand *ptr;
+		while (*temp)
+		{
+			ptr = *temp;
+			if (ptr->is_new_menu
+				&& ptr->plugin == a
+				&& ptr->menuid == mi)
+			{
+				if (g_forwards.isSameSPForward(ptr->function, f))
+				{
+					return;
+				}
+			}
+			temp = &(*temp)->next;
+		}
+	} else {
+		while (*temp)
+		{
+			temp = &(*temp)->next;
+		}
+	}
+	*temp = new MenuCommand(a, mi, k, f, from_new_menu);
 }
 
-void MenuMngr::clear() 
+void MenuMngr::clear()
 {
-  while (headid)
-  {
-    MenuIdEle* a = headid->next;
-    delete headid;
-    headid = a;
-  }
+	while (headid)
+	{
+		MenuIdEle* a = headid->next;
+		delete headid;
+		headid = a;
+	}
 
-  while (headcmd)
-  {
-    MenuCommand* a = headcmd->next;
-    delete headcmd;
-    headcmd = a;
-  }
+	while (headcmd)
+	{
+		MenuCommand* a = headcmd->next;
+		delete headcmd;
+		headcmd = a;
+	}
 }
 
-int MenuMngr::MenuIdEle::uniqueid = 0;
+MenuMngr::iterator MenuMngr::SetWatchIter(MenuMngr::iterator iter)
+{
+	MenuMngr::iterator old = m_watch_iter;
+
+	m_watch_iter = iter;
+
+	return old;
+}
+
+int MenuMngr::MenuIdEle::uniqueid = 0;

amxmodx/CMenu.h

@@ -1,33 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef MENUS_H
 #define MENUS_H
@@ -38,55 +16,62 @@
 
 class MenuMngr
 {
-  struct MenuIdEle
-  {
-    String name;
-    AMX* amx;
-    MenuIdEle* next;
-	int id;
-	static int uniqueid;
-    MenuIdEle( const char* n, AMX* a, MenuIdEle* m ) : name( n ) , amx(a) , next( m ) {
-		id = ++uniqueid;
-	}
-	~MenuIdEle() { --uniqueid; }
-  } *headid;
+	struct MenuIdEle
+	{
+		ke::AString name;
+		AMX* amx;
+		MenuIdEle* next;
+		
+		int id;
+		static int uniqueid;
+		
+		MenuIdEle(const char* n, AMX* a, MenuIdEle* m) : name(n), amx(a), next(m)
+		{
+			id = ++uniqueid;
+		}
+	} *headid;
 
 public:
-	class iterator;
-
+		class iterator;
 private:
 
-  class MenuCommand 
-  {
-	  friend class iterator;
-	  friend class MenuMngr;
-	  
-	  CPluginMngr::CPlugin *plugin;
-	  int menuid;
-	  int keys;
-	  int function;
-	  MenuCommand* next;
-	  MenuCommand( CPluginMngr::CPlugin *a, int mi, int k, int f );
-  public:
-	  inline int getFunction() { return function; }
-	  inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
-	  inline bool matchCommand( int m, int k  ) { return ((m == menuid) && (keys & k)); }
-  } *headcmd;
+	class MenuCommand 
+	{
+		friend class iterator;
+		friend class MenuMngr;
+
+		CPluginMngr::CPlugin *plugin;
+		int menuid;
+		int keys;
+		int function;
+		int is_new_menu;
+		
+		MenuCommand* next;
+		MenuCommand(CPluginMngr::CPlugin *a, int mi, int k, int f, bool new_menu=false);
+	public:
+		inline int getFunction() { return function; }
+		inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
+		inline bool matchCommand(int m, int k)
+		{
+			return ((m == menuid) && (keys & k));
+		}
+	} *headcmd;
 	
 public:
-	
-	MenuMngr() { headid = 0;  headcmd = 0; }
+	MenuMngr() : m_watch_iter(end())
+		{ headid = NULL; headcmd = NULL; }
 	~MenuMngr();
 
 	// Interface
 
-
 	int findMenuId(const char* name, AMX* a = 0);
-	int registerMenuId(const char* n, AMX* a );
-	void registerMenuCmd( CPluginMngr::CPlugin *a,int mi, int k , int f  );
+	int registerMenuId(const char* n, AMX* a);
+	void registerMenuCmd(CPluginMngr::CPlugin *a, int mi, int k, int f, bool from_new_menu=false);
 	void clear();
 
-	class iterator {
+	class iterator
+	{
+		friend class MenuMngr;
 		MenuCommand* a;
 	public:
 		iterator(MenuCommand*aa) : a(aa) {}
@@ -96,12 +81,16 @@ public:
 		operator bool () const { return a ? true : false; }
 		MenuCommand& operator*() { return *a; }
 	};
+	
 	inline iterator begin() const { return iterator(headcmd); }
 	inline iterator end() const { return iterator(0); }
-	
 
+	MenuMngr::iterator SetWatchIter(MenuMngr::iterator iter);
+	inline MenuMngr::iterator GetWatchIter() { return m_watch_iter; }
+private:
+	MenuMngr::iterator m_watch_iter;
 };
 
-#endif
-
+extern MenuMngr g_menucmds;
 
+#endif //MENUS_H

amxmodx/CMisc.cpp

@@ -1,46 +1,27 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
 #include "amxmodx.h"
+#include "newmenus.h"
 // *****************************************************
 // class CPlayer
 // *****************************************************
 
-void CPlayer::Init( edict_t* e , int i )
+void CPlayer::Init(edict_t* e, int i)
 {
 	index = i;
 	pEdict = e;
 	initialized = false;
 	ingame = false;
-	bot = false;
 	authorized = false;
+	disconnecting = false;
+	teamIdsInitialized = false;
 
 	current = 0;
 	teamId = -1;
@@ -48,185 +29,265 @@ void CPlayer::Init( edict_t* e , int i )
 	aiming = 0;
 	menu = 0;
 	keys = 0;
+	menuexpire = 0.0;
+	newmenu = -1;
+
+	death_weapon = nullptr;
+	name = nullptr;
+	ip = nullptr;
+	team = nullptr;
+}
+
+void CPlayer::Disconnect()
+{
+	ingame = false;
+	initialized = false;
+	authorized = false;
+	disconnecting = false;
+	teamIdsInitialized = false;
+
+	if (Menu *pMenu = get_menu_by_id(newmenu))
+		pMenu->Close(index);
+
+	List<ClientCvarQuery_Info *>::iterator iter, end=queries.end();
+	for (iter=queries.begin(); iter!=end; iter++)
+	{
+		unregisterSPForward((*iter)->resultFwd);
+		delete [] (*iter)->params;
+		delete (*iter);
+	}
+	queries.clear();
+
+	menu = 0;
+	newmenu = -1;
+}
+
+void CPlayer::PutInServer()
+{
+	playtime = gpGlobals->time;
+	ingame = true;
+}
+
+int CPlayer::NextHUDChannel()
+{
+	int ilow = 1;
+
+	for (int i=ilow+1; i<=4; i++)
+	{
+		if (channels[i] < channels[ilow])
+			ilow = i;
+	}
+
+	return ilow;
+}
+
+bool CPlayer::Connect(const char* connectname, const char* ipaddress)
+{
+	name = connectname;
+	ip = ipaddress;
+	time = gpGlobals->time;
+	death_killer = 0;
+	menu = 0;
+	newmenu = -1;
 	
-	death_weapon.clear();
-	name.clear();
-	ip.clear();
-	team.clear();
+	memset(flags, 0, sizeof(flags));
+	memset(weapons, 0, sizeof(weapons));
+	
+	initialized = true;
+	authorized = false;
+
+	for (int i=0; i<=4; i++)
+	{
+		channels[i] = 0.0f;
+		hudmap[i] = 0;
+	}
+
+	List<ClientCvarQuery_Info *>::iterator iter, end=queries.end();
+	for (iter=queries.begin(); iter!=end; iter++)
+	{
+		unregisterSPForward((*iter)->resultFwd);
+		delete [] (*iter)->params;
+		delete (*iter);
+	}
+	queries.clear();
+
+	const char* authid = GETPLAYERAUTHID(pEdict);
+
+	if ((authid == 0) || (*authid == 0) || (strcmp(authid, "STEAM_ID_PENDING") == 0))
+		return true;
+
+	return false;
 }
 
-void CPlayer::Disconnect() {
-  ingame = false;
-  initialized = false;
-  authorized = false;
-  bot = 0;
-}
-
-void CPlayer::PutInServer() {
-  playtime = gpGlobals->time;
-  ingame = true;
-}
-bool CPlayer::Connect(const char* connectname,const char* ipaddress) {
-  name.assign(connectname);
-  ip.assign(ipaddress);
-  time = gpGlobals->time;
-  bot = IsBot();
-  death_killer = 0;
-  memset(flags,0,sizeof(flags));
-  memset(weapons,0,sizeof(weapons));
-  initialized = true;
-  authorized = false;
-
-  const char* authid = GETPLAYERAUTHID( pEdict );
-
-  if ( (authid == 0) || (*authid == 0) 
-	  || (strcmp( authid , "STEAM_ID_PENDING") == 0) )
-	return true;
-
-  return false;
-}
-
-
-
 // *****************************************************
 // class Grenades
 // *****************************************************
-void Grenades::put( edict_t* grenade, float time, int type, CPlayer* player  )
+
+void Grenades::put(edict_t* grenade, float time, int type, CPlayer* player)
 {
-  Obj* a = new Obj;
-  if ( a == 0 ) return;
-  a->player = player;
-  a->grenade = grenade;
-  a->time = gpGlobals->time + time;
-  a->type = type;
-  a->next = head;
-  head = a;
+	Obj* a = new Obj;
+	if (a == 0) return;
+	a->player = player;
+	a->grenade = grenade;
+	a->time = gpGlobals->time + time;
+	a->type = type;
+	a->next = head;
+	head = a;
 }
 
-bool Grenades::find( edict_t* enemy, CPlayer** p, int& type )
+bool Grenades::find(edict_t* enemy, CPlayer** p, int& type)
 {
-  bool found = false;
-  Obj** a = &head;
-  while ( *a ){
-    if ( (*a)->time > gpGlobals->time ) {
-      if ( (*a)->grenade == enemy ) {
-        found = true;
-        (*p) = (*a)->player;
-        type = (*a)->type;
-      }
-    }
-    else {
-      Obj* b = (*a)->next;
-      delete *a;
-      *a = b;
-
-     continue;
-
-    }
-    a = &(*a)->next;
-  }
-  return found;
+	bool found = false;
+	Obj** a = &head;
+	
+	while (*a)
+	{
+		if ((*a)->time > gpGlobals->time)
+		{
+			if ((*a)->grenade == enemy)
+			{
+				found = true;
+				(*p) = (*a)->player;
+				type = (*a)->type;
+			}
+		} else {
+			Obj* b = (*a)->next;
+			delete *a;
+			*a = b;
+			continue;
+		}
+		a = &(*a)->next;
+	}
+	
+	return found;
 }
 
 void Grenades::clear()
 {
-  while(head){
-    Obj* a = head->next;
-    delete head;
-    head = a;
-  }
+	while (head)
+	{
+		Obj* a = head->next;
+		delete head;
+		head = a;
+	}
 }
 
 // *****************************************************
 // class XVars
 // *****************************************************
-void XVars::clear()  {
+
+void XVars::clear()
+{
 	delete[] head;
 	head = 0;
 	num = 0;
 	size = 0;
 }
 
-int XVars::put( AMX* p, cell* v )
+int XVars::put(AMX* p, cell* v)
 {
-  for(int a = 0; a < num; ++a) {
-	if ( (head[a].amx == p) && (head[a].value == v) )
-		return a;
-  }
+	for (int a = 0; a < num; ++a)
+	{
+		if ((head[a].amx == p) && (head[a].value == v))
+			return a;
+	}
 
-  if ( (num >= size) && realloc_array( size ? (size * 2) : 8 ) )
-	return -1;
+	if ((num >= size) && realloc_array(size ? (size * 2) : 8))
+		return -1;
 
-  head[num].value = v;
-  head[num].amx = p;
-  return num++;
+	head[num].value = v;
+	head[num].amx = p;
+	
+	return num++;
 }
 
-int XVars::realloc_array( int nsize )
+int XVars::realloc_array(int nsize)
 {
 	XVarEle* me = new XVarEle[nsize];
-	if ( me ){
-		for(int a = 0 ; a < num; ++a)
+	
+	if (me)
+	{
+		for (int a = 0 ; a < num; ++a)
 			me[a] = head[a];
+		
 		delete[] head;
 		head = me;
 		size = nsize;
 		return 0;
 	}
+	
 	return 1;
 }
 
 // *****************************************************
 // class TeamIds
 // *****************************************************
+
 TeamIds::TeamIds() { head = 0; newTeam = 0; }
-TeamIds::~TeamIds() {
-    while( head ) {
+
+TeamIds::~TeamIds()
+{
+	while (head)
+	{
 		TeamEle* a = head->next;
 		delete head;
 		head = a;
-    }
+	}
 }
 
-void TeamIds::registerTeam( const char* n ,int s )
+void TeamIds::registerTeam(const char* n, int s)
 {
-    TeamEle** a = &head;
-    while( *a ){
-		if ( strcmp((*a)->name.c_str(),n) == 0 ){
-			if (s != -1){
+	TeamEle** a = &head;
+	
+	while (*a)
+	{
+		if (strcmp((*a)->name.chars(),n) == 0)
+		{
+			if (s != -1)
+			{
 				(*a)->id = s;
 				newTeam &= ~(1<<(*a)->tid);				
 			}
+			
 			return;
 		}
 		a = &(*a)->next;
-    }
-    *a = new TeamEle( n , s );
-	if ( *a == 0 ) return;
-    newTeam |= (1<<(*a)->tid);
+	}
+
+	*a = new TeamEle(n, s);
+	
+	if (*a == 0)
+		return;
+	
+	newTeam |= (1<<(*a)->tid);
 }
 
-int TeamIds::findTeamId( const char* n )
+int TeamIds::findTeamId(const char* n)
 {
 	TeamEle* a = head;
-    while( a ){
-		if ( !strcmpi(a->name.c_str(),n) )
+	
+	while (a)
+	{
+		if (!stricmp(a->name.chars(), n))
 			return a->id;
 		a = a->next;
-    }
+	}
+	
 	return -1;
 }
 
-int TeamIds::findTeamIdCase( const char* n)
+int TeamIds::findTeamIdCase(const char* n)
 {
 	TeamEle* a = head;
-    while( a ){
-		if ( !strcmp(a->name.c_str(), n) )
+	
+	while (a)
+	{
+		if (!strcmp(a->name.chars(), n))
 			return a->id;
 		a = a->next;
-    }
+	}
+	
 	return -1;
 }
 
 char TeamIds::TeamEle::uid = 0;
-

amxmodx/CMisc.h

@@ -1,86 +1,51 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef CMISC_H
 #define CMISC_H
 
-#include "CList.h"
-
-// *****************************************************
-// class CCVar
-// *****************************************************
-class CCVar
-{
-    cvar_t cvar;
-    String name;
-    String plugin;
-public:	
-    CCVar( const char* pname, const char* pplugin, 
-		int pflags, float pvalue ) : name(pname) , plugin(pplugin ) {
-		cvar.name = (char*)name.c_str();
-		cvar.flags = pflags;
-		cvar.string = "";
-		cvar.value = pvalue;
-    }
-	inline cvar_t* getCvar() { return &cvar; }
-	inline const char* getPluginName() { return plugin.c_str(); }
-	inline const char* getName() { return name.c_str(); }
-	inline bool operator == ( const char* string ) { return (strcmp(name.c_str(),string)==0); }
-};
-
-
+#include "sh_list.h"
 
 // *****************************************************
 // class CPlayer
 // *****************************************************
 
+struct ClientCvarQuery_Info
+{
+	int resultFwd;
+	int requestId;
+	int paramLen;
+	cell *params;
+};
+
 class CPlayer 
 {
-	
 public:
 	edict_t* pEdict;
 	
-	String name;
-	String ip;
-	String team;
+	ke::AString name;
+	ke::AString ip;
+	ke::AString team;
 
 	bool initialized;
 	bool ingame;
-	bool bot;
 	bool authorized;
-	
+	bool disconnecting;
+	bool vgui;
+	bool teamIdsInitialized;
+
 	float time;
 	float playtime;
+	float menuexpire;
 	
-	struct {
+	struct
+	{
 		int ammo;
 		int clip;
 	} weapons[MAX_WEAPONS];
@@ -98,27 +63,39 @@ public:
 	int death_killer;
 	int death_victim;
 	bool death_tk;
-	String death_weapon;
+	ke::AString death_weapon;
+	int newmenu;
+	int page;
+
+	float channels[5];
+	cell hudmap[5];
 	
 	Vector lastTrace;
-	Vector thisTrace;
 	Vector lastHit;
 	
-	void Init( edict_t* e , int i );
+	List<ClientCvarQuery_Info *> queries;
+
+	void Init(edict_t* e, int i);
 	void Disconnect();
 	void PutInServer();
-	bool Connect(const char* connectname,const char* ipaddress);
+	
+	bool Connect(const char* connectname, const char* ipaddress);
 
-	inline bool IsBot(){
-		return ((pEdict->v.flags & FL_FAKECLIENT)?true:false);
+	inline bool IsBot()
+	{
+		const char *auth = GETPLAYERAUTHID(pEdict);
+		return auth && !strcmp(auth, "BOT");
 	}
 
-	inline bool IsAlive(){
-		return ((pEdict->v.deadflag==DEAD_NO)&&(pEdict->v.health>0));
+	inline bool IsAlive()
+	{
+		return ((pEdict->v.deadflag == DEAD_NO) && (pEdict->v.health > 0));
 	}
 
 	inline void Authorize() { authorized = true; }
 
+	int NextHUDChannel();
+
 };
 
 // *****************************************************
@@ -127,40 +104,44 @@ public:
 
 class Grenades
 {
-  struct Obj 
-  {
-    CPlayer* player;
-    edict_t* grenade;
-    float time;
-    int type;
-    Obj* next;
-  } *head;
-
+	struct Obj 
+	{
+		CPlayer* player;
+		edict_t* grenade;
+		float time;
+		int type;
+		Obj* next;
+	} *head;
 
 public:
-  Grenades() { head = 0; }
-  ~Grenades() { clear(); }
-  void put( edict_t* grenade, float time, int type, CPlayer* player  );
-  bool find( edict_t* enemy, CPlayer** p, int& type );
-  void clear();
+	Grenades() { head = 0; }
+	~Grenades() { clear(); }
+	
+	void put(edict_t* grenade, float time, int type, CPlayer* player);
+	bool find(edict_t* enemy, CPlayer** p, int& type);
+	void clear();
 };
 
 // *****************************************************
 // class ForceObject
 // *****************************************************
-class ForceObject {
-    String filename;
-    FORCE_TYPE type;
-    Vector mins;
-    Vector maxs;
-    AMX* amx;
+
+class ForceObject
+{
+	ke::AString filename;
+	FORCE_TYPE type;
+	Vector mins;
+	Vector maxs;
+	AMX* amx;
 public:
-    ForceObject(const char* n, FORCE_TYPE c,Vector& mi, Vector& ma, AMX* a) :
-    filename(n) , type(c), mins(mi), maxs(ma), amx(a) {}
-	inline const char* getFilename() { return filename.c_str(); }
+	ForceObject(const char* n, FORCE_TYPE c, Vector& mi, Vector& ma, AMX* a) : filename(n), type(c), mins(mi), maxs(ma), amx(a) {}
+
+	inline const char* getFilename() { return filename.chars(); }
 	inline AMX* getAMX() { return amx; }
+	
 	Vector& getMin() { return mins; }
 	Vector& getMax() { return maxs; }
+	
 	inline FORCE_TYPE getForceType() { return type; }
 };
 
@@ -170,81 +151,174 @@ public:
 
 class XVars
 {
-  struct XVarEle  {
-    AMX* amx;
-    cell* value;
-  };
-  
-  XVarEle* head;
-  int size;
-  int num;
+	struct XVarEle
+	{
+		AMX* amx;
+		cell* value;
+	};
 
-  int realloc_array( int nsize );
+	XVarEle* head;
+	
+	int size;
+	int num;
+	int realloc_array(int nsize);
 
 public:
-  XVars() {  num = 0;  size = 0;  head = 0; }
-  ~XVars() { clear(); }
-  void clear();
-  int put( AMX* a, cell* v );
-  inline cell getValue( int a ) {
-	  return ( a >= 0 && a < num ) ? *(head[a].value) : 0;
-  }
-  inline int setValue( int a, cell v ) { 
-	  if ( a >= 0 && a < num ){
-		*(head[a].value) = v;
-		return 0;
-	  }
-	  return 1;
-  }
+	XVars() { num = 0; size = 0; head = 0; }
+	~XVars() { clear(); }
+	
+	void clear();
+	int put(AMX* a, cell* v);
+	
+	inline cell getValue(int a)
+	{
+		return (a >= 0 && a < num) ? *(head[a].value) : 0;
+	}
+
+	inline int setValue(int a, cell v)
+	{ 
+		if (a >= 0 && a < num)
+		{
+			*(head[a].value) = v;
+			return 0;
+		}
+
+		return 1;
+	}
 };
 
 // *****************************************************
 // class CScript
 // *****************************************************
-class CScript
+
+class CScript : public ke::InlineListNode<CScript>
 {
-	String filename;
+	ke::AString filename;
 	AMX* amx;
 	void* code;
 public:
-	CScript(AMX* aa, void* cc,const char* ff):filename(ff),amx(aa),code(cc){}
+	CScript(AMX* aa, void* cc, const char* ff) : filename(ff), amx(aa), code(cc) {}
+	
 	inline AMX* getAMX() { return amx; }
-	inline const char* getName() { return filename.c_str(); }
-	inline bool operator==( void* a ) { return (amx == (AMX*)a); }
+	inline const char* getName() { return filename.chars(); }
 	inline void* getCode() { return code; }
 };
 
 // *****************************************************
 // class TeamIds
 // *****************************************************
+
 class TeamIds
 {
-  struct TeamEle {
-    String name;
-    int id;
-	char tid;
-	static char uid;
-    TeamEle* next;
-    TeamEle(const char* n, int& i) : name(n) , id(i) , next(0) {
-		tid = uid++;
-	};
-	~TeamEle(){ --uid; }
-  } *head;
+	struct TeamEle
+	{
+		ke::AString name;
+		int id;
+		char tid;
+		static char uid;
+		TeamEle* next;
+		
+		TeamEle(const char* n, int& i) : name(n), id(i), next(0)
+		{
+			tid = uid++;
+		}
+		
+		~TeamEle() { --uid; }
+	} *head;
 
-  int newTeam;
+	int newTeam;
 
 public:
-  TeamIds();
-  ~TeamIds();
-  void registerTeam( const char* n ,int s );
-  int findTeamId( const char* n);
-  int findTeamIdCase( const char* n);
-  inline bool isNewTeam() { return newTeam ? true : false; }
+	TeamIds();
+	~TeamIds();
+	
+	void registerTeam(const char* n, int s);
+	int findTeamId(const char* n);
+	int findTeamIdCase(const char* n);
+	inline bool isNewTeam() { return newTeam ? true : false; }
 };
 
+class CAdminData
+{
+private:
+	cell		m_AuthData[44];
+	cell		m_Password[32];
+	cell		m_Flags;
+	cell		m_Access;
+public:
 
+	CAdminData()
+	{
+		m_AuthData[0]=0;
+		m_Password[0]=0;
+		m_Flags=0;
+		m_Access=0;
+	};
 
-#endif
+	void SetAccess(cell Access)
+	{
+		m_Access=Access;
+	};
+	cell GetAccess(void) const
+	{
+		return m_Access;
+	};
 
+	void SetFlags(cell Flags)
+	{
+		m_Flags=Flags;
+	};
+	cell GetFlags(void) const
+	{
+		return m_Flags;
+	};
 
+	void SetAuthID(const cell *Input)
+	{
+		unsigned int i=0;
+		while (i<sizeof(m_AuthData)-1)
+		{
+			if ((m_AuthData[i++]=*Input++)==0)
+			{
+				return;
+			}
+		}
 
+		m_AuthData[arraysize(m_AuthData)-1]=0;
+
+	};
+	const cell *GetAuthID(void) const
+	{
+		return &m_AuthData[0];
+	};
+
+	void SetPass(const cell *Input)
+	{
+		unsigned int i=0;
+		while (i<sizeof(m_Password)-1)
+		{
+			if ((m_Password[i++]=*Input++)==0)
+			{
+				return;
+			}
+		}
+
+		m_Password[arraysize(m_Password)-1]=0;
+
+	};
+	const cell *GetPass(void) const
+	{
+		return &m_Password[0];
+	};
+
+	CAdminData & operator = (const CAdminData &src)
+	{
+		this->SetAccess(src.GetAccess());
+		this->SetFlags(src.GetFlags());
+		this->SetAuthID(src.GetAuthID());
+		this->SetPass(src.GetPass());
+
+		return *this;
+	}
+};
+#endif //CMISC_H

amxmodx/CModule.cpp

@@ -1,126 +1,28 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
+#include "libraries.h"
 
 #ifndef FAR
-#define FAR
+	#define FAR
 #endif
 
-// Old
-typedef int (FAR *QUERYMOD)(module_info_s**);
-typedef int (FAR *ATTACHMOD)(pfnamx_engine_g*,pfnmodule_engine_g*);
-typedef int (FAR *DETACHMOD)(void);
-
 // New
 typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/);
 typedef int (FAR *QUERYMOD_NEW)(int * /*ifvers*/, amxx_module_info_s * /*modInfo*/);
+typedef int (FAR *CHECKGAME_NEW)(const char *);
 typedef int (FAR *ATTACHMOD_NEW)(PFN_REQ_FNPTR /*reqFnptrFunc*/);
 typedef int (FAR *DETACHMOD_NEW)(void);
 typedef void (FAR *PLUGINSLOADED_NEW)(void);
-
-// Old
-// These functions are needed since Small Abstract Machine 2.5.0
-int wamx_FindPublic(AMX *amx, char *name, int *index)
-{ return amx_FindPublic(amx, name, index); }
-
-int wamx_FindPubVar(AMX *amx, char *varname, cell *amx_addr)
-{ return amx_FindPubVar(amx, varname, amx_addr); }
-
-int wamx_GetString(char *dest, cell *source)
-{ return amx_GetString(dest, source, 0); }
-
-AMX_NATIVE_INFO *wamx_NativeInfo(char *name, AMX_NATIVE func)
-{ return amx_NativeInfo(name, func); }
-
-int wamx_SetString(cell *dest, char *source, int pack)
-{ return amx_SetString(dest, source, pack, 0); }
-
-pfnamx_engine_g engAmxFunc = {
-  amx_Align16,
-  amx_Align32,
-  amx_Allot,
-  amx_Callback,
-  amx_Clone,
-  amx_Debug,
-  amx_Exec,
-  amx_Execv,
-  wamx_FindPublic,
-  wamx_FindPubVar,
-  amx_FindTagId,
-  amx_Flags,
-  amx_GetAddr,
-  amx_GetPublic,
-  amx_GetPubVar,
-  wamx_GetString,
-  amx_GetTag,
-  amx_GetUserData,
-  amx_Init,
-  amx_InitJIT,
-  amx_MemInfo,
-  amx_NameLength,
-  wamx_NativeInfo,
-  amx_NumPublics,
-  amx_NumPubVars,
-  amx_NumTags,
-  amx_RaiseError,
-  amx_Register,
-  amx_Release,
-  amx_SetCallback,
-  amx_SetDebugHook,
-  wamx_SetString,
-  amx_SetUserData,
-  amx_StrLen,
-};
-
-pfnmodule_engine_g engModuleFunc = {
-  add_amxnatives,
-  build_pathname,
-  copy_amxmemory,
-  format_amxstring,
-  get_amxaddr,
-  get_amxscript,
-  get_amxscriptname,
-  get_amxstring,
-  get_modname,
-  load_amxscript,
-  print_srvconsole,
-  report_error,
-  set_amxnatives,
-  set_amxstring,
-  amxstring_len,
-  unload_amxscript,
-  alloc_amxmemory,
-  free_amxmemory,
-};
+typedef void (*PLUGINSUNLOADED_NEW)(void);
+typedef void (*PLUGINSUNLOADING_NEW)(void);
 
 // *****************************************************
 // class CModule
@@ -128,14 +30,14 @@ pfnmodule_engine_g engModuleFunc = {
 
 CModule::CModule(const char* fname)
 {
-	m_Filename.assign(fname);
+	m_Filename = fname;
 	clear(false);
 }
 
 CModule::~CModule()
 {
 	// old & new
-	if ( m_Handle )
+	if (m_Handle)
 		DLFREE(m_Handle);
 
 	clear();
@@ -147,20 +49,94 @@ void CModule::clear(bool clearFilename)
 	m_Metamod = false;
 	m_Handle = NULL;
 	m_Status = MODULE_NONE;
-	if (clearFilename)
-		m_Filename.assign("unknown");
 
-	// old
-	m_InfoOld = NULL;
+	if (clearFilename)
+	{
+		m_Filename = "unknown";
+	}
+
 	// new
-	m_Amxx = false;
 	m_InfoNew.author = "unknown";
 	m_InfoNew.name = "unknown";
 	m_InfoNew.version = "unknown";
 	m_InfoNew.reload = 0;
 	m_MissingFunc = NULL;
 
+	for (size_t i=0; i<m_DestroyableIndexes.length(); i++)
+	{
+		delete [] m_Natives[m_DestroyableIndexes[i]];
+	}
+
+	m_DestroyableIndexes.clear();
 	m_Natives.clear();
+	m_NewNatives.clear();
+}
+
+bool CModule::attachMetamod(const char *mmfile, PLUG_LOADTIME now)
+{
+	void **handle;
+	void *dummy = NULL;
+
+	if (!m_Handle)
+		handle = &dummy;
+	else
+		handle = (void **)&m_Handle;
+
+	int res = LoadMetamodPlugin(mmfile, handle, now);
+
+	if (!res)
+	{
+		m_Metamod = false;
+	}
+
+	return true;
+}
+
+//this ugly function is ultimately something like O(n^4).
+//sigh.  it shouldn't be needed.
+void CModule::rewriteNativeLists(AMX_NATIVE_INFO *list)
+{
+	AMX_NATIVE_INFO *curlist;
+	for (size_t i=0; i<m_Natives.length(); i++)
+	{
+		curlist = m_Natives[i];
+		bool changed = false;
+		bool found = false;
+		ke::Vector<size_t> newlist;
+		for (size_t j=0; curlist[j].func != NULL; j++)
+		{
+			found = false;
+			for (size_t k=0; list[k].func != NULL; k++)
+			{
+				if (strcmp(curlist[j].name, list[k].name) == 0)
+				{
+					found = true;
+					break;
+				}
+			}
+			if (found)
+			{
+				changed = true;
+				//don't break, we have to search it all
+			} else {
+				newlist.append(j);
+			}
+		}
+		if (changed)
+		{
+			//now build the new list
+			AMX_NATIVE_INFO *rlist = new AMX_NATIVE_INFO[newlist.length()+1];
+			for (size_t j=0; j<newlist.length(); j++)
+			{
+				rlist[j].func = curlist[newlist[j]].func;
+				rlist[j].name = curlist[newlist[j]].name;
+			}
+			rlist[newlist.length()].func = NULL;
+			rlist[newlist.length()].name = NULL;
+			m_Natives[i] = rlist;
+			m_DestroyableIndexes.append(i);
+		}
+	}
 }
 
 bool CModule::attachModule()
@@ -169,26 +145,24 @@ bool CModule::attachModule()
 	if (m_Status != MODULE_QUERY || !m_Handle)
 		return false;
 
-	if (m_Amxx)
+	ATTACHMOD_NEW AttachFunc_New = (ATTACHMOD_NEW)DLPROC(m_Handle, "AMXX_Attach");
+
+	if (!AttachFunc_New)
+		return false;
+
+	g_ModuleCallReason = ModuleCall_Attach;
+	g_CurrentlyCalledModule = this;
+	int retVal = (*AttachFunc_New)(Module_ReqFnptr);
+	g_CurrentlyCalledModule = NULL;
+	g_ModuleCallReason = ModuleCall_NotCalled;
+
+	switch (retVal)
 	{
-		// new
-		ATTACHMOD_NEW AttachFunc_New = (ATTACHMOD_NEW)DLPROC(m_Handle, "AMXX_Attach");
-
-		if (!AttachFunc_New)
-			return false;
-		g_ModuleCallReason = ModuleCall_Attach;
-		g_CurrentlyCalledModule = this;
-		int retVal = (*AttachFunc_New)(Module_ReqFnptr);
-		g_CurrentlyCalledModule = NULL;
-		g_ModuleCallReason = ModuleCall_NotCalled;
-
-		switch (retVal)
-		{
 		case AMXX_OK:
 			m_Status = MODULE_LOADED;
-			return true;
+			break;
 		case AMXX_PARAM:
-			AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") retured \"Invalid parameter\" from Attach func.", m_Filename.c_str(), getVersion());
+			AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") returned \"Invalid parameter\" from Attach func.", m_Filename.chars(), getVersion());
 			m_Status = MODULE_INTERROR;
 			return false;
 		case AMXX_FUNC_NOT_PRESENT:
@@ -196,31 +170,32 @@ bool CModule::attachModule()
 			m_MissingFunc = g_LastRequestedFunc;
 			return false;
 		default:
-			AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an invalid code.",  m_Filename.c_str(), getVersion());
+			AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an invalid code.", m_Filename.chars(), getVersion());
 			m_Status = MODULE_BADLOAD;
 			return false;
-		}
 	}
-	else
-	{
-		// old
-		ATTACHMOD AttachFunc = (ATTACHMOD)DLPROC(m_Handle, "AMX_Attach");
 
-		if (AttachFunc)
-			(*AttachFunc)(&engAmxFunc,&engModuleFunc);
-		m_Status = MODULE_LOADED;
+	if (m_Status == MODULE_LOADED)
+	{
+		AddLibrariesFromString(m_InfoNew.library, LibType_Library, LibSource_Module, this);
+		AddLibrariesFromString(m_InfoNew.libclass, LibType_Class, LibSource_Module, this);
 		return true;
 	}
+
+	return false;
 }
 
 bool CModule::queryModule()
 {
-	if (m_Status != MODULE_NONE)			// don't check if already queried
+	if (m_Status != MODULE_NONE)				// don't check if already queried
 		return false;
 
-	m_Handle = DLLOAD(m_Filename.c_str());		// load file
+	m_Handle = DLLOAD(m_Filename.chars());		// load file
 	if (!m_Handle)
 	{
+#if defined(__linux__) || defined(__APPLE__)
+		AMXXLOG_Log("[AMXX] Module \"%s\" failed to load (%s)", m_Filename.chars(), dlerror());
+#endif
 		m_Status = MODULE_BADLOAD;
 		return false;
 	}
@@ -231,33 +206,60 @@ bool CModule::queryModule()
 
 	// Try new interface first
 	QUERYMOD_NEW queryFunc_New = (QUERYMOD_NEW)DLPROC(m_Handle, "AMXX_Query");
+
 	if (queryFunc_New)
 	{
-		m_Amxx = true;
 		int ifVers = AMXX_INTERFACE_VERSION;
 		g_ModuleCallReason = ModuleCall_Query;
 		g_CurrentlyCalledModule = this;
 		int retVal = (*queryFunc_New)(&ifVers, &m_InfoNew);
 		g_CurrentlyCalledModule = NULL;
 		g_ModuleCallReason = ModuleCall_NotCalled;
+
 		switch (retVal)
 		{
-		case AMXX_PARAM:
-			AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") retured \"Invalid parameter\" from Attach func.", m_Filename.c_str(), getVersion());
-			m_Status = MODULE_INTERROR;
-			return false;
-		case AMXX_IFVERS:
-			if (ifVers < AMXX_INTERFACE_VERSION)
-				m_Status = MODULE_OLD;
-			else
-				m_Status = MODULE_NEWER;
-			return false;
-		case AMXX_OK:
-			break;
-		default:
-			AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an invalid code.",  m_Filename.c_str(), getVersion());
-			m_Status = MODULE_BADLOAD;
-			return false;
+			case AMXX_PARAM:
+				AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") returned \"Invalid parameter\" from Attach func.", m_Filename.chars(), getVersion());
+				m_Status = MODULE_INTERROR;
+				return false;
+			case AMXX_IFVERS:
+				if (ifVers < AMXX_INTERFACE_VERSION)
+				{
+					//backwards compat for new defs
+					if (ifVers == 3)
+					{
+						g_ModuleCallReason = ModuleCall_Query;
+						g_CurrentlyCalledModule = this;
+						retVal = (*queryFunc_New)(&ifVers, &m_InfoNew);
+						g_CurrentlyCalledModule = NULL;
+						g_ModuleCallReason = ModuleCall_NotCalled;
+						if (retVal == AMXX_OK)
+						{
+							m_InfoNew.library = m_InfoNew.logtag;
+							if (StrCaseStr(m_InfoNew.library, "sql")
+								|| StrCaseStr(m_InfoNew.library, "dbi"))
+							{
+								m_InfoNew.libclass = "DBI";
+							} else {
+								m_InfoNew.libclass = "";
+							}
+							break;
+						}
+						return false;
+					} else {
+						m_Status = MODULE_OLD;
+						return false;
+					}
+				} else {
+					m_Status = MODULE_NEWER;
+					return false;
+				}
+			case AMXX_OK:
+				break;
+			default:
+				AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an invalid code.", m_Filename.chars(), getVersion());
+				m_Status = MODULE_BADLOAD;
+				return false;
 		}
 
 		// Check for attach
@@ -267,49 +269,38 @@ bool CModule::queryModule()
 			return false;
 		}
 
+
+		// Lastly, check to see if this module is able to load on this game mod
+		CHECKGAME_NEW checkGame_New = (CHECKGAME_NEW)DLPROC(m_Handle, "AMXX_CheckGame");
+
+		if (checkGame_New)
+		{
+			// This is an optional check; do not fail modules that do not have it
+			int ret = checkGame_New(g_mod_name.chars());
+
+			if (ret != AMXX_GAME_OK)
+			{
+				switch (ret)
+				{
+				case AMXX_GAME_BAD:
+					AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") reported that it cannot load on game \"%s\"", m_Filename.chars(), getVersion(), g_mod_name.chars());
+					m_Status = MODULE_BADGAME;
+					break;
+				default:
+					AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an unknown CheckGame code (value: %d)", m_Filename.chars(), getVersion(), ret);
+					m_Status = MODULE_BADLOAD;
+					break;
+				}
+
+				return false;
+			}
+		}
+
 		m_Status = MODULE_QUERY;
 		return true;
-	}
-	else
-	{
-		// old interface not 64 bit compatible
-#if SMALL_CELL_SIZE == 64
-		m_Status = MODULE_NOT64BIT;
+	} else {
+		m_Status = MODULE_NOQUERY;
 		return false;
-#else
-		// Try old interface
-		QUERYMOD queryFunc_Old = (QUERYMOD)DLPROC(m_Handle,"AMX_Query"); // check what version
-		if (!queryFunc_Old)
-		{
-			m_Status = MODULE_NOQUERY;
-			return false;
-		}
-
-		(*queryFunc_Old)(&m_InfoOld);
-
-		if (!m_InfoOld)
-		{
-			m_Status = MODULE_NOINFO;
-			return false;
-		}
-
-		if (m_InfoOld->ivers != AMX_INTERFACE_VERSION)
-		{
-			m_Status = MODULE_OLD;
-			return false;
-		}
-
-		// Check for attach
-		if (!DLPROC(m_Handle, "AMX_Attach"))
-		{
-			m_Status = MODULE_NOATTACH;
-			return false;
-		}
-
-		m_InfoOld->serial = (long int)this;
-		m_Status = MODULE_QUERY;
-		return true;
-#endif
 	}
 }
 
@@ -318,29 +309,62 @@ bool CModule::detachModule()
 	if (m_Status != MODULE_LOADED)
 		return false;
 
-	if (m_Amxx)
+	RemoveLibraries(this);
+
+	DETACHMOD_NEW detachFunc_New = (DETACHMOD_NEW)DLPROC(m_Handle, "AMXX_Detach");
+
+	if (detachFunc_New)
 	{
-		DETACHMOD_NEW detachFunc_New = (DETACHMOD_NEW)DLPROC(m_Handle, "AMXX_Detach");
-		if (detachFunc_New)
-		{
-			g_ModuleCallReason = ModuleCall_Detach;
-			g_CurrentlyCalledModule = this;
-			(*detachFunc_New)();
-			g_CurrentlyCalledModule = NULL;
-			g_ModuleCallReason = ModuleCall_NotCalled;
-		}
+		g_ModuleCallReason = ModuleCall_Detach;
+		g_CurrentlyCalledModule = this;
+		(*detachFunc_New)();
+		g_CurrentlyCalledModule = NULL;
+		g_ModuleCallReason = ModuleCall_NotCalled;
 	}
-	else
+
+	if (IsMetamod())
 	{
-		DETACHMOD detachFunc_Old = (DETACHMOD)DLPROC(m_Handle, "AMX_Detach");
-		if (detachFunc_Old)
-			(*detachFunc_Old)();
+		UnloadMetamodPlugin(m_Handle);
 	}
+
 	DLFREE(m_Handle);
 	clear();
+
 	return true;
 }
 
+void CModule::CallPluginsUnloaded()
+{
+	if (m_Status != MODULE_LOADED)
+		return;
+
+	if (!m_Handle)
+		return;
+
+	PLUGINSUNLOADED_NEW func = (PLUGINSUNLOADED_NEW)DLPROC(m_Handle, "AMXX_PluginsUnloaded");
+
+	if (!func)
+		return;
+
+	func();
+}
+
+void CModule::CallPluginsUnloading()
+{
+	if (m_Status != MODULE_LOADED)
+		return;
+
+	if (!m_Handle)
+		return;
+
+	PLUGINSUNLOADING_NEW func = (PLUGINSUNLOADING_NEW)DLPROC(m_Handle, "AMXX_PluginsUnloading");
+
+	if (!func)
+		return;
+
+	func();
+}
+
 void CModule::CallPluginsLoaded()
 {
 	if (m_Status != MODULE_LOADED)
@@ -350,28 +374,32 @@ void CModule::CallPluginsLoaded()
 		return;
 
 	PLUGINSLOADED_NEW func = (PLUGINSLOADED_NEW)DLPROC(m_Handle, "AMXX_PluginsLoaded");
+
 	if (!func)
 		return;
+
 	func();
 }
 
 const char* CModule::getStatus() const
 {
-	switch(m_Status)
+	switch (m_Status)
 	{
-	case MODULE_NONE:		return "error";
-	case MODULE_QUERY:		return "pending";
-	case MODULE_BADLOAD:	return "bad load";
-	case MODULE_LOADED:		return "running";
-	case MODULE_NOINFO:		return "no info";
-	case MODULE_NOQUERY:	return "no query";
-	case MODULE_NOATTACH:	return "no attach";
-	case MODULE_OLD:		return "old";
-	case MODULE_FUNCNOTPRESENT:
-	case MODULE_NEWER:		return "newer";
-	case MODULE_INTERROR:	return "internal err";
-	case MODULE_NOT64BIT:	return "not 64bit";
-	default:		break;
+		case MODULE_NONE:		return "error";
+		case MODULE_QUERY:		return "pending";
+		case MODULE_BADLOAD:	return "bad load";
+		case MODULE_LOADED:		return "running";
+		case MODULE_NOINFO:		return "no info";
+		case MODULE_NOQUERY:	return "no query";
+		case MODULE_NOATTACH:	return "no attach";
+		case MODULE_OLD:		return "old";
+		case MODULE_FUNCNOTPRESENT:
+		case MODULE_NEWER:		return "newer";
+		case MODULE_INTERROR:	return "internal err";
+		case MODULE_NOT64BIT:	return "not 64bit";
+		case MODULE_BADGAME:	return "bad game";
+		default:				break;
 	}
+
 	return "unknown";
 }

amxmodx/CModule.h

@@ -1,33 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 // *****************************************************
 // class CModule
@@ -36,19 +14,21 @@
 #ifndef CMODULE_H
 #define CMODULE_H
 
-enum MODULE_STATUS {
-  MODULE_NONE,				// No module loaded
-  MODULE_QUERY,				// Query failed
-  MODULE_BADLOAD,			// Bad file or the module writer messed something up ;]
-  MODULE_LOADED,			// Loaded
-  MODULE_NOINFO,			// No info
-  MODULE_NOQUERY,			// No query function present
-  MODULE_NOATTACH,			// No attach function present
-  MODULE_OLD,				// Old interface
-  MODULE_NEWER,				// newer interface
-  MODULE_INTERROR,			// Internal error
-  MODULE_FUNCNOTPRESENT,	// Function not present
-  MODULE_NOT64BIT			// Not 64 bit compatible
+enum MODULE_STATUS
+{
+	MODULE_NONE,			// No module loaded
+	MODULE_QUERY,			// Query failed
+	MODULE_BADLOAD,			// Bad file or the module writer messed something up ;]
+	MODULE_LOADED,			// Loaded
+	MODULE_NOINFO,			// No info
+	MODULE_NOQUERY,			// No query function present
+	MODULE_NOATTACH,		// No attach function present
+	MODULE_OLD,				// Old interface
+	MODULE_NEWER,			// newer interface
+	MODULE_INTERROR,		// Internal error
+	MODULE_FUNCNOTPRESENT,	// Function not present
+	MODULE_NOT64BIT,		// Not 64 bit compatible
+	MODULE_BADGAME,			// Module cannot load on the current game mod
 };
 
 struct amxx_module_info_s
@@ -57,22 +37,27 @@ struct amxx_module_info_s
 	const char *author;
 	const char *version;
 	int reload;				// reload on mapchange when nonzero
+	const char *logtag;		//added in version 2
+	const char *library;	// added in version 4
+	const char *libclass;	// added in version 4
 };
 
-
 #define AMXX_OK					0			/* no error */
 #define AMXX_IFVERS				1			/* interface version */
 #define AMXX_PARAM				2			/* Invalid parameter */
 #define AMXX_FUNC_NOT_PRESENT	3			/* Function not present */
 
-#define AMXX_INTERFACE_VERSION 1
+#define AMXX_GAME_OK			0			/* Module can load on this game. */
+#define AMXX_GAME_BAD			1			/* Module cannot load on this game. */
 
-class CModule 
+#define AMXX_INTERFACE_VERSION	4
+
+class CModule : public ke::InlineListNode<CModule>
 {
-	String m_Filename;				// Filename
+	ke::AString m_Filename;         // Filename
+
 	bool m_Metamod;					// Using metamod?
-	bool m_Amxx;					// Using new module interface?
-	module_info_s* m_InfoOld;		// module info (old module interface)
+
 	amxx_module_info_s m_InfoNew;	// module info (new module interface)
 	DLHANDLE m_Handle;				// handle
 	MODULE_STATUS m_Status;			// status
@@ -84,30 +69,33 @@ public:
 	~CModule();
 
 	// Interface
+
 	bool attachModule();
 	bool queryModule();
 	bool detachModule();
+	void rewriteNativeLists(AMX_NATIVE_INFO *list);
+
+	bool attachMetamod(const char *mmfile, PLUG_LOADTIME now);
+
 	const char* getStatus() const;
-	inline const char* getType() const { return m_Amxx ? "amxx" : (m_Metamod ? "amx&mm" : "amx"); }
-	inline const char* getAuthor() const { return m_Amxx ? (m_InfoNew.author) : (m_InfoOld ? m_InfoOld->author : "unknown"); }
-	inline const char* getVersion() const { return m_Amxx ? (m_InfoNew.version) : (m_InfoOld ? m_InfoOld->version : "unknown"); }
-	inline const char* getName() const { return m_Amxx ? (m_InfoNew.name) : (m_InfoOld ? m_InfoOld->name : "unknown"); }
-	inline module_info_s* getInfo() const { return m_InfoOld; }	// old
+	inline const char* getType() const { return m_Metamod ? "amxx&mm" : "amxx"; }
+	inline const char* getAuthor() const { return m_InfoNew.author; }
+	inline const char* getVersion() const { return m_InfoNew.version; }
+	inline const char* getName() const { return m_InfoNew.name; }
 	inline const amxx_module_info_s* getInfoNew() const { return &m_InfoNew; }	// new
 	inline int getStatusValue() { return m_Status; }
-	inline bool operator==( const char* fname ) { return !strcmp( m_Filename.c_str() , fname );  }
-	inline bool isReloadable() { return m_Amxx ? ((m_Status == MODULE_LOADED) && (m_InfoNew.reload != 0)) : ( (m_Status==MODULE_LOADED) && (m_InfoOld->type==RELOAD_MODULE)); }
-	inline bool isAmxx() const { return m_Amxx; }
+	inline bool isReloadable() { return ((m_Status == MODULE_LOADED) && (m_InfoNew.reload != 0)); }
 	inline const char *getMissingFunc() const { return m_MissingFunc; }
-	inline const char *getFilename() { return m_Filename.c_str(); }
-	void CModule::CallPluginsLoaded();
+	inline const char *getFilename() { return m_Filename.chars(); }
+	inline bool IsMetamod() { return m_Metamod; }
 
-	CList<AMX_NATIVE_INFO*> m_Natives;
+	void CallPluginsLoaded();
+	void CallPluginsUnloaded();
+	void CallPluginsUnloading();
+
+	ke::Vector<AMX_NATIVE_INFO*> m_Natives;
+	ke::Vector<AMX_NATIVE_INFO*> m_NewNatives; // Natives for new (AMXX, not AMX) plugins only
+	ke::Vector<size_t> m_DestroyableIndexes;
 };
 
-
-
-#endif
-
-
-
+#endif //CMODULE_H

amxmodx/CPlugin.cpp

@@ -1,93 +1,200 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
 #include "CPlugin.h"
 #include "CForward.h"
-#include "CFile.h"
+#include "amx.h"
+#include "natives.h"
+#include "debugger.h"
+#include "libraries.h"
+#include <amxmodx_version.h>
+#include "engine_strucs.h"
 
-CPluginMngr::CPlugin* CPluginMngr::loadPlugin(const char* path, const char* name, char* error, int debug) {	
+extern const char *no_function;
+
+CPluginMngr::CPlugin* CPluginMngr::loadPlugin(const char* path, const char* name, char* error, size_t maxLength, int debug)
+{
 	CPlugin** a = &head;
-	while( *a ) a = &(*a)->next;
-	*a = new CPlugin( pCounter++ ,path,name,error, debug);
+
+	while (*a)
+		a = &(*a)->next;
+
+	*a = new CPlugin(pCounter++, path, name, error, maxLength, debug);
+
 	return (*a);
 }
 
-void CPluginMngr::unloadPlugin( CPlugin** a ) {
+void CPluginMngr::unloadPlugin(CPlugin** a)
+{
 	CPlugin* next = (*a)->next;
 	delete *a;
 	*a = next;
 	--pCounter;
 }
 
-int  CPluginMngr::loadPluginsFromFile( const char* filename )
+void CPluginMngr::Finalize()
 {
-	FILE *fp = fopen(build_pathname("%s",filename) , "rt");
+	if (m_Finalized)
+		return;
 
-	if ( !fp ) 
+	pNatives = BuildNativeTable();
+	CPlugin *a = head;
+
+	while (a)
 	{
-		AMXXLOG_Log( "[AMXX] Plugins list not found (file \"%s\")",filename);
+		if (a->getStatusCode() == ps_running)
+		{
+			amx_Register(a->getAMX(), pNatives, -1);
+			a->Finalize();
+		}
+		a = a->next;
+	}
+
+	m_Finalized = true;
+}
+
+int CPluginMngr::loadPluginsFromFile(const char* filename, bool warn)
+{
+	char file[PLATFORM_MAX_PATH];
+	FILE *fp = fopen(build_pathname_r(file, sizeof(file), "%s", filename), "rt");
+
+	if (!fp)
+	{
+		if (warn)
+		{
+			AMXXLOG_Error("[AMXX] Plugins list not found (file \"%s\")", filename);
+		}
 		return 1;
 	}
-	
+
 	// Find now folder
 	char pluginName[256], error[256], debug[256];
 	int debugFlag = 0;
 	const char *pluginsDir = get_localinfo("amxx_pluginsdir", "addons/amxmodx/plugins");
-	
-	String line;
 
-	while ( !feof(fp) ) 
+	char line[512];
+
+	List<ke::AString *>::iterator block_iter;
+
+	while (!feof(fp))
 	{
-		*pluginName = 0;
-		*debug = 0;
-		debugFlag = 0;
-		line.clear();
-		line._fread(fp);
-		sscanf(line.c_str(),"%s %s",pluginName, debug);
-		if (!isalnum(*pluginName))  continue;
+		pluginName[0] = '\0';
 
-		if (isalnum(*debug) && strcmp(debug, "debug") == 0)
+		debug[0] = '\0';
+		debugFlag = 0;
+
+		line[0] = '\0';
+		fgets(line, sizeof(line), fp);
+
+		/** quick hack */
+		char *ptr = line;
+		while (*ptr)
+		{
+			if (*ptr == ';')
+			{
+				*ptr = '\0';
+			} else {
+				ptr++;
+			}
+		}
+		sscanf(line, "%s %s", pluginName, debug);
+
+		if (!isalnum(*pluginName))
+		{
+			continue;
+		}
+
+		if (isalnum(*debug) && !strcmp(debug, "debug"))
 		{
 			debugFlag = 1;
 		}
 
-		CPlugin* plugin = loadPlugin( pluginsDir , pluginName  , error,  debugFlag);
-		
+		bool skip = false;
+		for (block_iter = m_BlockList.begin();
+			 block_iter != m_BlockList.end();
+			 block_iter++)
+		{
+			if ((*block_iter)->compare(pluginName) == 0)
+			{
+				skip = true;
+				break;
+			}
+		}
+
+		if (skip || !strcmp(debug, "disabled"))
+		{
+			continue;
+		}
+
+		if (findPlugin(pluginName) != NULL)
+		{
+			continue;
+		}
+
+		CPlugin* plugin = loadPlugin(pluginsDir, pluginName, error, sizeof(error), debugFlag);
+
 		if (plugin->getStatusCode() == ps_bad_load)
 		{
 			char errorMsg[255];
 			sprintf(errorMsg, "%s (plugin \"%s\")", error, pluginName);
 			plugin->setError(errorMsg);
-			AMXXLOG_Log("[AMXX] %s", plugin->getError());
+			AMXXLOG_Error("[AMXX] %s", plugin->getError());
+		}
+		else
+		{
+			cell addr;
+			if (amx_FindPubVar(plugin->getAMX(), "MaxClients", &addr) != AMX_ERR_NOTFOUND)
+			{
+				*get_amxaddr(plugin->getAMX(), addr) = gpGlobals->maxClients;
+			}
+
+			if (amx_FindPubVar(plugin->getAMX(), "MapName", &addr) != AMX_ERR_NOTFOUND)
+			{
+				set_amxstring(plugin->getAMX(), addr, STRING(gpGlobals->mapname), MAX_MAPNAME_LENGTH - 1);
+			}
+
+			auto length = 0;
+			if (amx_FindPubVar(plugin->getAMX(), "PluginName", &addr) != AMX_ERR_NOTFOUND)
+			{
+				plugin->setTitle(get_amxstring(plugin->getAMX(), addr, 0, length));
+			}
+
+			if (amx_FindPubVar(plugin->getAMX(), "PluginVersion", &addr) != AMX_ERR_NOTFOUND)
+			{
+				plugin->setVersion(get_amxstring(plugin->getAMX(), addr, 0, length));
+			}
+
+			if (amx_FindPubVar(plugin->getAMX(), "PluginAuthor", &addr) != AMX_ERR_NOTFOUND)
+			{
+				plugin->setAuthor(get_amxstring(plugin->getAMX(), addr, 0, length));
+			}
+
+			if (amx_FindPubVar(plugin->getAMX(), "PluginURL", &addr) != AMX_ERR_NOTFOUND)
+			{
+				plugin->setUrl(get_amxstring(plugin->getAMX(), addr, 0, length));
+			}
+
+			if (amx_FindPubVar(plugin->getAMX(), "PluginDescription", &addr) != AMX_ERR_NOTFOUND)
+			{
+				plugin->setDescription(get_amxstring(plugin->getAMX(), addr, 0, length));
+			}
+
+			if (amx_FindPubVar(plugin->getAMX(), "NULL_STRING", &addr) != AMX_ERR_NOTFOUND)
+			{
+				plugin->m_pNullStringOfs = get_amxaddr(plugin->getAMX(), addr);
+			}
+
+			if (amx_FindPubVar(plugin->getAMX(), "NULL_VECTOR", &addr) != AMX_ERR_NOTFOUND)
+			{
+				plugin->m_pNullVectorOfs = get_amxaddr(plugin->getAMX(), addr);
+			}
 		}
 	}
 
@@ -96,100 +203,248 @@ int  CPluginMngr::loadPluginsFromFile( const char* filename )
 	return pCounter;
 }
 
-void CPluginMngr::clear() {
-	CPlugin**a = &head;	
-	while ( *a )
+void CPluginMngr::clear()
+{
+	CPlugin**a = &head;
+
+	while (*a)
 		unloadPlugin(a);
-}
 
-CPluginMngr::CPlugin* CPluginMngr::findPluginFast(AMX *amx) 
-{ 
-	return (CPlugin*)(amx->userdata[3]); 
-}
+	m_Finalized = false;
 
-CPluginMngr::CPlugin* CPluginMngr::findPlugin(AMX *amx) {
-	CPlugin*a = head;
-	while ( a && &a->amx != amx )
-		a=a->next;
-	return a;
-}
-	
-CPluginMngr::CPlugin* CPluginMngr::findPlugin(int index){
-	CPlugin*a = head;
-	while ( a && index--)
-		a=a->next;
-	return a;
-}
-	
-CPluginMngr::CPlugin* CPluginMngr::findPlugin(const char* name) {
-	if (!name) return 0;
-	int len = strlen(name);
-	if (!len) return 0;
-	CPlugin*a = head;
-	while( a && strncmp(a->name.c_str(), name,len) )
-		a=a->next;
-	return a;
-}
-
-const char* CPluginMngr::CPlugin::getStatus() const {
-	switch(status){
-	case ps_running: 
-			{
-					if (getAMX()->flags & AMX_FLAG_DEBUG)
-					{
-						return "debug";
-					} else {
-						return "running";
-					}
-					break;
-			}
-	case ps_paused: return "paused";
-	case ps_bad_load: return "bad load";
-	case ps_stopped: return "stopped";
-	case ps_locked: return "locked";
+	if (pNatives)
+	{
+		delete [] pNatives;
+		pNatives = NULL;
 	}
+
+	List<ke::AString *>::iterator iter = m_BlockList.begin();
+	while (iter != m_BlockList.end())
+	{
+		delete (*iter);
+		iter = m_BlockList.erase(iter);
+	}
+	m_BlockList.clear();
+}
+
+CPluginMngr::CPlugin* CPluginMngr::findPlugin(AMX *amx)
+{
+	CPlugin*a = head;
+
+	while (a && &a->amx != amx)
+		a = a->next;
+
+	return a;
+}
+
+CPluginMngr::CPlugin* CPluginMngr::findPlugin(int index)
+{
+	CPlugin*a = head;
+
+	while (a && index--)
+		a = a->next;
+
+	return a;
+}
+
+CPluginMngr::CPlugin* CPluginMngr::findPlugin(const char* name)
+{
+	if (!name)
+		return 0;
+
+	int len = strlen(name);
+
+	if (!len)
+		return 0;
+
+	CPlugin*a = head;
+
+	while (a && strncmp(a->name.chars(), name, len))
+		a = a->next;
+
+	return a;
+}
+
+void CPluginMngr::CPlugin::AddToFailCounter(unsigned int i)
+{
+	failcounter += i;
+	if ((failcounter >= 3)
+		&& (status ))
+	{
+		errorMsg = "This plugin is non-GPL which violates AMX Mod X's license.";
+		status = ps_bad_load;
+	}
+}
+
+const char* CPluginMngr::CPlugin::getStatus() const
+{
+	switch (status)
+	{
+		case ps_running:
+		{
+			if (m_Debug)
+			{
+				return "debug";
+			} else {
+				return "running";
+			}
+			break;
+		}
+		case ps_paused: return "paused";
+		case ps_bad_load: return "bad load";
+		case ps_stopped: return "stopped";
+		case ps_locked: return "locked";
+	}
+
 	return "error";
 }
 
-CPluginMngr::CPlugin::CPlugin(int i, const char* p,const char* n, char* e, int d) : name(n), title(n) {
+CPluginMngr::CPlugin::CPlugin(int i, const char* p, const char* n, char* e, size_t m, int d) : name(n), title(n), m_pNullStringOfs(nullptr), m_pNullVectorOfs(nullptr)
+{
 	const char* unk = "unknown";
-	title.assign(unk);
-	author.assign(unk);
-	version.assign(unk);
-	char* path = build_pathname("%s/%s",p,n);
+
+	failcounter = 0;
+	title = unk;
+	author = unk;
+	version = unk;
+	url = unk;
+
+	char file[PLATFORM_MAX_PATH];
+	char* path = build_pathname_r(file, sizeof(file), "%s/%s", p, n);
 	code = 0;
-	int err = load_amxscript(&amx,&code,path,e, d);
-	if ( err == AMX_ERR_NONE )
+	memset(&amx, 0, sizeof(AMX));
+	int err = load_amxscript_ex(&amx, &code, path, e, m, d);
+
+	if (err == AMX_ERR_NONE)
 	{
 		status = ps_running;
 	} else {
 		status = ps_bad_load;
 	}
-	amx.userdata[3] = this;
+
+	amx.userdata[UD_FINDPLUGIN] = this;
 	paused_fun = 0;
 	next = 0;
 	id = i;
-}
-CPluginMngr::CPlugin::~CPlugin( ){
-	unload_amxscript( &amx, &code );
-}
 
-void CPluginMngr::CPlugin::pauseFunction( int id ) { 
-	if (isValid()){
-		paused_fun |= (1<<id);
-		g_commands.clearBufforedInfo();
+	if (status == ps_running)
+	{
+		m_PauseFwd = registerSPForwardByName(&amx, "plugin_pause", FP_DONE);
+		m_UnpauseFwd = registerSPForwardByName(&amx, "plugin_unpause", FP_DONE);
+
+		if (amx.flags & AMX_FLAG_DEBUG)
+		{
+			m_Debug = true;
+		} else {
+			m_Debug = false;
+		}
 	}
 }
 
-void CPluginMngr::CPlugin::unpauseFunction( int id ) {
-	if (isValid()) {
-		paused_fun &= ~(1<<id); 
-		g_commands.clearBufforedInfo();
+CPluginMngr::CPlugin::~CPlugin()
+{
+	unload_amxscript(&amx, &code);
+}
+
+int AMXAPI native_handler(AMX *amx, int index)
+{
+	Handler *pHandler = (Handler *)amx->userdata[UD_HANDLER];
+
+	char name[sNAMEMAX + 1];
+	amx_GetNative(amx, index, name);
+
+	return pHandler->HandleNative(name, index, 0);
+}
+
+static cell AMX_NATIVE_CALL invalid_native(AMX *amx, cell *params)
+{
+	//A script has accidentally called an invalid native! give them a
+	// first chance to block the resulting error.
+
+	Handler *pHandler = (Handler *)amx->userdata[UD_HANDLER];
+
+	//this should never happen
+	if (!pHandler)
+	{
+		LogError(amx, AMX_ERR_INVNATIVE, "Invalid native attempt");
+		return 0;
+	}
+
+	//this should never happen because this native won't be called
+	// if the plugin isn't filtering.
+	if (!pHandler->IsNativeFiltering())
+	{
+		LogError(amx, AMX_ERR_INVNATIVE, "Invalid native attempt");
+		return 0;
+	}
+
+	char name[sNAMEMAX + 1];
+	int native = (int)(_INT_PTR)(amx->usertags[UT_NATIVE]);
+	int err = amx_GetNative(amx, native, name);
+
+	if (err != AMX_ERR_NONE)
+		name[0] = '\0';
+
+	//1 - because we're trapping usage
+	if (!pHandler->HandleNative(name, native, 1))
+	{
+		amx->usertags[UT_NATIVE] = (void *)native;
+		LogError(amx, AMX_ERR_INVNATIVE, NULL);
+		return 0;
+	}
+
+	//Someday maybe allow native filters to write their own return value?
+	return 0;
+}
+
+void CPluginMngr::CPlugin::Finalize()
+{
+	char buffer[128];
+	int old_status = status;
+
+	if (CheckModules(&amx, buffer))
+	{
+		if (amx_Register(&amx, core_Natives, -1) != AMX_ERR_NONE)
+		{
+			Handler *pHandler = (Handler *)amx.userdata[UD_HANDLER];
+			int res = 0;
+
+			if (pHandler->IsNativeFiltering())
+				res = amx_CheckNatives(&amx, native_handler);
+
+			if (!res)
+			{
+				status = ps_bad_load;
+				sprintf(buffer, "Plugin uses an unknown function (name \"%s\") - check your modules.ini.", no_function);
+				errorMsg = buffer;
+				amx.error = AMX_ERR_NOTFOUND;
+			} else {
+				amx_RegisterToAny(&amx, invalid_native);
+			}
+		}
+	} else {
+		status = ps_bad_load;
+		errorMsg = buffer;
+		amx.error = AMX_ERR_NOTFOUND;
+	}
+
+	if (old_status != status)
+	{
+		AMXXLOG_Log("[AMXX] Plugin \"%s\" failed to load: %s", name.chars(), errorMsg.chars());
 	}
 }
 
-void CPluginMngr::CPlugin::setStatus( int a   ) { 
-	status = a; 
+void CPluginMngr::CPlugin::pauseFunction(int id)
+{
+}
+
+void CPluginMngr::CPlugin::unpauseFunction(int id)
+{
+}
+
+void CPluginMngr::CPlugin::setStatus(int a)
+{
+	status = a;
 	g_commands.clearBufforedInfo(); // ugly way
 }
 
@@ -199,17 +454,9 @@ void CPluginMngr::CPlugin::pausePlugin()
 	if (isValid())
 	{
 		// call plugin_pause if provided
-		int func;
-		cell retval;
-		if (amx_FindPublic(&amx, "plugin_pause", &func) == AMX_ERR_NONE)
-		{
-			if (isExecutable(func))
-			{
+		if (m_PauseFwd != -1)
+			executeForwards(m_PauseFwd);
 
-				amx_Exec(&amx, &retval, func, 0);
-			}
-		}
-	
 		setStatus(ps_paused);
 	}
 }
@@ -217,20 +464,330 @@ void CPluginMngr::CPlugin::pausePlugin()
 // Unpause a plugin
 void CPluginMngr::CPlugin::unpausePlugin()
 {
-	if (isValid())
+	if (isValid() && (getStatusCode() != ps_stopped))
 	{
 		// set status first so the function will be marked executable
-
 		setStatus(ps_running);
+
 		// call plugin_unpause if provided
-		int func;
-		cell retval;
-		if (amx_FindPublic(&amx, "plugin_unpause", &func) == AMX_ERR_NONE)
+		if (m_UnpauseFwd != -1)
 		{
-			if (isExecutable(func))
-			{
-				amx_Exec(&amx, &retval, func, 0);
-			}
+			executeForwards(m_UnpauseFwd);
 		}
 	}
 }
+
+void CPluginMngr::CPlugin::AddConfig(bool create, const char *name, const char *folder)
+{
+	// Do a check for duplicates to prevent double-execution
+	for (size_t i = 0; i < m_configs.length(); ++i)
+	{
+		AutoConfig *config = m_configs[i];
+
+		if (config->autocfg.compare(name) == 0 && config->folder.compare(folder) == 0)
+		{
+			if (!config->create)
+			{
+				config->create = create;
+			}
+			return;
+		}
+	}
+
+	auto c = new AutoConfig;
+
+	c->autocfg = name;
+	c->folder = folder;
+	c->create = create;
+
+	m_configs.append(c);
+}
+
+size_t CPluginMngr::CPlugin::GetConfigCount()
+{
+	return m_configs.length();
+}
+
+AutoConfig *CPluginMngr::CPlugin::GetConfig(size_t i)
+{
+	if (i >= GetConfigCount())
+	{
+		return nullptr;
+	}
+
+	return m_configs[i];
+}
+
+
+
+char *CPluginMngr::ReadIntoOrFromCache(const char *file, size_t &bufsize)
+{
+	List<plcache_entry *>::iterator iter;
+	plcache_entry *pl;
+
+	for (iter=m_plcache.begin(); iter!=m_plcache.end(); iter++)
+	{
+		pl = (*iter);
+		if (pl->path.compare(file) == 0)
+		{
+			bufsize = pl->bufsize;
+			return pl->buffer;
+		}
+	}
+
+	pl = new plcache_entry;
+
+	pl->file = new CAmxxReader(file, sizeof(cell));
+	pl->buffer = NULL;
+	if (pl->file->GetStatus() != CAmxxReader::Err_None)
+	{
+		delete pl->file;
+		delete pl;
+		return NULL;
+	}
+
+	pl->bufsize = pl->file->GetBufferSize();
+	if (pl->bufsize)
+	{
+		pl->buffer = new char[pl->bufsize];
+		pl->file->GetSection(pl->buffer);
+	}
+
+	if (!pl->buffer || pl->file->GetStatus() != CAmxxReader::Err_None)
+	{
+		delete [] pl->buffer;
+		delete pl->file;
+		delete pl;
+		return NULL;
+	}
+
+	pl->path = file;
+
+	bufsize = pl->bufsize;
+
+	m_plcache.push_back(pl);
+
+	return pl->buffer;
+}
+
+void CPluginMngr::InvalidateCache()
+{
+	List<plcache_entry *>::iterator iter;
+	plcache_entry *pl;
+
+	for (iter=m_plcache.begin(); iter!=m_plcache.end(); iter++)
+	{
+		pl = (*iter);
+		delete [] pl->buffer;
+		delete pl->file;
+		delete pl;
+	}
+
+	m_plcache.clear();
+}
+
+void CPluginMngr::InvalidateFileInCache(const char *file, bool freebuf)
+{
+	List<plcache_entry *>::iterator iter;
+	plcache_entry *pl;
+
+	for (iter=m_plcache.begin(); iter!=m_plcache.end(); iter++)
+	{
+		pl = (*iter);
+		if (pl->path.compare(file) == 0)
+		{
+			if (freebuf)
+				delete [] pl->buffer;
+			delete pl->file;
+			delete pl;
+			m_plcache.erase(iter);
+			return;
+		}
+	}
+}
+
+void CPluginMngr::CacheAndLoadModules(const char *plugin)
+{
+	size_t progsize;
+	char *prog = ReadIntoOrFromCache(plugin, progsize);
+
+	if (!prog)
+		return;
+
+	AMX_HEADER hdr;
+	memcpy(&hdr, prog, sizeof(AMX_HEADER));
+
+	uint16_t magic = hdr.magic;
+	amx_Align16(&magic);
+
+	if (magic != AMX_MAGIC)
+	{
+		return;
+	}
+
+	if (hdr.file_version < MIN_FILE_VERSION ||
+		hdr.file_version > CUR_FILE_VERSION)
+	{
+		return;
+	}
+	if ((hdr.defsize != sizeof(AMX_FUNCSTUB)) &&
+		(hdr.defsize != sizeof(AMX_FUNCSTUBNT)))
+	{
+		return;
+	}
+
+	amx_Align32((uint32_t*)&hdr.nametable);
+	uint16_t *namelength=(uint16_t*)((unsigned char*)prog + (unsigned)hdr.nametable);
+	amx_Align16(namelength);
+	if (*namelength>sNAMEMAX)
+	{
+		return;
+	}
+
+	if (hdr.stp <= 0)
+	{
+		return;
+	}
+
+	AMX amx;
+	memset(&amx, 0, sizeof(AMX));
+	amx.base = (unsigned char *)prog;
+
+	int num;
+	char name[sNAMEMAX+1];
+
+	num = amx_GetLibraries(&amx);
+	for (int i=0; i<num; i++)
+	{
+		amx_GetLibrary(&amx, i, name, sNAMEMAX);
+		if (stricmp(name, "Float")==0)
+			continue;
+		//awful backwards compat hack
+		if (stricmp(name, "socket")==0)
+			strcpy(name, "sockets");
+		//we don't want to report failed modules here...
+		LoadModule(name, PT_ANYTIME, true, true);
+	}
+
+	cell tag_id;
+	amx_NumTags(&amx, &num);
+
+	ke::Vector<LibDecoder *> expects;
+	ke::Vector<LibDecoder *> defaults;
+	CStack<LibDecoder *> delstack;
+	for (int i=0; i<num; i++)
+	{
+		amx_GetTag(&amx, i, name, &tag_id);
+		if (name[0] == '?')
+		{
+			LibDecoder *dc = new LibDecoder;
+			delstack.push(dc);
+			if (DecodeLibCmdString(name, dc))
+			{
+				if (dc->cmd == LibCmd_ForceLib)
+				{
+					RunLibCommand(dc);
+				} else if ( (dc->cmd == LibCmd_ExpectClass) ||
+							(dc->cmd == LibCmd_ExpectLib) )
+				{
+					expects.append(dc);
+				} else if (dc->cmd == LibCmd_DefaultLib) {
+					defaults.append(dc);
+				}
+			}
+		}
+	}
+
+	for (size_t i=0; i<expects.length(); i++)
+	{
+		RunLibCommand(expects[i]);
+	}
+	for (size_t i=0; i<defaults.length(); i++)
+	{
+		RunLibCommand(defaults[i]);
+	}
+
+	expects.clear();
+	defaults.clear();
+
+	while (!delstack.empty())
+	{
+		delete delstack.front();
+		delstack.pop();
+	}
+
+	return;
+}
+
+void CPluginMngr::CALMFromFile(const char *file)
+{
+	char filename[PLATFORM_MAX_PATH];
+	FILE *fp = fopen(build_pathname_r(filename, sizeof(filename), "%s", file), "rt");
+
+	if (!fp)
+	{
+		return;
+	}
+
+	// Find now folder
+	char pluginName[256];
+	char line[256];
+	char rline[256];
+
+	while (!feof(fp))
+	{
+		fgets(line, sizeof(line)-1, fp);
+		if (line[0] == ';' || line[0] == '\n' || line[0] == '\0')
+		{
+			continue;
+		}
+
+		/** quick hack */
+		char *ptr = line;
+		while (*ptr)
+		{
+			if (*ptr == ';')
+			{
+				*ptr = '\0';
+			} else {
+				ptr++;
+			}
+		}
+
+		strncopy(rline, line, sizeof(rline));
+		UTIL_TrimLeft(rline);
+		UTIL_TrimRight(rline);
+
+		pluginName[0] = '\0';
+		sscanf(rline, "%s", pluginName);
+
+		/* HACK: see if there's a 'disabled' coming up
+		 * new block for scopying flexibility
+		 */
+		if (1)
+		{
+			const char *_ptr = rline + strlen(pluginName);
+			while (*_ptr != '\0'  && isspace(*_ptr))
+			{
+				_ptr++;
+			}
+			if ((*_ptr != '\0') && !strcmp(_ptr, "disabled"))
+			{
+				ke::AString *pString = new ke::AString(pluginName);
+				m_BlockList.push_back(pString);
+				continue;
+			}
+		}
+
+		if (!isalnum(*pluginName))
+		{
+			continue;
+		}
+
+		build_pathname_r(filename, sizeof(filename), "%s/%s", get_localinfo("amxx_pluginsdir", "addons/amxmodx/plugins"), pluginName);
+
+		CacheAndLoadModules(filename);
+	}
+
+	fclose(fp);
+}

amxmodx/CPlugin.h

@@ -1,53 +1,45 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef PLUGIN_H
 #define PLUGIN_H
 
+#include "sh_list.h"
+#include "amx.h"
+#include "amxxfile.h"
+#include <amtl/am-string.h>
+#include <amtl/am-vector.h>
+#include <amtl/am-autoptr.h>
+
 // *****************************************************
 // class CPluginMngr
 // *****************************************************
 
-enum {
-	ps_bad_load,
-	ps_error,
-	ps_paused,
-	ps_running,
-	ps_stopped,
-	ps_locked
+enum
+{
+	ps_bad_load,	//Load failed
+	ps_error,	//Erroneous state
+	ps_locked,	//UNUSED
+	ps_paused,	//Plugin is temporarily paused
+	ps_stopped,	//Plugin is ... more temporarily paused
+	ps_running,	//Plugin is running
+};
+
+struct AutoConfig
+{
+	ke::AString autocfg;
+	ke::AString folder;
+	bool create;
 };
 
 class CPluginMngr
 {
-
 public:
 
 	class iterator;
@@ -59,67 +51,98 @@ public:
 	
 		AMX amx;
 		void* code;
-		String name;
-		String version;
-		String title;
-		String author;
-		String errorMsg;
+		
+		ke::AString name;
+		ke::AString version;
+		ke::AString title;
+		ke::AString author;
+		ke::AString url;
+		ke::AString description;
+		ke::AString errorMsg;
+		
+		unsigned int failcounter;
+		int m_PauseFwd;
+		int m_UnpauseFwd;
 		int paused_fun;
 		int status;
 		CPlugin* next;
 		int id;
-		CPlugin(int i , const char* p,const char* n, char* e, int d);
-		~CPlugin( );
-
+		
+		CPlugin(int i, const char* p, const char* n, char* e, size_t m, int d);
+		~CPlugin();
+		
+		bool m_Debug;
+		cell* m_pNullStringOfs;
+		cell* m_pNullVectorOfs;
+		ke::Vector<ke::AutoPtr<AutoConfig>> m_configs;
 	public:
-
-		inline const char* getName() { return name.c_str();}
-		inline const char* getVersion() { return version.c_str();}
-		inline const char* getTitle() { return title.c_str();}
-		inline const char* getAuthor() { return author.c_str();}
-		inline const char* getError() { return errorMsg.c_str();}
+		inline const char* getName() { return name.chars();}
+		inline const char* getVersion() { return version.chars();}
+		inline const char* getTitle() { return title.chars();}
+		inline const char* getAuthor() { return author.chars();}
+		inline const char* getUrl() { return url.chars(); }
+		inline const char* getDescription() { return description.chars(); }
+		inline const char* getError() { return errorMsg.chars();}
 		inline int getStatusCode() { return status; }
 		inline int getId() const { return id; }
 		inline AMX* getAMX() { return &amx; }
 		inline const AMX* getAMX() const { return &amx; }
-		inline void setTitle( const char* n ) { title.assign(n); }
-		inline void setAuthor( const char* n ) { author.assign(n); }
-		inline void setVersion( const char* n ) { version.assign(n); }
-		inline void setError( const char* n ) { errorMsg.assign(n); }
-		inline bool isValid() const { return ((status != ps_bad_load) && (status != ps_locked)); }
-		inline bool isPaused() const { return ( (status == ps_paused) || (status == ps_stopped)); }
-		inline bool isFunctionPaused( int id ) const { return (paused_fun & (1<<id)) ? true : false; 	}
-		inline bool isExecutable(int id) const { 	return (isValid() && !isPaused() && !isFunctionPaused(id));	}
+		inline void setTitle(const char* n) { title = n; }
+		inline void setAuthor(const char* n) { author =n; }
+		inline void setVersion(const char* n) { version = n; }
+		inline void setUrl(const char* n) { url = n; }
+		inline void setDescription(const char* n) { description = n; }
+		inline void setError(const char* n) { errorMsg = n; }
+		inline bool isValid() const { return (status >= ps_paused); }
+		inline bool isPaused() const { return ((status == ps_paused) || (status == ps_stopped)); }
+		inline bool isStopped() const { return (status == ps_stopped); }
+		inline bool isExecutable(int id) const { return (isValid() && !isPaused());	}
+		
+		void Finalize();
+		void AddToFailCounter(unsigned int i);
 		void pausePlugin();
 		void unpausePlugin();
-		void pauseFunction( int id );
-		void unpauseFunction( int id );
-		void setStatus( int a   );
+		void pauseFunction(int id);
+		void unpauseFunction(int id);
+		void setStatus(int a);
+		
 		const char* getStatus() const;
+		inline bool isDebug() const { return m_Debug; }
+		inline cell* getNullStringOfs() const { return m_pNullStringOfs; }
+		inline cell* getNullVectorOfs() const { return m_pNullVectorOfs; }
+	public:
+		void AddConfig(bool create, const char *name, const char *folder);
+		size_t GetConfigCount();
+		AutoConfig *GetConfig(size_t index);
 	}; 
 	
 private:	
 	CPlugin *head;
 	int pCounter;
-
-
 public:
-	CPluginMngr() { head = 0; pCounter = 0; }
-	~CPluginMngr() { clear(); }
+	CPluginMngr() { head = 0; pCounter = 0; pNatives = NULL; m_Finalized=false;}
+	~CPluginMngr() { clear(); InvalidateCache(); }
+
+	bool m_Finalized;
+	AMX_NATIVE_INFO *pNatives;
 
 	// Interface
 
-	CPlugin* loadPlugin(const char* path, const char* name, char* error, int debug);
-	void unloadPlugin( CPlugin** a );
-	int loadPluginsFromFile( const char* filename );
-	CPlugin* findPluginFast(AMX *amx);
+	CPlugin* loadPlugin(const char* path, const char* name, char* error, size_t maxLength, int debug);
+	void unloadPlugin(CPlugin** a);
+	int loadPluginsFromFile(const char* filename, bool warn=true);
+	
+	inline CPlugin* findPluginFast(AMX *amx) { return (CPlugin*)(amx->userdata[UD_FINDPLUGIN]); }
 	CPlugin* findPlugin(AMX *amx);
 	CPlugin* findPlugin(int index);
 	CPlugin* findPlugin(const char* name);
+	
 	inline int getPluginsNum() const { return pCounter; }
+	void Finalize();
 	void clear();
 
-	class iterator {
+	class iterator
+	{
 		CPlugin *a;
 	public:
 		iterator(CPlugin*aa) : a(aa) {}
@@ -129,10 +152,25 @@ public:
 		operator bool () const { return a ? true : false; }
 		CPlugin& operator*() { return *a; }
 	};
+	
 	inline iterator begin() const { return iterator(head); }
 	inline iterator end() const { return iterator(0); }
+public:
+	struct plcache_entry
+	{
+		CAmxxReader *file;
+		size_t bufsize;
+		char *buffer;
+		ke::AString path;
+	};
+	char *ReadIntoOrFromCache(const char *file, size_t &bufsize);
+	void InvalidateCache();
+	void InvalidateFileInCache(const char *file, bool freebuf);
+	void CacheAndLoadModules(const char *plugin);
+	void CALMFromFile(const char *file);
+private:
+	List<plcache_entry *> m_plcache;
+	List<ke::AString *> m_BlockList;
 };
 
-#endif
-
-
+#endif //PLUGIN_H

amxmodx/CQueue.h

@@ -1,126 +0,0 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
-
-//by David "BAILOPAN" Anderson
-#ifndef _INCLUDE_CQUEUE_H
-#define _INCLUDE_CQUEUE_H
-
-template <class T>
-class CQueue
-{
-public:
-	class CQueueItem
-	{
-	public:
-		CQueueItem(const T &i, CQueueItem *n)
-		{
-			item = i;
-			next = n;
-		}
-		CQueueItem *GetNext()
-		{
-			return next;
-		}
-		T & GetItem()
-		{
-			return item;
-		}
-		void SetNext(CQueueItem *n)
-		{
-			next = n;
-		}
-	private:
-		T item;
-		CQueueItem *next;
-	};
-public:
-	CQueue()
-	{
-		mSize = 0;
-		mFirst = NULL;
-		mLast = NULL;
-	}
-
-	bool empty()
-	{
-		return ((mSize==0)?true:false);
-	}
-
-	void push(const T &v)
-	{
-		CQueueItem *p = new CQueueItem(v, NULL);
-		if (empty())
-		{
-			mFirst = p;
-		} else {
-			mLast->SetNext(p);
-		}
-		mLast = p;
-		mSize++;
-	}
-
-	void pop()
-	{
-		if (mFirst == mLast)
-		{
-			delete mFirst;
-			mFirst = NULL;
-			mLast = NULL;
-		} else {
-			CQueueItem *p = mFirst->GetNext();
-			delete mFirst;
-			mFirst = p;
-		}
-		mSize--;
-	}
-
-	T & front()
-	{
-		return mFirst->GetItem();
-	}
-
-	T & back()
-	{
-		return mLast->GetItem();
-	}
-
-	unsigned int size()
-	{
-		return mSize;
-	}
-private:
-	CQueueItem *mFirst;
-	CQueueItem *mLast;
-	unsigned int mSize;
-};
-
-#endif //_INCLUDE_CQUEUE_H
-

amxmodx/CString.h

@@ -1,404 +0,0 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
-
-#ifndef _INCLUDE_CSTRING_H
-#define _INCLUDE_CSTRING_H
-
-//by David "BAILOPAN" Anderson
-class String
-{
-public:
-	String() 
-	{
-		v = NULL;
-		mSize = 0;
-		cSize = 0;
-		Grow(2);
-		assign("");
-	}
-
-	~String()
-	{ 
-		if (v) 
-			delete [] v; 
-	}
-
-	String(const char *src) 
-	{
-		v = NULL; 
-		mSize = 0; 
-		cSize = 0; assign(src); 
-	}
-
-	String(String &src) 
-	{
-		v = NULL;
-		mSize = 0;
-		cSize = 0;
-		assign(src.c_str()); 
-	}
-
-	const char *c_str() { return v?v:""; }
-	const char *c_str() const { return v?v:""; }
-
-	void append(const char *t)
-	{
-		Grow(cSize + strlen(t) + 1);
-		strcat(v, t);
-		cSize = strlen(v);
-	}
-
-	void append(const char c)
-	{
-		Grow(cSize + 2);
-		v[cSize] = c;
-		v[++cSize] = 0;
-	}
-
-	void append(String &d)
-	{
-		const char *t = d.c_str();
-		Grow(cSize + strlen(t));
-		strcat(v, t);
-		cSize = strlen(v);
-	}
-
-	void assign(const String &src)
-	{
-		assign(src.c_str());
-	}
-
-	void assign(const char *d)
-	{
-		if (!d)
-		{
-			Grow(1);
-			cSize = 0;
-			strcpy(v, "");
-			return;
-		}
-		Grow(strlen(d));
-		if (v)
-		{
-			strcpy(v, d);
-			cSize = strlen(v);
-		} else {
-			cSize = 0;
-		}
-	}
-
-	void clear()
-	{
-		if (v)
-		{
-			v[0] = 0;
-			cSize = 0;
-		}
-	}
-
-	int compare (const char *d)
-	{
-		if (v) {
-			if (d) {
-				return strcmp(v, d);
-			} else {
-				return strlen(v);
-			}
-		} else {
-			if (d) {
-				return strlen(d);
-			} else {
-				return 0;
-			}
-		}
-	}
-
-	//Added this for amxx inclusion
-	bool empty()
-	{
-		if (!v || !cSize)
-			return true;
-
-		return false;
-	}
-
-	int size()
-	{
-		if (!v)
-			return 0;
-		return cSize;
-	}
-
-	const char * _fread(FILE *fp)
-	{
-		Grow(512);
-		char * ret = fgets(v, 511, fp);
-		cSize = strlen(v);
-		return ret;
-	}
-
-	int find(const char c, int index = 0)
-	{
-		if (!v)
-			return npos;
-		if (index >= (int)cSize || index < 0)
-			return npos;
-		unsigned int i = 0;
-		for (i=index; i<cSize; i++)
-		{
-			if (v[i] == c)
-			{
-				return i;
-			}
-		}
-
-		return npos;
-	}
-
-	bool is_space(int c)
-	{
-		if (c == '\f' || c == '\n' ||
-			c == '\t' || c == '\r' ||
-			c == '\v' || c == ' ')
-		{
-			return true;
-		}
-
-		return false;
-	}
-	
-	void trim()
-	{
-		if (!v)
-			return;
-		unsigned int i = 0;
-		unsigned int j = 0;
-
-		if (cSize == 1)
-		{
-			if (is_space(v[i]))
-			{
-				clear();
-				return;
-			} 
-		}
-
-		unsigned char c0 = v[0];
-
-		if (is_space(c0))
-		{
-			for (i=0; i<cSize; i++)
-			{
-				if (!is_space(v[i]) || (is_space(v[i]) && ((unsigned char)i==cSize-1)))
-				{
-					erase(0, i);
-					break;
-				}
-			}
-		}
-
-		cSize = strlen(v);
-
-		if (cSize < 1)
-		{
-			return;
-		}
-
-		if (is_space(v[cSize-1]))
-		{
-			for (i=cSize-1; i>=0; i--)
-			{
-				if (!is_space(v[i])
-					|| (is_space(v[i]) && i==0))
-				{
-					erase(i+1, j);
-					break;
-				}
-				j++;
-			}
-		}
-
-		if (cSize == 1)
-		{
-			if (is_space(v[0]))
-			{
-				clear();
-				return;
-			}
-		}
-	}
-
-	String & erase(unsigned int start, int num = npos)
-	{
-		if (!v)
-			return (*this);
-		unsigned int i = 0;
-		//check for bounds
-		if (num == npos || start+num > cSize-num+1)
-			num = cSize - start;
-		//do the erasing
-		bool copyflag = false;
-		for (i=0; i<cSize; i++)
-		{
-			if (i>=start && i<start+num)
-			{
-				if (i+num < cSize)
-				{	
-					v[i] = v[i+num];
-				} else {
-					v[i] = 0;
-				}
-				copyflag = true;
-			} else if (copyflag) {
-				if (i+num < cSize)
-				{
-					v[i] = v[i+num];
-				} else {
-					v[i] = 0;
-				}
-			}
-		}
-		cSize -= num;
-		v[cSize] = 0;
-
-		return (*this);
-	}
-
-	String substr(unsigned int index, int num = npos)
-	{
-		String ns;
-
-		if (index >= cSize || !v)
-			return ns;
-		
-		if (num == npos)
-		{
-			num = cSize - index;
-		} else if (index+num >= cSize) {
-			num = cSize - index;
-		}
-
-		unsigned int i = 0, j=0;
-		char *s = new char[cSize+1];
-
-		for (i=index; i<index+num; i++)
-		{
-			s[j++] = v[i];
-		}
-		s[j] = 0;
-
-		ns.assign(s);
-
-		delete [] s;
-
-		return ns;
-	}
-
-	void toLower()
-	{
-		if (!v)
-			return;
-		unsigned int i = 0;
-		for (i=0; i<cSize; i++)
-		{
-			if (v[i] >= 65 && v[i] <= 90)
-				v[i] |= 32;
-		}
-	}
-
-	String & operator = (const String &src)
-	{
-		assign(src);
-		return *this;
-	}
-
-	String & operator = (const char *src)
-	{
-		assign(src);
-		return *this;
-
-	}
-
-	char operator [] (unsigned int index)
-	{
-		if (index > cSize)
-		{
-			return -1;
-		} else {
-			return v[index];
-		}
-	}
-
-	int at(int a)
-	{
-		if (a < 0 || a >= (int)cSize)
-			return -1;
-
-		return v[a];
-	}
-
-	bool at(int at, char c)
-	{
-		if (at < 0 || at >= (int)cSize)
-			return false;
-
-		v[at] = c;
-
-		return true;
-	}
-
-private:
-	void Grow(unsigned int d)
-	{
-		if (d<1)
-			return;
-		if (d > mSize)
-		{
-			mSize = d + 16;	// allocate a buffer
-			char *t = new char[d+1];
-			if (v) {
-				strcpy(t, v);
-				t[cSize] = 0;
-				delete [] v;
-			}
-			v = t;
-			mSize = d;
-		}
-	}
-
-	char *v;
-	unsigned int mSize;
-	unsigned int cSize;
-public:
-	static const int npos = -1;
-};
-
-#endif //_INCLUDE_CSTRING_H

amxmodx/CTask.cpp

@@ -1,61 +1,41 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
 #include "CTask.h"
 
 /*********************** CTask ***********************/
-int CTaskMngr::CTask::getTaskId() const
-{
-	return m_iId;
-}
 
-CPluginMngr::CPlugin *CTaskMngr::CTask::getPlugin() const
-{
-	return m_pPlugin;
-}
-
-void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime)
+void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, cell iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime)
 {
+	clear();
 	m_bFree = false;
 
 	m_pPlugin = pPlugin;
 	m_iFunc = iFunc;
 	m_iId = iId;
 	m_fBase = fBase;
+	m_bInExecute = false;
 
-	m_iRepeat =		(iFlags & 1) ? iRepeat : 0;
-	m_bLoop =		(iFlags & 2) ?  true : false;
-	m_bAfterStart =	(iFlags & 4) ?  true : false;
-	m_bBeforeEnd =	(iFlags & 8) ?  true : false;
+	if (iFlags & 2)
+	{
+		m_bLoop = true;
+		m_iRepeat = -1;
+	}
+	else if (iFlags & 1)
+	{
+		m_bLoop = true;
+		m_iRepeat = iRepeat;
+	}
+	
+	m_bAfterStart =	(iFlags & 4) ? true : false;
+	m_bBeforeEnd = (iFlags & 8) ? true : false;
 
 	m_fNextExecTime = fCurrentTime + m_fBase;
 
@@ -73,17 +53,30 @@ void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags,
 
 void CTaskMngr::CTask::clear()
 {
+	m_bFree = true;
+
 	if (m_iFunc >= 0)
 	{
 		unregisterSPForward(m_iFunc);
 		m_iFunc = -1;
 	}
-	m_bFree = true;
+
 	if (m_pParams)
 	{
 		delete [] m_pParams;
 		m_pParams = NULL;
 	}
+
+	m_pPlugin = NULL;
+	m_iId = 0;
+	m_fBase = 0.0f;
+
+	m_iRepeat =	0;
+	m_bLoop = false;
+	m_bAfterStart =	false;
+	m_bBeforeEnd = false;
+
+	m_fNextExecTime = 0.0f;
 }
 
 bool CTaskMngr::CTask::isFree() const
@@ -98,12 +91,16 @@ void CTaskMngr::CTask::changeBase(float fNewBase)
 
 void CTaskMngr::CTask::resetNextExecTime(float fCurrentTime)
 {
-	m_fNextExecTime = fCurrentTime + m_fBase;
+	// If we're here while we're executing we would add m_fBase twice
+	if (!m_bInExecute)
+		m_fNextExecTime = fCurrentTime + m_fBase;
 }
 
 void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, float fTimeLeft)
 {
-	bool execute=false;
+	bool execute = false;
+	bool done = false;
+	
 	if (m_bAfterStart)
 	{
 		if (fCurrentTime - fTimeLeft + 1.0f >= m_fBase)
@@ -115,31 +112,43 @@ void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, f
 			execute = true;
 	}
 	else if (m_fNextExecTime <= fCurrentTime)
+	{
 		execute = true;
+	}
 
 	if (execute)
 	{
-		if (m_iParamLen)	// call with parameters
+		//only bother calling if we have something to call
+		if (!(m_bLoop && !m_iRepeat))
 		{
-			cell arr = prepareCellArray(m_pParams, m_iParamLen);
-			executeForwards(m_iFunc, arr, m_iId);
-		} else {
-			executeForwards(m_iFunc, m_iId);
+			m_bInExecute = true;
+			if (m_iParamLen)	// call with parameters
+			{
+				cell arr = prepareCellArray(m_pParams, m_iParamLen);
+				executeForwards(m_iFunc, arr, m_iId);
+			} else {
+				executeForwards(m_iFunc, m_iId);
+			}
+			m_bInExecute = false;
 		}
-
+	
 		if (isFree())
 			return;
 
 		// set new exec time OR remove the task if needed
-		if (m_bLoop || (--m_iRepeat > 0))
+		if (m_bLoop)
 		{
-			m_fNextExecTime += m_fBase;
+			if (m_iRepeat != -1 && --m_iRepeat <= 0)
+				done = true;
+		} else {
+			done = true;
 		}
-		else
+
+		if (done)
 		{
-			unregisterSPForward(m_iFunc);
-			m_iFunc = -1;
-			m_bFree = true;
+			clear();
+		} else {
+			m_fNextExecTime += m_fBase;
 		}
 	}
 }
@@ -147,6 +156,22 @@ void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, f
 CTaskMngr::CTask::CTask()
 {
 	m_bFree = true;
+
+	m_pPlugin = NULL;
+	m_iFunc = -1;
+	m_iId = 0;
+	m_fBase = 0.0f;
+
+	m_iRepeat =	0;
+	m_bLoop = false;
+	m_bAfterStart =	false;
+	m_bBeforeEnd = false;
+	m_bInExecute = false;
+
+	m_fNextExecTime = 0.0f;
+
+	m_iParamLen = 0;
+	m_pParams = NULL;
 }
 
 CTaskMngr::CTask::~CTask()
@@ -155,6 +180,7 @@ CTaskMngr::CTask::~CTask()
 }
 
 /*********************** CTaskMngr ***********************/
+
 CTaskMngr::CTaskMngr()
 {
 	m_pTmr_CurrentTime = NULL;
@@ -162,6 +188,11 @@ CTaskMngr::CTaskMngr()
 	m_pTmr_TimeLeft = NULL;
 }
 
+CTaskMngr::~CTaskMngr()
+{
+	clear();
+}
+
 void CTaskMngr::registerTimers(float *pCurrentTime, float *pTimeLimit, float *pTimeLeft)
 {
 	m_pTmr_CurrentTime = pCurrentTime;
@@ -169,67 +200,83 @@ void CTaskMngr::registerTimers(float *pCurrentTime, float *pTimeLimit, float *pT
 	m_pTmr_TimeLeft = pTimeLeft;
 }
 
-void CTaskMngr::registerTask(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat)
+void CTaskMngr::registerTask(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, cell iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat)
 {
 	// first, search for free tasks
-	TaskListIter iter = m_Tasks.find(CTaskDescriptor(0, NULL, true));
-	if (iter)
+	for (auto &task : m_Tasks)
 	{
-		// found: reuse it
-		iter->set(pPlugin, iFunc, iFlags, iId, fBase, iParamsLen, pParams, iRepeat, *m_pTmr_CurrentTime);
-	}
-	else
-	{
-		// not found: make a new one
-		CTask *pTmp = new CTask;
-		if (!pTmp)
+		if (task->isFree() && !task->inExecute())
+		{
+			// found: reuse it
+			task->set(pPlugin, iFunc, iFlags, iId, fBase, iParamsLen, pParams, iRepeat, *m_pTmr_CurrentTime);
 			return;
-		pTmp->set(pPlugin, iFunc, iFlags, iId, fBase, iParamsLen, pParams, iRepeat, *m_pTmr_CurrentTime);
-		m_Tasks.put(pTmp);
+		}
 	}
+	// not found: make a new one
+	auto task = ke::AutoPtr<CTask>(new CTask);
+		
+	if (!task)
+		return;
+		
+	task->set(pPlugin, iFunc, iFlags, iId, fBase, iParamsLen, pParams, iRepeat, *m_pTmr_CurrentTime);
+	m_Tasks.append(ke::Move(task));
 }
 
 int CTaskMngr::removeTasks(int iId, AMX *pAmx)
 {
-	CTaskDescriptor descriptor(iId, pAmx);
-	TaskListIter iter = m_Tasks.find(descriptor);
-	int i=0;
-	while (iter)
+	int i = 0;
+	
+	for (auto &task : m_Tasks)
 	{
-			iter->clear();
+		if (task->match(iId, pAmx))
+		{
+			task->clear();
 			++i;
-			iter = m_Tasks.find(++iter, descriptor);
+		}
 	}
+	
 	return i;
 }
 
 int CTaskMngr::changeTasks(int iId, AMX *pAmx, float fNewBase)
 {
-	CTaskDescriptor descriptor(iId, pAmx);
-	TaskListIter iter = m_Tasks.find(descriptor);
-	int i=0;
-	while (iter)
+	int i = 0;
+	
+	for (auto &task : m_Tasks)
 	{
-			iter->changeBase(fNewBase);
-			iter->resetNextExecTime(*m_pTmr_CurrentTime);
+		if (task->match(iId, pAmx))
+		{
+			task->changeBase(fNewBase);
+			task->resetNextExecTime(*m_pTmr_CurrentTime);
 			++i;
-			iter = m_Tasks.find(++iter, descriptor);
+		}
 	}
+	
 	return i;
 }
 
 bool CTaskMngr::taskExists(int iId, AMX *pAmx)
 {
-	return m_Tasks.find(CTaskDescriptor(iId, pAmx));
+	for (auto &task : m_Tasks)
+	{
+		if (task->match(iId, pAmx))
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 void CTaskMngr::startFrame()
 {
-	for (TaskListIter iter = m_Tasks.begin(); iter; ++iter)
+	auto lastSize = m_Tasks.length();
+	for(auto i = 0u; i < lastSize; i++)
 	{
-		if (iter->isFree())
+		auto &task = m_Tasks[i];
+
+		if (task->isFree())
 			continue;
-		iter->executeIfRequired(*m_pTmr_CurrentTime, *m_pTmr_TimeLimit, *m_pTmr_TimeLeft);
+		task->executeIfRequired(*m_pTmr_CurrentTime, *m_pTmr_TimeLimit, *m_pTmr_TimeLeft);
 	}
 }
 

amxmodx/CTask.h

@@ -1,33 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef CTASK_H
 #define CTASK_H
@@ -39,83 +17,69 @@ private:
 	class CTask
 	{
 		// task settings
+		
 		CPluginMngr::CPlugin *m_pPlugin;
-		int m_iId;
+		cell m_iId;
 		int m_iFunc;
 		int m_iRepeat;
+		
+		bool m_bInExecute;
 		bool m_bLoop;
 		bool m_bAfterStart;
 		bool m_bBeforeEnd;
 		float m_fBase;		// for normal tasks, stores the interval, for the others, stores the amount of time before start / after end
 		int m_iParamLen;
+		
 		cell *m_pParams;
 		bool m_bFree;
 
 		// execution
 		float m_fNextExecTime;
 	public:
-		 void set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime);
-		 void clear();
-		 bool isFree() const;
+		void set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, cell iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime);
+		void clear();
+		bool isFree() const;
 
-		 CPluginMngr::CPlugin *getPlugin() const;
-		 int getTaskId() const;
+		inline CPluginMngr::CPlugin *getPlugin() const { return m_pPlugin; }
+		inline AMX *getAMX() const { return m_pPlugin->getAMX(); }
+		inline int getTaskId() const { return m_iId; }
 
-		 void executeIfRequired(float fCurrentTime, float fTimeLimit, float fTimeLeft);	// also removes the task if needed
+		void executeIfRequired(float fCurrentTime, float fTimeLimit, float fTimeLeft);	// also removes the task if needed
 
-		 void changeBase(float fNewBase);
-		 void resetNextExecTime(float fCurrentTime);
+		void changeBase(float fNewBase);
+		void resetNextExecTime(float fCurrentTime);
+		inline bool inExecute() const { return m_bInExecute; }
 
-		 bool shouldRepeat();
+		bool shouldRepeat();
+		
+		inline bool match(int id, AMX *amx)
+		{
+			return (!m_bFree) && (amx ? getAMX() == amx : true) && (m_iId == id);
+		}
 
 		CTask();
 		~CTask();
 	};
 
-	class CTaskDescriptor
-	{
-	public:
-		int m_iId;
-		AMX *m_pAmx;
-		bool m_bFree;
-
-		CTaskDescriptor(int iId, AMX *pAmx, bool bFree = false)
-		{
-			m_iId = iId;
-			m_pAmx = pAmx;
-			m_bFree = bFree;
-		}
-
-		friend bool operator == (const CTask &left, const CTaskDescriptor &right)
-		{
-			if (right.m_bFree)
-				return left.isFree();
-			
-			return !left.isFree() &&
-				(right.m_pAmx ? left.getPlugin()->getAMX() == right.m_pAmx : true) &&
-				left.getTaskId() == right.m_iId;
-		}
-	};
-
 	/*** CTaskMngr priv members ***/
-	typedef CList<CTask, CTaskDescriptor> TaskList;
-	typedef TaskList::iterator TaskListIter;
-	TaskList m_Tasks;
+	ke::Vector<ke::AutoPtr<CTask>> m_Tasks;
+	
 	float *m_pTmr_CurrentTime;
 	float *m_pTmr_TimeLimit;
 	float *m_pTmr_TimeLeft;
 public:
 	CTaskMngr();
+	~CTaskMngr();
 
 	void registerTimers(float *pCurrentTime, float *pTimeLimit, float *pTimeLeft);	// The timers will always point to the right value
-	void registerTask(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat);
-	int removeTasks(int iId, AMX *pAmx);	// remove all tasks that match the id and amx
-	int changeTasks(int iId, AMX *pAmx, float fNewBase);	// change all tasks that match the id and amx
+	void registerTask(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, cell iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat);
+	
+	int removeTasks(int iId, AMX *pAmx);											// remove all tasks that match the id and amx
+	int changeTasks(int iId, AMX *pAmx, float fNewBase);							// change all tasks that match the id and amx
 	bool taskExists(int iId, AMX *pAmx);
+	
 	void startFrame();
 	void clear();
 };
 
-#endif
-
-
+#endif //CTASK_H

amxmodx/CTextParsers.h

@@ -0,0 +1,89 @@
+/**
+* vim: set ts=4 :
+* =============================================================================
+* SourceMod
+* Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+* =============================================================================
+*
+* This program is free software; you can redistribute it and/or modify it under
+* the terms of the GNU General Public License, version 3.0, as published by the
+* Free Software Foundation.
+*
+* 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, see <http://www.gnu.org/licenses/>.
+*
+* As a special exception, AlliedModders LLC gives you permission to link the
+* code of this program (as well as its derivative works) to "Half-Life 2," the
+* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+* by the Valve Corporation.  You must obey the GNU General Public License in
+* all respects for all other code used.  Additionally, AlliedModders LLC grants
+* this exception to all derivative works.  AlliedModders LLC defines further
+* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+* or <http://www.sourcemod.net/license.php>.
+*
+* Version: $Id$
+*/
+
+#ifndef _INCLUDE_SOURCEMOD_TEXTPARSERS_H_
+#define _INCLUDE_SOURCEMOD_TEXTPARSERS_H_
+
+#include <ITextParsers.h>
+#include <amtl/am-vector.h>
+
+/**
+* @param void *			IN: Stream pointer
+* @param char *			IN/OUT: Stream buffer
+* @param size_t			IN: Maximum size of buffer
+* @param unsigned int *	OUT: Number of bytes read (0 = end of stream)
+* @return					True on success, false on failure
+*/
+typedef bool(*STREAMREADER)(void *, char *, size_t, unsigned int *);
+
+class TextParsers :	public ITextParsers
+{
+public:
+	TextParsers();
+public:
+	bool ParseFile_INI(const char *file,
+		ITextListener_INI *ini_listener,
+		unsigned int *line,
+		unsigned int *col,
+		bool inline_comment);
+
+	SMCError ParseFile_SMC(const char *file,
+		ITextListener_SMC *smc_listener,
+		SMCStates *states);
+
+	SMCError ParseSMCFile(const char *file,
+		ITextListener_SMC *smc_listener,
+		SMCStates *states,
+		char *buffer,
+		size_t maxsize);
+
+	SMCError ParseSMCStream(const char *stream,
+		size_t length,
+		ITextListener_SMC *smc_listener,
+		SMCStates *states,
+		char *buffer,
+		size_t maxsize);
+
+	unsigned int GetUTF8CharBytes(const char *stream);
+
+	const char *GetSMCErrorString(SMCError err);
+	bool IsWhitespace(const char *stream);
+private:
+	SMCError ParseStream_SMC(void *stream,
+		STREAMREADER srdr,
+		ITextListener_SMC *smc,
+		SMCStates *states);
+};
+
+extern TextParsers g_TextParser;
+
+#endif //_INCLUDE_SOURCEMOD_TEXTPARSERS_H_
+

amxmodx/CVault.cpp

@@ -1,84 +1,63 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include "amxmodx.h"
 #include "CVault.h"
-#include "CFile.h"
+#include "CFileSystem.h"
 
 // *****************************************************
 // class Vault
 // *****************************************************
-bool Vault::exists( const char* k )
-{
-	if ( *k == 0 ) return false;
 
-	return *find( k ) != 0;
+bool Vault::exists(const char* k)
+{
+	if (*k == 0) return false;
+
+	return *find(k) != 0;
 }
 
-void Vault::put( const char* k, const char* v )
+void Vault::put(const char* k, const char* v)
 {
-	if ( *k == 0 ) return;
+	if (*k == 0) return;
 
-	if ( *v == 0 )
+	if (*v == 0)
 	{
-		remove( k );
+		remove(k);
 		return;
 	}
 
-	Obj** a = find( k );
+	Obj** a = find(k);
 
-	if ( *a )
+	if (*a)
 	{
-		(*a)->value.assign(v);
-		(*a)->number = atoi( v );
+		(*a)->value = v;
+		(*a)->number = atoi(v);
 	}
 	else
-		*a = new Obj( k , v );
-
+		*a = new Obj(k, v);
 }
 
-Vault::Obj::Obj( const char* k,  const char* v): key(k) , value(v) , next(0) {
+Vault::Obj::Obj(const char* k, const char* v): key(k), value(v), next(0)
+{
 	number = atoi(v);
 }
 
-Vault::Obj** Vault::find( const char* n )
+Vault::Obj** Vault::find(const char* n)
 {
 	Obj** a = &head;
 
-	while( *a )
+	while (*a)
 	{
-		if ( strcmp((*a)->key.c_str(), n) == 0 )
+		if (strcmp((*a)->key.chars(), n) == 0)
 			return a;
 
 		a = &(*a)->next;
@@ -88,91 +67,119 @@ Vault::Obj** Vault::find( const char* n )
 }
 
 
-int Vault::get_number( const char* n )
+int Vault::get_number(const char* n)
 {
-	if ( *n == 0 ) return 0;
+	if (*n == 0) return 0;
 
-	Obj* b = *find( n );
+	Obj* b = *find(n);
 
-	if ( b == 0 ) return 0;
+	if (b == 0) return 0;
 
 	return b->number;
 }
 
-const char* Vault::get( const char* n )
+const char* Vault::get(const char* n)
 {
-	if ( *n == 0 ) return "";
+	if (*n == 0) return "";
 
-	Obj* b = *find( n );
+	Obj* b = *find(n);
 
-	if ( b == 0 ) return "";
+	if (b == 0) return "";
 
-	return b->value.c_str();
+	return b->value.chars();
 }
 
 void Vault::clear()
 {
-	while ( head )
+	while (head)
 	{
 		Obj* a = head->next;
 		delete head;
-		head =  a;
+		head = a;
 	}
 }
 
-void Vault::remove( const char* n )
+void Vault::remove(const char* n)
 {
-	Obj** b = find( n );
+	Obj** b = find(n);
 
-	if ( *b == 0 ) return;
+	if (*b == 0) return;
 
 	Obj* a = (*b)->next;
 	delete *b;
 	*b = a;
 }
 
-void Vault::setSource( const char* n )
+void Vault::setSource(const char* n)
 {
-	path.assign(n);
+	path = n;
 }
 
-
-bool Vault::loadVault(  )
+bool Vault::loadVault()
 {
-	if ( path.empty() ) return false;
+	if (!path.length())
+	{
+		return false;
+	}
 
 	clear();
 
-	File a( path.c_str() , "r" );
+	FILE *fp = fopen(path.chars(), "r");
 
-	if ( !a ) return false;
-
-	const int sz = 512;
-	char value[sz+1];
-	char key[sz+1];
-
-	while ( a >> key && a.skipWs() && a.getline( value , sz ) )
+	if (!fp)
 	{
-		if ( isalpha ( *key ) )
-			put( key, value );
+		return false;
 	}
 
+	char lineRead[512];
+	char key[sizeof(lineRead) + 1];
+	char value[sizeof(lineRead) + 1];
+
+	while (fgets(lineRead, sizeof(lineRead), fp))
+	{
+		UTIL_TrimLeft(lineRead);
+
+		if (!*lineRead || *lineRead == ';')
+		{
+			continue;
+		}
+
+		sscanf(lineRead, "%s%*[ \t]%[^\n]", key, value);
+
+		if (isalpha(*key))
+		{
+			put(key, value);
+		}
+	}
+
+	fclose(fp);
+
 	return true;
 
 }
 
-bool Vault::saveVault( )
+bool Vault::saveVault()
 {
-	if ( path.empty() ) return false;
+	if (!path.length())
+	{
+		return false;
+	}
 
-	File a( path.c_str() , "w" );
+	FILE *fp = fopen(path.chars(), "w");
 
-	if ( !a ) return false;
+	if (!fp)
+	{
+		return false;
+	}
 
-	a << "; Don't modify!" << '\n';
+	fputs("; Don't modify!\n", fp);
 
-	for (Obj* b = head; b ;b = b->next)
-		a << b->key << '\t' << b->value << '\n';
+	for (Obj* b = head; b; b = b->next)
+	{
+		fprintf(fp, "%s\t%s\n", b->key.chars(), b->value.chars());
+	}
+
+	fclose(fp);
 
 	return true;
 }

amxmodx/CVault.h

@@ -1,93 +1,70 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef VAULT_CUSTOM_H
 #define VAULT_CUSTOM_H
 
-#include "CString.h"
-#include "CList.h"
-
 // *****************************************************
 // class Vault
 // *****************************************************
 
 class Vault
 {
-  struct Obj
-  {
-	String key;
-	String value;
-	int number;
-    Obj *next;
-	Obj( const char* k,  const char* v);
-  } *head;
+	struct Obj
+	{
+		ke::AString key;
+		ke::AString value;
 
-  String path;
+		int number;
+		Obj *next;
+		Obj(const char* k, const char* v);
+	} *head;
 
-  Obj** find( const char* n );
+	ke::AString path;
+
+	Obj** find(const char* n);
 
 public:
 
-  Vault() {head=0;}
-  ~Vault() { clear();}
+	Vault() { head = 0; }
+	~Vault() { clear(); }
 
 	// Interface
 
-  bool exists( const char* k );
-  void put(const char* k, const char* v);
-  void remove( const char* k );
-  const char* get( const char* n );
-  int get_number( const char* n );
-  void setSource( const char* n );
-  bool loadVault( );
-  bool saveVault( );
-  void clear();
+	bool exists(const char* k);
+	
+	void put(const char* k, const char* v);
+	void remove(const char* k);
+	
+	const char* get(const char* n);
+	int get_number(const char* n);
+	void setSource(const char* n);
+	
+	bool loadVault();
+	bool saveVault();
+	
+	void clear();
 
+	class iterator
+	{
+		Obj * a;
+	public:
+		iterator(Obj* aa) : a(aa) {}
+		iterator& operator++() { if (a) a = a->next; return *this; }
+		bool operator==(const iterator& b) const { return a == b.a; }
+		bool operator!=(const iterator& b) const { return !operator==(b); }
+		ke::AString& key() const { return a->key; }
+		ke::AString& value() const { return a->value; }
+	};
 
-  class iterator {
-	Obj * a;
-  public:
-	iterator(Obj*aa) : a(aa) {}
-	iterator& operator++() { if ( a ) a = a->next; return *this; }
-	bool operator==(const iterator& b) const { return a == b.a; }
-	bool operator!=(const iterator& b) const { return !operator==(b); }
-	String& key() const { return a->key; }
-	String& value() const { return a->value; }
-  };
-
-  inline iterator begin() const { return iterator(head); }
-  inline iterator end() const { return iterator(0); }
+	inline iterator begin() const { return iterator(head); }
+	inline iterator end() const { return iterator(0); }
 };
 
-#endif
-
-
-
+#endif //VAULT_CUSTOM_H

amxmodx/CVector.h

@@ -1,444 +0,0 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
-
-#ifndef __CVECTOR_H__
-#define __CVECTOR_H__
-
-#include <assert.h>
-
-// Vector
-template <class T> class CVector
-{
-	bool Grow()
-	{
-		// automatic grow
-		size_t newSize = m_Size * 2;
-		if (newSize == 0)
-			newSize = 8;					// a good init value
-		T *newData = new T[newSize];
-		if (!newData)
-			return false;
-		if (m_Data)
-		{
-			memcpy(newData, m_Data, m_Size * sizeof(T));
-			delete [] m_Data;
-		}
-		m_Data = newData;
-		m_Size = newSize;
-		return true;
-	}
-
-	bool GrowIfNeeded()
-	{
-		if (m_CurrentUsedSize >= m_Size)
-			return Grow();
-		else
-			return true;
-	}
-
-	bool ChangeSize(size_t size)
-	{
-		// change size
-		if (size == m_Size)
-			return true;
-		T *newData = new T[size];
-		if (!newData)
-			return false;
-		if (m_Data)
-		{
-			memcpy(newData, m_Data, (m_Size < size) ? (m_Size * sizeof(T)) : (size * sizeof(T)));
-			delete [] m_Data;
-		}
-		if (m_Size < size)
-			m_CurrentSize = size;
-		m_Data = newData;
-		m_Size = size;
-		return true;
-	}
-
-	void FreeMemIfPossible()
-	{
-
-	}
-protected:
-	T *m_Data;
-	size_t m_Size;
-	size_t m_CurrentUsedSize;
-	size_t m_CurrentSize;
-public:
-	class iterator
-	{
-	protected:
-		T *m_Ptr;
-	public:
-		// constructors / destructors
-		iterator()
-		{
-			m_Ptr = NULL;
-		}
-
-		iterator(T * ptr)
-		{
-			m_Ptr = ptr;
-		}
-
-		// member functions
-		T * base()
-		{
-			return m_Ptr;
-		}
-
-		const T * base() const
-		{
-			return m_Ptr;
-		}
-
-		// operators
-		T & operator*()
-		{
-			return *m_Ptr;
-		}
-
-		T * operator->()
-		{
-			return m_Ptr;
-		}
-
-		iterator & operator++()		// preincrement
-		{
-			++m_Ptr;
-			return (*this);
-		}
-
-		iterator operator++(int)	// postincrement
-		{
-			iterator tmp = *this;
-			++m_Ptr;
-			return tmp;
-		}
-
-		iterator & operator--()		// predecrement
-		{
-			--m_Ptr;
-			return (*this);
-		}
-
-		iterator operator--(int)	// postdecrememnt
-		{
-			iterator tmp = *this;
-			--m_Ptr;
-			return tmp;
-		}
-
-		bool operator==(T * right) const
-		{
-			return (m_Ptr == right);
-		}
-
-		bool operator==(const iterator & right) const
-		{
-			return (m_Ptr == right.m_Ptr);
-		}
-
-		bool operator!=(T * right) const
-		{
-			return (m_Ptr != right);
-		}
-
-		bool operator!=(const iterator & right) const
-		{
-			return (m_Ptr != right.m_Ptr);
-		}
-
-		iterator & operator+=(size_t offset)
-		{
-			m_Ptr += offset;
-			return (*this);
-		}
-
-		iterator & operator-=(size_t offset)
-		{
-			m_Ptr += offset;
-			return (*this);
-		}
-
-		iterator operator+(size_t offset) const
-		{
-			iterator tmp(*this);
-			tmp.m_Ptr += offset;
-			return tmp;
-		}
-
-		iterator operator-(size_t offset) const
-		{
-			iterator tmp(*this);
-			tmp.m_Ptr += offset;
-			return tmp;
-		}
-		
-		T & operator[](size_t offset)
-		{
-			return (*(*this + offset));
-		}
-
-		const T & operator[](size_t offset) const
-		{
-			return (*(*this + offset));
-		}
-
-		bool operator<(const iterator & right) const
-		{
-			return m_Ptr < right.m_Ptr;
-		}
-
-		bool operator>(const iterator & right) const
-		{
-			return m_Ptr > right.m_Ptr;
-		}
-
-		bool operator<=(const iterator & right) const
-		{
-			return m_Ptr <= right.m_Ptr;
-		}
-
-		bool operator>=(const iterator & right) const
-		{
-			return m_Ptr >= right.m_Ptr;
-		}
-
-		size_t operator-(const iterator & right) const
-		{
-			return m_Ptr - right.m_Ptr;
-		}
-	};
-
-	// constructors / destructors
-	CVector<T>()
-	{
-		m_Size = 0;
-		m_CurrentUsedSize = 0;
-		m_Data = NULL;
-	}
-
-	CVector<T>(const CVector<T> & other)
-	{
-		// copy data
-		m_Data = new T [other.m_Size];
-		m_Size = other.m_Size;
-		m_CurrentUsedSize = other.m_CurrentUsedSize;
-		memcpy(m_Data, other.m_Data, m_CurrentUsedSize * sizeof(T));
-	}
-
-	~CVector<T>()
-	{
-		clear();
-	}
-
-	// interface
-	size_t size() const
-	{
-		return m_CurrentUsedSize;
-	}
-
-	size_t capacity() const
-	{
-		return m_Size;
-	}
-
-	iterator begin()
-	{
-		return iterator(m_Data);
-	}
-
-	iterator end()
-	{
-		return iterator(m_Data + m_CurrentUsedSize);
-	}
-
-	iterator iterAt(size_t pos)
-	{
-		if (pos > m_CurrentUsedSize)
-			assert(0);
-		return iterator(m_Data + pos);
-	}
-
-	bool reserve(size_t newSize)
-	{
-		return ChangeSize(newSize);
-	}
-
-	bool push_back(const T & elem)
-	{
-		++m_CurrentUsedSize;
-		if (!GrowIfNeeded())
-		{
-			--m_CurrentUsedSize;
-			return false;
-		}
-
-		m_Data[m_CurrentUsedSize - 1] = elem;
-		return true;
-	}
-
-	void pop_back()
-	{
-		--m_CurrentUsedSize;
-		if (m_CurrentUsedSize < 0)
-			m_CurrentUsedSize = 0;
-		// :TODO: free memory sometimes
-	}
-
-	bool resize(size_t newSize)
-	{
-		if (!ChangeSize(newSize))
-			return false;
-		FreeMemIfPossible();
-		return true;
-	}
-
-	bool empty() const
-	{
-		return (m_CurrentUsedSize == 0);
-	}
-
-	T & at(size_t pos)
-	{
-		if (pos > m_CurrentUsedSize)
-		{
-			assert(0);
-		}
-		return m_Data[pos];
-	}
-
-	const  T & at(size_t pos) const
-	{
-		if (pos > m_CurrentUsedSize)
-		{
-			assert(0);
-		}
-		return m_Data[pos];
-	}
-
-	T & operator[](size_t pos)
-	{
-		return at(pos);
-	}
-
-	const T & operator[](size_t pos) const
-	{
-		return at(pos);
-	}
-
-	T & front()
-	{
-		if (m_CurrentUsedSize < 1)
-		{
-			assert(0);
-		}
-		return m_Data[0];
-	}
-
-	const T & front() const
-	{
-		if (m_CurrentUsedSize < 1)
-		{
-			assert(0);
-		}
-		return m_Data[0];
-	}
-
-	T & back()
-	{
-		if (m_CurrentUsedSize < 1)
-		{
-			assert(0);
-		}
-		return m_Data[m_CurrentUsedSize - 1];
-	}
-
-	const T & back() const
-	{
-		if (m_CurrentUsedSize < 1)
-		{
-			assert(0);
-		}
-		return m_Data[m_CurrentUsedSize - 1];
-	}
-
-	bool insert(iterator where, const T & value)
-	{
-		// we have to insert before
-		// if it is begin, don't decrement
-		if (where != m_Data)
-			--where;
-		// validate iter
-		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
-			return false;
-
-		++m_CurrentUsedSize;
-		if (!GrowIfNeeded())
-		{
-			--m_CurrentUsedSize;
-			return false;
-		}
-
-		memmove(where.base() + 1, where.base(), m_CurrentUsedSize - (where - m_Data));
-		memcpy(where.base(), &value, sizeof(T));
-		return true;
-	}
-
-	void erase(iterator where)
-	{
-		// validate iter
-		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
-			return false;
-
-		if (m_CurrentUsedSize > 1)
-		{
-			// move
-			memmove(where.base(), where.base() + 1, m_CurrentUsedSize - 1);
-		}
-
-		--m_CurrentUsedSize;
-		// :TODO: free memory sometimes
-	}
-
-	void clear()
-	{
-		m_Size = 0;
-		m_CurrentUsedSize = 0;
-		delete [] m_Data;
-		m_Data = NULL;
-	}
-};
-
-#endif // __CVECTOR_H__
-

amxmodx/CoreConfig.cpp

@@ -0,0 +1,340 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "amxmodx.h"
+#include "CoreConfig.h"
+#include "CLibrarySys.h"
+#include <amxmodx_version.h>
+
+CoreConfig CoreCfg;
+
+const char *MainConfigFile = "amxx.cfg";
+const char *AutoConfigDir  = "/plugins";
+const char *MapConfigDir   = "/maps";
+const char *CommandFormat  = "exec %s\n";
+
+CoreConfig::CoreConfig()
+{
+	Clear();
+}
+
+CoreConfig::~CoreConfig()
+{
+}
+
+void CoreConfig::OnAmxxInitialized()
+{
+	m_ConfigsBufferedForward = registerForward("OnAutoConfigsBuffered", ET_IGNORE, FP_DONE);
+	m_ConfigsExecutedForward = registerForward("OnConfigsExecuted", ET_IGNORE, FP_DONE);
+}
+
+void CoreConfig::Clear()
+{
+	m_ConfigsExecuted = false;
+	m_PendingForwardPush = false;
+	m_LegacyMainConfigExecuted = false;
+	m_LegacyMapConfigsExecuted = false,
+	m_legacyMapConfigNextTime = 0.0f;
+}
+
+void CoreConfig::ExecuteMainConfig()
+{
+	if (m_LegacyMainConfigExecuted)
+	{
+		return;
+	}
+
+	char path[PLATFORM_MAX_PATH];
+	char command[PLATFORM_MAX_PATH + sizeof(CommandFormat)];
+
+	ke::SafeSprintf(path, sizeof(path), "%s/%s/%s", g_mod_name.chars(), get_localinfo("amxx_configsdir", "addons/amxmodx/configs"), MainConfigFile);
+	ke::SafeSprintf(command, sizeof(command), CommandFormat, path);
+
+	SERVER_COMMAND(command);
+}
+
+void CoreConfig::ExecuteAutoConfigs()
+{
+	for (size_t i = 0; i < static_cast<size_t>(g_plugins.getPluginsNum()); ++i)
+	{
+		auto plugin = g_plugins.findPlugin(i);
+
+		bool can_create = true;
+
+		for (size_t j = 0; j < plugin->GetConfigCount(); ++j)
+		{
+			can_create = ExecuteAutoConfig(plugin, plugin->GetConfig(j), can_create);
+		}
+	}
+
+	executeForwards(m_ConfigsBufferedForward);
+}
+
+bool CoreConfig::ExecuteAutoConfig(CPluginMngr::CPlugin *plugin, AutoConfig *config, bool can_create)
+{
+	bool will_create = false;
+
+	const char *configsDir = get_localinfo("amxx_configsdir", "addons/amxmodx/configs");
+
+	if (can_create && config->create)
+	{
+		will_create = true;
+
+		const char *folder = config->folder.chars();
+
+		char path[PLATFORM_MAX_PATH];
+		char build[PLATFORM_MAX_PATH];
+
+		build_pathname_r(path, sizeof(path), "%s%s/%s", configsDir, AutoConfigDir, folder);
+
+		if (!g_LibSys.IsPathDirectory(path))
+		{
+			char *cur_ptr = path;
+
+			g_LibSys.PathFormat(path, sizeof(path), "%s", folder);
+			build_pathname_r(build, sizeof(build), "%s%s", configsDir, AutoConfigDir);
+
+			size_t length = strlen(build);
+
+			do
+			{
+				char *next_ptr = cur_ptr;
+
+				while (*next_ptr != '\0')
+				{
+					if (*next_ptr == PLATFORM_SEP_CHAR)
+					{
+						*next_ptr = '\0';
+						next_ptr++;
+						break;
+					}
+
+					next_ptr++;
+				}
+
+				if (*next_ptr == '\0')
+				{
+					next_ptr = nullptr;
+				}
+
+				length += g_LibSys.PathFormat(&build[length], sizeof(build) - length, "/%s", cur_ptr);
+
+				if (!g_LibSys.CreateFolder(build))
+				{
+					break;
+				}
+
+				cur_ptr = next_ptr;
+
+			} while (cur_ptr);
+		}
+	}
+
+	char file[PLATFORM_MAX_PATH];
+
+	if (config->folder.length())
+	{
+		ke::SafeSprintf(file, sizeof(file), "%s/%s%s/%s/%s.cfg", g_mod_name.chars(), configsDir, AutoConfigDir, config->folder.chars(), config->autocfg.chars());
+	}
+	else
+	{
+		ke::SafeSprintf(file, sizeof(file), "%s/%s%s/%s.cfg", g_mod_name.chars(), configsDir, AutoConfigDir, config->autocfg.chars());
+	}
+
+	bool file_exists = g_LibSys.IsPathFile(file);
+
+	if (!file_exists && will_create)
+	{
+		auto list = g_CvarManager.GetCvarsList();
+
+		if (list->empty())
+		{
+			return can_create;
+		}
+
+		FILE *fp = fopen(file, "wt");
+
+		if (fp)
+		{
+			fprintf(fp, "// This file was auto-generated by AMX Mod X (v%s)\n", AMXX_VERSION);
+
+			if (*plugin->getTitle() && *plugin->getAuthor() && *plugin->getVersion())
+			{
+				fprintf(fp, "// Cvars for plugin \"%s\" by \"%s\" (%s, v%s)\n", plugin->getTitle(), plugin->getAuthor(), plugin->getName(), plugin->getVersion());	
+			}
+			else
+			{
+				fprintf(fp, "// Cvars for plugin \"%s\"\n", plugin->getName());
+			}
+
+			fprintf(fp, "\n\n");
+
+			for (auto iter = list->begin(); iter != list->end(); iter++)
+			{
+				auto info = (*iter);
+
+				if (info->pluginId == plugin->getId())
+				{
+					char description[255];
+					char *ptr = description;
+
+					// Print comments until there is no more
+					strncopy(description, info->description.chars(), sizeof(description));
+
+					while (*ptr != '\0')
+					{
+						// Find the next line
+						char *next_ptr = ptr;
+
+						while (*next_ptr != '\0')
+						{
+							if (*next_ptr == '\n')
+							{
+								*next_ptr = '\0';
+								next_ptr++;
+								break;
+							}
+
+							next_ptr++;
+						}
+
+						fprintf(fp, "// %s\n", ptr);
+
+						ptr = next_ptr;
+					}
+
+					fprintf(fp, "// -\n");
+					fprintf(fp, "// Default: \"%s\"\n", info->defaultval.chars());
+
+					if (info->bound.hasMin)
+					{
+						fprintf(fp, "// Minimum: \"%02f\"\n", info->bound.minVal);
+					}
+
+					if (info->bound.hasMax)
+					{
+						fprintf(fp, "// Maximum: \"%02f\"\n", info->bound.maxVal);
+					}
+
+					fprintf(fp, "%s \"%s\"\n", info->var->name, info->defaultval.chars());
+					fprintf(fp, "\n");
+				}
+			}
+
+			fprintf(fp, "\n");
+
+			file_exists = true;
+			can_create = false;
+
+			fclose(fp);
+		}
+		else
+		{
+			AMXXLOG_Error("Failed to auto generate config for %s, make sure the directory has write permission.", plugin->getName());
+			return can_create;
+		}
+	}
+
+	if (file_exists)
+	{
+		char command[PLATFORM_MAX_PATH + sizeof(CommandFormat)];
+		ke::SafeSprintf(command, sizeof(command), CommandFormat, file);
+
+		SERVER_COMMAND(command);
+	}
+
+	return can_create;
+}
+
+void CoreConfig::ExecuteMapConfig()
+{
+	const char *configsDir = get_localinfo("amxx_configsdir", "addons/amxmodx/configs");
+
+	char cfgPath[PLATFORM_MAX_PATH];
+	char mapName[PLATFORM_MAX_PATH];
+	char command[PLATFORM_MAX_PATH + sizeof(CommandFormat)];
+
+	strncopy(mapName, STRING(gpGlobals->mapname), sizeof(mapName));
+
+	char *mapPrefix;
+
+	if ((mapPrefix = strtok(mapName, "_")))
+	{
+		ke::SafeSprintf(cfgPath, sizeof(cfgPath), "%s/%s%s/prefix_%s.cfg", g_mod_name.chars(), configsDir, MapConfigDir, mapPrefix);
+
+		if (g_LibSys.IsPathFile(cfgPath))
+		{
+			ke::SafeSprintf(command, sizeof(command), CommandFormat, cfgPath);
+			SERVER_COMMAND(command);
+		}
+	}
+
+	strncopy(mapName, STRING(gpGlobals->mapname), sizeof(mapName));
+	ke::SafeSprintf(cfgPath, sizeof(cfgPath), "%s/%s%s/%s.cfg", g_mod_name.chars(), configsDir, MapConfigDir, mapName);
+
+	if (g_LibSys.IsPathFile(cfgPath))
+	{
+		ke::SafeSprintf(command, sizeof(command), CommandFormat, cfgPath);
+		SERVER_COMMAND(command);
+	}
+
+	// Consider all configs be executed to the next frame.
+	m_PendingForwardPush = true;
+}
+
+
+void CoreConfig::OnMapConfigTimer()
+{
+	if (m_ConfigsExecuted)
+	{
+		return;
+	}
+
+	if (m_legacyMapConfigNextTime <= gpGlobals->time)
+	{
+		if (m_PendingForwardPush)
+		{
+			m_PendingForwardPush = false;
+			m_ConfigsExecuted = true;
+
+			executeForwards(m_ConfigsExecutedForward);
+		}
+		else if (!m_LegacyMapConfigsExecuted)
+		{
+			ExecuteMapConfig();
+		}
+	}
+}
+
+void CoreConfig::CheckLegacyBufferedCommand(char *command)
+{
+	if (m_ConfigsExecuted)
+	{
+		return;
+	}
+
+
+	if (!m_LegacyMainConfigExecuted && strstr(command, MainConfigFile))
+	{
+		m_LegacyMainConfigExecuted = true;
+	}
+
+	if (!m_LegacyMapConfigsExecuted && strstr(command, MapConfigDir))
+	{
+		m_LegacyMapConfigsExecuted = true;
+		
+		// Consider all configs be executed to m_legacyMapConfigNextTime time.
+		m_PendingForwardPush = true;
+	}
+}
+
+void CoreConfig::SetMapConfigTimer(float time)
+{
+	m_legacyMapConfigNextTime = gpGlobals->time + time;
+}

amxmodx/CoreConfig.h

@@ -0,0 +1,51 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef _CORE_CONFIG_H_
+#define _CORE_CONFIG_H_
+
+#include "CPlugin.h"
+
+class CoreConfig
+{
+	public:
+
+		CoreConfig();
+		~CoreConfig();
+
+	public:
+
+		void Clear();
+
+		void ExecuteMainConfig();
+		void ExecuteAutoConfigs();
+		bool ExecuteAutoConfig(CPluginMngr::CPlugin *plugin, AutoConfig *config, bool can_create);
+		void ExecuteMapConfig();
+
+		void OnAmxxInitialized();
+		void OnMapConfigTimer();
+
+		void CheckLegacyBufferedCommand(char *command);
+		void SetMapConfigTimer(float time);
+
+	private:
+
+		bool  m_ConfigsExecuted;          // Whether all configs have been executed
+		bool  m_PendingForwardPush;       // Whether OnConfigsExecuted forward should be triggered to the next frame
+		bool  m_LegacyMainConfigExecuted; // Whether the old admin.sma is used and amxx.cfg was executed from there
+		bool  m_LegacyMapConfigsExecuted; // Whether the old admin.sma is used and per-map config was executed from there
+		float m_legacyMapConfigNextTime;  // Sets the next time that per-map configs should be executed
+
+		int m_ConfigsBufferedForward;
+		int m_ConfigsExecutedForward;
+};
+
+extern CoreConfig CoreCfg;
+
+#endif // _CORE_CONFIG_H_

amxmodx/CvarManager.cpp

@@ -0,0 +1,669 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "CvarManager.h"
+#include "amxmodx.h"
+#include <CDetour/detours.h>
+#include <auto-string.h>
+#include <resdk/mod_rehlds_api.h>
+
+CvarManager g_CvarManager;
+
+void (*Cvar_DirectSet_Actual)(struct cvar_s* var, const char *value) = nullptr;
+
+void Cvar_DirectSet_Custom(struct cvar_s *var, const char *value, IRehldsHook_Cvar_DirectSet *chain = nullptr)
+{
+	CvarInfo* info = nullptr;
+
+	if (!var || !value                                    // Sanity checks against bogus pointers.
+		|| strcmp(var->string, value) == 0                // Make sure old and new values are different to not trigger callbacks.
+		|| !g_CvarManager.CacheLookup(var->name, &info))  // No data in cache, nothing to do.
+	{
+		chain ? chain->callNext(var, value) : Cvar_DirectSet_Actual(var, value);
+		return;
+	}
+
+	if (info->bound.hasMin || info->bound.hasMax) // cvar_s doesn't have min/max mechanism, so we check things here.
+	{
+		float fvalue = atof(value);
+		bool oob = false;
+
+		if (info->bound.hasMin && fvalue < info->bound.minVal)
+		{
+			oob = true;
+			fvalue = info->bound.minVal;
+		}
+		else if (info->bound.hasMax && fvalue > info->bound.maxVal)
+		{
+			oob = true;
+			fvalue = info->bound.maxVal;
+		}
+
+		if (oob) // Found value out of bound, set new value and block original call.
+		{
+			CVAR_SET_FLOAT(var->name, fvalue);
+			return;
+		}
+	}
+
+	ke::AString oldValue; // We save old value since it will be likely changed after original function called.
+
+	if (!info->hooks.empty())
+	{
+		oldValue = var->string;
+	}
+
+	chain ? chain->callNext(var, value) : Cvar_DirectSet_Actual(var, value);
+
+	if (!info->binds.empty())
+	{
+		for (size_t i = 0; i < info->binds.length(); ++i)
+		{
+			CvarBind* bind = info->binds[i];
+
+			switch (bind->type)
+			{
+				case CvarBind::CvarType_Int:
+				{
+					*bind->varAddress = atoi(var->string);
+					break;
+				}
+				case CvarBind::CvarType_Float:
+				{
+					float fvalue = atof(var->string);
+					*bind->varAddress = amx_ftoc(fvalue);
+					break;
+				}
+				case CvarBind::CvarType_String:
+				{
+					set_amxstring_simple(bind->varAddress, var->string, bind->varLength);
+					break;
+				}
+			}
+		}
+	}
+
+	if (!info->hooks.empty())
+	{
+		for (size_t i = 0; i < info->hooks.length(); ++i)
+		{
+			CvarHook* hook = info->hooks[i];
+
+			if (hook->forward->state == AutoForward::FSTATE_OK) // Our callback can be enable/disabled by natives.
+			{
+				executeForwards(hook->forward->id, reinterpret_cast<cvar_t*>(var), oldValue.chars(), var->string);
+			}
+		}
+	}
+}
+
+void Cvar_DirectSet(struct cvar_s *var, const char *value)
+{
+	Cvar_DirectSet_Custom(var, value);
+}
+
+void Cvar_DirectSet_RH(IRehldsHook_Cvar_DirectSet *chain, cvar_t *var, const char *value)
+{
+	Cvar_DirectSet_Custom(var, value, chain);
+}
+
+
+CvarManager::CvarManager() : m_AmxmodxCvars(0), m_HookDetour(nullptr), m_ReHookEnabled(false)
+{
+}
+
+CvarManager::~CvarManager()
+{
+	OnAmxxShutdown();
+}
+
+void CvarManager::CreateCvarHook(void)
+{
+	// void PF_Cvar_DirectSet(struct cvar_s *var, const char *value) // = pfnCvar_DirectSet
+	// {
+	//   	Cvar_DirectSet(var, value); // <- We want to hook this.
+	// }
+
+	if (!RehldsHookchains)
+	{
+		void *functionAddress = nullptr;
+
+		if (CommonConfig && CommonConfig->GetMemSig("Cvar_DirectSet", &functionAddress) && functionAddress)
+		{
+			// Disabled by default.
+			m_HookDetour = DETOUR_CREATE_STATIC_FIXED(Cvar_DirectSet, functionAddress);
+		}
+		else
+		{
+			AMXXLOG_Log("Binding/Hooking cvars have been disabled - %s.", RehldsApi ? "update ReHLDS" : "check your gamedata files");
+		}
+	}
+}
+
+void CvarManager::EnableHook()
+{
+	if (RehldsHookchains)
+	{
+		if (!m_ReHookEnabled)
+		{
+			RehldsHookchains->Cvar_DirectSet()->registerHook(Cvar_DirectSet_RH);
+			m_ReHookEnabled = true;
+		}
+	}
+	else if (m_HookDetour)
+	{
+		m_HookDetour->EnableDetour();
+	}
+}
+
+void CvarManager::DisableHook()
+{
+	if (RehldsHookchains)
+	{
+		if (m_ReHookEnabled)
+		{
+			RehldsHookchains->Cvar_DirectSet()->unregisterHook(Cvar_DirectSet_RH);
+			m_ReHookEnabled = false;
+		}
+	}
+	else if (m_HookDetour)
+	{
+		m_HookDetour->DisableDetour();
+	}
+}
+
+void CvarManager::DestroyHook()
+{
+	DisableHook();
+	
+	if (m_HookDetour)
+	{
+		m_HookDetour->Destroy();
+	}
+}
+
+CvarInfo* CvarManager::CreateCvar(const char* name, const char* value, const char* plugin, int pluginId, int flags,
+								  const char* helpText)
+{
+	cvar_t*    var = nullptr;
+	CvarInfo* info = nullptr;
+
+	if (!CacheLookup(name, &info))
+	{
+		// Not cached - Is cvar already exist?
+		var = CVAR_GET_POINTER(name);
+
+		// Whether it exists, we need to prepare a new entry.
+		info = new CvarInfo(name, helpText, plugin, pluginId);
+
+		if (var)
+		{
+			// Cvar already exists. Just copy.
+			// "string" will be set after. "value" and "next" are automatically set.
+			info->var        = var;
+			info->defaultval = var->string;
+			info->amxmodx    = false;
+		}
+		else
+		{
+			// Registers a new cvar.
+			static cvar_t cvar_reg_helper;
+
+			// "string" will be set after. "value" and "next" are automatically set.
+			cvar_reg_helper.name   = info->name.chars();
+			cvar_reg_helper.string = "";
+			cvar_reg_helper.flags  = flags;
+
+			// Adds cvar to global list.
+			CVAR_REGISTER(&cvar_reg_helper);
+
+			// Registering can fail if name is already a registered command.
+			var = CVAR_GET_POINTER(name);
+
+			// If so, we can't go further.
+			if (!var)
+			{
+				delete info;
+				return nullptr;
+			}
+
+			// If ok, we got a valid pointer, we can copy.
+			info->var        = var;
+			info->defaultval = value;
+			info->amxmodx    = true;
+
+			// Keeps track count of cvars registered by AMXX.
+			++m_AmxmodxCvars;
+		}
+
+		// Add a new entry in the caches.
+		m_Cvars.append(info);
+		m_Cache.insert(name, info);
+
+		// Make sure that whether an existing or new cvar is set to the given value.
+		CVAR_DIRECTSET(var, value);
+	}
+	else if (info->pluginId == -1)
+	{
+		// In situation where a plugin has been modified/recompiled
+		// or new added plugins, and a change map occurs. We want to keep data up to date.
+		info->bound.hasMin = false;
+		info->bound.minVal = 0;
+		info->bound.hasMax = false;
+		info->bound.maxVal = 0;
+		info->defaultval   = value;
+		info->description  = helpText;
+		info->pluginId     = pluginId;
+	}
+
+	// Detour is disabled on map change.
+	// Don't enable it unless there are things to do.
+	if ((info->bound.hasMin || info->bound.hasMax))
+	{
+		EnableHook();
+	}
+
+	return info;
+}
+
+CvarInfo* CvarManager::FindCvar(const char* name)
+{
+	cvar_t* var = nullptr;
+	CvarInfo* info = nullptr;
+
+	// Do we have already cvar in cache?
+	if (CacheLookup(name, &info))
+	{
+		return info;
+	}
+
+	// Cvar doesn't exist.
+	if (!(var = CVAR_GET_POINTER(name)))
+	{
+		return nullptr;
+	}
+
+	// Create a new entry.
+	info = new CvarInfo(name);
+	info->var = var;
+
+	// Add entry in the caches.
+	m_Cvars.append(info);
+	m_Cache.insert(name, info);
+
+	return info;
+}
+
+CvarInfo* CvarManager::FindCvar(size_t index)
+{
+	// Used by get_plugins_cvar native.
+	// For compatibility, only cvars registered by AMXX are concerned.
+
+	size_t iter_id = 0;
+
+	for (CvarsList::iterator iter = m_Cvars.begin(); iter != m_Cvars.end(); iter++)
+	{
+		if (iter->amxmodx && iter_id++ == index)
+		{
+			return *(iter);
+		}
+	}
+
+	return nullptr;
+}
+
+bool CvarManager::CacheLookup(const char* name, CvarInfo** info)
+{
+	return m_Cache.retrieve(name, info);
+}
+
+AutoForward* CvarManager::HookCvarChange(cvar_t* var, AMX* amx, cell param, const char** callback)
+{
+	CvarInfo* info = nullptr;
+
+	// A cvar is guaranteed to be in cache if pointer is got from
+	// get_cvar_pointer and register_cvar natives. Though it might be
+	// provided by another way. If by any chance we run in such
+	// situation, we create a new entry right now.
+
+	if (!CacheLookup(var->name, &info))
+	{
+		// Create a new entry.
+		info = new CvarInfo(var->name);
+		info->var = var;
+
+		// Add entry in the caches.
+		m_Cvars.append(info);
+		m_Cache.insert(info->name.chars(), info);
+	}
+
+	int length;
+	*callback = get_amxstring(amx, param, 0, length);
+
+	int forwardId = registerSPForwardByName(amx, *callback, FP_CELL, FP_STRING, FP_STRING, FP_DONE);
+
+	// Invalid callback, it could be: not a public function, wrongly named, or simply missing.
+	if (forwardId == -1)
+	{
+		return nullptr;
+	}
+
+	// Hook is disabled on map change.
+	EnableHook();
+
+	AutoForward* forward = new AutoForward(forwardId, *callback);
+	info->hooks.append(new CvarHook(g_plugins.findPlugin(amx)->getId(), forward));
+
+	return forward;
+}
+
+bool CvarManager::BindCvar(CvarInfo* info, CvarBind::CvarType type, AMX* amx, cell varofs, size_t varlen)
+{
+	if (varofs > amx->hlw) // If variable address is not inside global area, we can't bind it.
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Cvars can only be bound to global variables");
+		return false;
+	}
+
+	int pluginId = g_plugins.findPluginFast(amx)->getId();
+	cell* address = get_amxaddr(amx, varofs);
+
+	// To avoid unexpected behavior, probably better to error such situations.
+	for (size_t i = 0; i < info->binds.length(); ++i)
+	{
+		CvarBind* bind = info->binds[i];
+
+		if (bind->pluginId == pluginId)
+		{
+			if (bind->varAddress == address)
+			{
+				LogError(amx, AMX_ERR_NATIVE, "A global variable can not be bound to multiple Cvars");
+				return false;
+			}
+		}
+	}
+
+	CvarBind* bind = new CvarBind(pluginId, type, get_amxaddr(amx, varofs), varlen);
+
+	info->binds.append(bind);
+
+	// Update right away variable with current cvar value.
+	switch (type)
+	{
+		case CvarBind::CvarType_Int:
+			*bind->varAddress = atoi(info->var->string);
+			break;
+		case CvarBind::CvarType_Float:
+			*bind->varAddress = amx_ftoc(info->var->value);
+			break;
+		case CvarBind::CvarType_String:
+			set_amxstring_simple(bind->varAddress, info->var->string, bind->varLength);
+			break;
+	}
+
+	// Hook is disabled on map change.
+	EnableHook();
+
+	return true;
+}
+
+void CvarManager::SetCvarMin(CvarInfo* info, bool set, float value, int pluginId)
+{
+	info->bound.hasMin = set;
+	info->bound.minPluginId = pluginId;
+
+	if (set)
+	{
+		// Hook is disabled on map change.
+		EnableHook();
+
+		info->bound.minVal = value;
+
+		// Current value is already in the allowed range.
+		if (info->var->value >= value)
+		{
+			return;
+		}
+
+		// Update if needed.
+		CVAR_SET_FLOAT(info->var->name, value);
+	}
+}
+
+void CvarManager::SetCvarMax(CvarInfo* info, bool set, float value, int pluginId)
+{
+	info->bound.hasMax = set;
+	info->bound.maxPluginId = pluginId;
+
+	if (set)
+	{
+		// Hook is disabled on map change.
+		EnableHook();
+
+		info->bound.maxVal = value;
+
+		// Current value is already in the allowed range.
+		if (info->var->value <= value)
+		{
+			return;
+		}
+
+		// Update if needed.
+		CVAR_SET_FLOAT(info->var->name, value);
+	}
+}
+
+size_t CvarManager::GetRegCvarsCount()
+{
+	return m_AmxmodxCvars;
+}
+
+CvarsList* CvarManager::GetCvarsList()
+{
+	return &m_Cvars;
+}
+
+ke::AutoString convertFlagsToString(int flags)
+{
+	ke::AutoString flagsName;
+
+	if (flags > 0)
+	{
+		if (flags & FCVAR_ARCHIVE)          flagsName = flagsName + "FCVAR_ARCHIVE ";
+		if (flags & FCVAR_USERINFO)         flagsName = flagsName + "FCVAR_USERINFO ";
+		if (flags & FCVAR_SERVER)           flagsName = flagsName + "FCVAR_SERVER ";
+		if (flags & FCVAR_EXTDLL)           flagsName = flagsName + "FCVAR_EXTDLL ";
+		if (flags & FCVAR_CLIENTDLL)        flagsName = flagsName + "FCVAR_CLIENTDLL ";
+		if (flags & FCVAR_PROTECTED)        flagsName = flagsName + "FCVAR_PROTECTED ";
+		if (flags & FCVAR_SPONLY)           flagsName = flagsName + "FCVAR_SPONLY ";
+		if (flags & FCVAR_PRINTABLEONLY)    flagsName = flagsName + "FCVAR_PRINTABLEONLY ";
+		if (flags & FCVAR_UNLOGGED)         flagsName = flagsName + "FCVAR_UNLOGGED ";
+		if (flags & FCVAR_NOEXTRAWHITEPACE) flagsName = flagsName + "FCVAR_NOEXTRAWHITEPACE ";
+	}
+
+	if (!flagsName.length())
+	{
+		flagsName = "-";
+	}
+
+	return flagsName;
+}
+
+void CvarManager::OnConsoleCommand()
+{
+	size_t index = 0;
+	size_t indexToSearch = 0;
+	ke::AString partialName;
+
+	int argcount = CMD_ARGC();
+
+	// amxx cvars [partial plugin name] [index from listing]
+	// E.g.:
+	//   amxx cvars test   <- list all cvars from plugin name starting by "test"
+	//   amxx cvars 2      <- show informations about cvar in position 2 from "amxx cvars" list
+	//   amxx cvars test 2 <- show informations about cvar in position 2 from "amxx cvars test" list
+
+	if (argcount > 2)
+	{
+		const char* argument = CMD_ARGV(2);
+
+		indexToSearch = atoi(argument); // amxx cvars 2
+
+		if (!indexToSearch)
+		{
+			partialName = argument; // amxx cvars test
+
+			if (argcount > 3)       // amxx cvars test 2
+			{
+				indexToSearch = atoi(CMD_ARGV(3));
+			}
+		}
+	}
+
+	if (!indexToSearch)
+	{
+		print_srvconsole("\nManaged cvars:\n");
+		print_srvconsole("       %-24.23s %-24.23s %-18.17s %-8.7s %-8.7s %-8.7s\n", "NAME", "VALUE", "PLUGIN", "HOOKED", "MIN", "MAX");
+		print_srvconsole(" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
+	}
+
+	for (CvarsList::iterator iter = m_Cvars.begin(); iter != m_Cvars.end(); iter++)
+	{
+		CvarInfo* ci = (*iter);
+
+		// List any cvars having a status either created, hooked or bound by a plugin.
+		bool in_list = ci->amxmodx || !ci->binds.empty() || !ci->hooks.empty() || ci->bound.hasMin || ci->bound.hasMax;
+
+		if (in_list && (!partialName.length() || strncmp(ci->plugin.chars(), partialName.chars(), partialName.length()) == 0))
+		{
+			if (!indexToSearch)
+			{
+				print_srvconsole(" [%3d] %-24.23s %-24.23s %-18.17s %-8.7s ", ++index, ci->name.chars(), ci->var->string,
+								 ci->plugin.length() ? ci->plugin.chars() : "-",
+								 ci->hooks.empty() ? "no" : "yes");
+
+				(ci->bound.hasMin) ? print_srvconsole("%-8.2f ", ci->bound.minVal) : print_srvconsole("%-8.7s ", "-");
+				(ci->bound.hasMax) ? print_srvconsole("%-8.2f ", ci->bound.maxVal) : print_srvconsole("%-8.7s ", "-");
+				print_srvconsole("\n");
+			}
+			else
+			{
+				if (++index != indexToSearch)
+				{
+					continue;
+				}
+
+				print_srvconsole("\nCvar details :\n\n");
+				print_srvconsole(" Cvar name   : %s\n", ci->var->name);
+				print_srvconsole(" Value       : %s\n", ci->var->string);
+				print_srvconsole(" Def. value  : %s\n", ci->defaultval.chars());
+				print_srvconsole(" Description : %s\n", ci->description.chars());
+				print_srvconsole(" Flags       : %s\n\n", convertFlagsToString(ci->var->flags).ptr());
+
+				print_srvconsole(" %-12s  %-26.25s %s\n", "STATUS", "PLUGIN", "INFOS");
+				print_srvconsole(" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
+
+				if (ci->amxmodx)
+				{
+					print_srvconsole(" Registered    %-26.25s %s\n", ci->plugin.chars(), "-");
+				}
+
+				if (ci->bound.hasMin)
+				{
+					print_srvconsole(" Min value   %-26.25s %f\n", g_plugins.findPlugin(ci->bound.minPluginId)->getName(), ci->bound.minVal);
+				}
+
+				if (ci->bound.hasMax)
+				{
+					print_srvconsole(" Max value   %-26.25s %f\n", g_plugins.findPlugin(ci->bound.maxPluginId)->getName(), ci->bound.maxVal);
+				}
+
+				if (!ci->binds.empty())
+				{
+					for (size_t i = 0; i < ci->binds.length(); ++i)
+					{
+						print_srvconsole(" Bound        %-26.25s %s\n", g_plugins.findPlugin(ci->binds[i]->pluginId)->getName(), "-");
+					}
+				}
+
+				if (!ci->hooks.empty())
+				{
+					for (size_t i = 0; i < ci->hooks.length(); ++i)
+					{
+						CvarHook* hook = ci->hooks[i];
+
+						print_srvconsole(" Hooked        %-26.25s %s (%s)\n", g_plugins.findPlugin(hook->pluginId)->getName(),
+										 hook->forward->callback.chars(),
+										 hook->forward->state == AutoForward::FSTATE_OK ? "active" : "inactive");
+					}
+				}
+				break;
+			}
+		}
+	}
+}
+
+void CvarManager::OnPluginUnloaded()
+{
+	// Clear only plugin hooks list.
+	for (CvarsList::iterator cvar = m_Cvars.begin(); cvar != m_Cvars.end(); cvar++)
+	{
+		for (size_t i = 0; i < (*cvar)->binds.length(); ++i)
+		{
+			delete (*cvar)->binds[i];
+		}
+
+		for (size_t i = 0; i < (*cvar)->hooks.length(); ++i)
+		{
+			delete (*cvar)->hooks[i];
+		}
+
+		if ((*cvar)->amxmodx) // Mark registered cvars so we can refresh default datas at next map.
+		{
+			(*cvar)->pluginId = -1;
+		}
+
+		(*cvar)->binds.clear();
+		(*cvar)->hooks.clear();
+	}
+
+	// There is no point to enable hook if at next map change
+	// no plugins hook cvars.
+	DisableHook();
+}
+
+void CvarManager::OnAmxxShutdown()
+{
+	// Free everything.
+
+	CvarsList::iterator iter = m_Cvars.begin();
+
+	while (iter != m_Cvars.end())
+	{
+		CvarInfo* cvar = (*iter);
+
+		for (size_t i = 0; i < cvar->binds.length(); ++i)
+		{
+			delete cvar->binds[i];
+		}
+
+		for (size_t i = 0; i < cvar->hooks.length(); ++i)
+		{
+			delete cvar->hooks[i];
+		}
+
+		iter = m_Cvars.erase(iter);
+
+		delete cvar;
+	}
+
+	m_Cache.clear();
+
+	DestroyHook();
+}

amxmodx/CvarManager.h

@@ -0,0 +1,177 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef CVARS_H
+#define CVARS_H
+
+#include "amxmodx.h"
+#include <amtl/am-vector.h>
+#include <amtl/am-inlinelist.h>
+#include <sm_namehashset.h>
+#include "CGameConfigs.h"
+
+class CDetour;
+
+enum CvarBounds
+{
+	CvarBound_Upper = 0,
+	CvarBound_Lower
+};
+
+struct AutoForward
+{
+	enum fwdstate
+	{
+		FSTATE_INVALID = 0,
+		FSTATE_OK,
+		FSTATE_STOP,
+	};
+
+	AutoForward(int id_, const char* handler) : id(id_), state(FSTATE_OK), callback(handler) {};
+	AutoForward()                             : id(-1) , state(FSTATE_INVALID) {};
+
+	~AutoForward()
+	{
+		unregisterSPForward(id);
+	}
+
+	int         id;
+	fwdstate    state;
+	ke::AString callback;
+};
+
+struct CvarHook
+{
+	CvarHook(int id, AutoForward* fwd) : pluginId(id), forward(fwd) {};
+	CvarHook(int id)                   : pluginId(id), forward(new AutoForward()) {};
+
+	int pluginId;
+	ke::AutoPtr<AutoForward> forward;
+};
+
+struct CvarBind
+{
+	enum CvarType
+	{
+		CvarType_Int,
+		CvarType_Float,
+		CvarType_String,
+	};
+
+	CvarBind(int id_, CvarType type_, cell* varAddress_, size_t varLength_)
+		: 
+		pluginId(id_), 
+		type(type_), 
+		varAddress(varAddress_), 
+		varLength(varLength_) {};
+
+	int      pluginId;
+	CvarType type;
+	cell*    varAddress;
+	size_t   varLength;
+};
+
+struct CvarBound
+{
+	CvarBound()
+		:
+		hasMin(false), minVal(0), 
+		hasMax(false), maxVal(0),
+		minPluginId(-1),
+		maxPluginId(-1) {};
+
+	bool    hasMin;
+	float   minVal;
+	bool    hasMax;
+	float   maxVal;
+	int     minPluginId;
+	int     maxPluginId;
+};
+
+typedef ke::Vector<CvarHook*> CvarsHook;
+typedef ke::Vector<CvarBind*> CvarsBind;
+
+struct CvarInfo : public ke::InlineListNode<CvarInfo>
+{
+	CvarInfo(const char* name_, const char* helpText, const char* plugin_, int pluginId_)
+		:
+		name(name_), description(helpText),	
+		plugin(plugin_), pluginId(pluginId_), bound() {};
+
+	CvarInfo(const char* name_)
+		:
+		name(name_), defaultval(""), description(""), 
+		plugin(""), pluginId(-1), bound(), amxmodx(false) {};
+
+	cvar_t*      var;
+	ke::AString  name;
+	ke::AString  defaultval;
+	ke::AString  description;
+
+	ke::AString  plugin;
+	int          pluginId;
+
+	CvarBound    bound;
+	CvarsBind    binds;
+	CvarsHook    hooks;
+
+	bool         amxmodx;
+
+	static inline bool matches(const char *name, const CvarInfo* info)
+	{
+		return strcmp(name, info->var->name) == 0;
+	}
+};
+
+typedef NameHashSet<CvarInfo*> CvarsCache;
+typedef ke::InlineList<CvarInfo> CvarsList;
+
+class CvarManager
+{
+	public:
+
+		CvarManager();
+		~CvarManager();
+
+	public:
+
+		void      CreateCvarHook();
+		void      EnableHook();
+		void      DisableHook();
+		void      DestroyHook();
+
+		CvarInfo* CreateCvar(const char* name, const char* value, const char* plugin, int pluginId, int flags = 0, const char* helpText = "");
+		CvarInfo* FindCvar(const char* name);
+		CvarInfo* FindCvar(size_t index);
+		bool      CacheLookup(const char* name, CvarInfo** info);
+
+		AutoForward*  HookCvarChange(cvar_t* var, AMX* amx, cell param, const char** callback);
+		bool          BindCvar(CvarInfo* info, CvarBind::CvarType type, AMX* amx, cell varofs, size_t varlen = 0);
+		void          SetCvarMin(CvarInfo* info, bool set, float value, int pluginId);
+		void          SetCvarMax(CvarInfo* info, bool set, float value, int pluginId);
+
+		size_t    GetRegCvarsCount();
+		CvarsList* GetCvarsList();
+
+		void      OnConsoleCommand();
+		void      OnPluginUnloaded();
+		void      OnAmxxShutdown();
+
+	private:
+
+		CvarsCache m_Cache;
+		CvarsList  m_Cvars;
+		size_t     m_AmxmodxCvars;
+		CDetour*   m_HookDetour;
+		bool       m_ReHookEnabled;
+};
+
+extern CvarManager g_CvarManager;
+
+#endif // CVARS_H

amxmodx/Makefile

@@ -1,123 +0,0 @@
-MODNAME = amxx_mm
-SRCFILES = meta_api.cpp CFile.cpp CString.cpp CVault.cpp vault.cpp\
-float.cpp file.cpp modules.cpp CMisc.cpp CTask.cpp string.cpp\
-amxmodx.cpp CEvent.cpp CCmd.cpp CLogEvent.cpp srvcmd.cpp strptime.cpp\
-CForward.cpp CPlugin.cpp CModule.cpp CMenu.cpp emsg.cpp util.cpp \
-amxcore.cpp amxtime.cpp power.cpp amxxlog.cpp fakemeta.cpp mmgr/mmgr.cpp \
-amxxfile.cpp CLang.cpp md5.cpp amx.cpp
-#use this for amd64, remove the above amx.cpp, and rename amx.cpp to amx.c
-#CSRCFILES = amx.c minilzo/minilzo.c
-CSRCFILES = minilzo/minilzo.c
-
-EXTRA_LIBS_LINUX =
-EXTRA_LIBS_WIN32 =
-EXTRA_LIBDIRS_LINUX = -Lextra/lib_linux
-EXTRA_LIBDIRS_WIN32 = -Lextra/lib_win32
-
-EXTRA_INCLUDEDIRS = -Iextra/include
-
-EXTRA_FLAGS = -Dstrcmpi=strcasecmp
-
-SDKTOP=../hlsdk
-METADIR=../metamod/metamod
-
-
-SDKSRC=$(SDKTOP)/SourceCode
-OBJDIR_LINUX=obj.linux
-OBJDIR_WIN32=obj.win32
-SRCDIR=.
-
-ifdef windir
-	OS=WIN32
-else
-	OS=LINUX
-endif
-
-CC_LINUX=gcc
-ifeq "$(OS)" "WIN32"
-	CC_WIN32=gcc
-	LD_WINDLL=dllwrap
-	DEFAULT=win32
-	CLEAN=clean_win32
-else
-	CC_WIN32=/usr/local/cross-tools/i386-mingw32msvc/bin/gcc
-	LD_WINDLL=/usr/local/cross-tools/bin/i386-mingw32msvc-dllwrap
-	DEFAULT=linux win32
-	CLEAN=clean_both
-endif
-
-
-#use this for AMD64
-#LIBFILE_LINUX = $(MODNAME)_amd64.so
-LIBFILE_LINUX = $(MODNAME)_i386.so
-LIBFILE_WIN32 = $(MODNAME).dll
-TARGET_LINUX = $(OBJDIR_LINUX)/$(LIBFILE_LINUX)
-TARGET_WIN32 = $(OBJDIR_WIN32)/$(LIBFILE_WIN32)
-
-FILES_ALL = *.cpp *.h [A-Z]* *.rc
-ifeq "$(OS)" "LINUX"
-	ASRCFILES := $(shell ls -t $(SRCFILES))
-else
-	ASRCFILES := $(shell dir /b)
-endif
-OBJ_LINUX := $(SRCFILES:%.cpp=$(OBJDIR_LINUX)/%.o)
-OBJC_LINUX := $(CSRCFILES:%.c=$(OBJDIR_LINUX)/%.o)
-OBJ_WIN32 := $(SRCFILES:%.cpp=$(OBJDIR_WIN32)/%.o)
-OBJC_WIN32 := $(CSRCFILES:%.c=$(OBJDIR_WIN32)/%.o)
-
-#use this for amd64
-#CCOPT = -m64 -g -ggdb3 -DHAVE_I64 -DSMALL_CELL_SIZE=64
-CCOPT = -march=i386 -s -DNDEBUG -O2 -fomit-frame-pointer -fno-exceptions -fno-rtti -ffast math
-
-INCLUDEDIRS=-I../curl/include -I$(SRCDIR) -I$(METADIR) -I$(SDKSRC)/engine -I$(SDKSRC)/common -I$(SDKSRC)/pm_shared -I$(SDKSRC)/dlls -I$(SDKSRC) $(EXTRA_INCLUDEDIRS)
-CFLAGS=-Wall -Wno-unknown-pragmas
-ODEF = -DOPT_TYPE=\"optimized\"
-CFLAGS:=$(CCOPT) $(CFLAGS) $(ODEF) $(EXTRA_FLAGS)
-
-DO_CC_LINUX=$(CC_LINUX) $(CFLAGS) -fPIC $(INCLUDEDIRS) -o $@ -c $<
-DO_CC_WIN32=$(CC_WIN32) $(CFLAGS) $(INCLUDEDIRS) -o $@ -c $<
-LINK_LINUX=$(CC_LINUX) $(CFLAGS) -shared -ldl -lm $(OBJ_LINUX) $(OBJC_LINUX) $(EXTRA_LIBDIRS_LINUX) $(EXTRA_LIBS_LINUX) -o $@
-LINK_WIN32=$(LD_WINDLL) -mwindows --def $(MODNAME).def --add-stdcall-alias $(OBJ_WIN32) $(OBJC_WIN32) $(EXTRA_LIBDIRS_WIN32) $(EXTRA_LIBS_WIN32) -o $@
-
-$(OBJDIR_LINUX)/%.o: $(SRCDIR)/%.c
-	$(DO_CC_LINUX)
-
-$(OBJDIR_LINUX)/%.o: $(SRCDIR)/%.cpp
-	$(DO_CC_LINUX)
-
-$(OBJDIR_WIN32)/%.o: $(SRCDIR)/%.c
-	$(DO_CC_WIN32)
-
-$(OBJDIR_WIN32)/%.o: $(SRCDIR)/%.cpp
-	$(DO_CC_WIN32)
-
-default: $(DEFAULT)
-
-$(TARGET_LINUX): $(OBJDIR_LINUX) $(OBJ_LINUX) $(OBJC_LINUX)
-	$(LINK_LINUX)
-
-$(TARGET_WIN32): $(OBJDIR_WIN32) $(OBJ_WIN32) $(OBJC_WIN32)
-	$(LINK_WIN32)
-
-$(OBJDIR_LINUX):
-	mkdir $@
-	mkdir $@/mmgr
-
-$(OBJDIR_WIN32):
-	mkdir $@
-	mkdir $@/mmgr
-
-win32: $(TARGET_WIN32)
-
-linux: $(TARGET_LINUX)
-
-clean: $(CLEAN)
-
-clean_both:
-	-rm -f $(OBJDIR_LINUX)/*
-	-rm -f $(OBJDIR_WIN32)/*
-
-clean_win32:
-	del /q $(OBJDIR_WIN32)
-
- 

amxmodx/Makefile.pl

@@ -1,256 +0,0 @@
-#!/usr/bin/perl
-#(C)2004 AMX Mod X Development Team
-# by David "BAILOPAN" Anderson
-
-# output will occur in bin.x.proc
-# where x is debug or opt and proc is ix86 or amd64
-# You must use this script from the amxmodx src dir
-
-#options = 
-# jit - use the JIT
-# debug - enable gdb debugging
-# amd64 - compile for AMD64 (impiles no jit)
-# proc=ix86 - assumed not amd64
-# clean - clean the specifications above
-# asm - for ASM implementation
-# !! TODO - add memory mananger support
-# lineop - for JIT only, uses slow version
-
-$PROJECT = "amxmodx_mm";
-$sdk = "../hlsdk/SourceCode";
-$mm = "../metamod/metamod";
-$gccf = "gcc";
-$ccf = "cc";
-$amd64_lstdc = "-lstdc++";
-
-@CPP_SOURCE_FILES = ("meta_api.cpp", "CFile.cpp", "CVault.cpp", "vault.cpp", "float.cpp", "file.cpp", "modules.cpp", "CMisc.cpp", "CTask.cpp", "string.cpp", "amxmodx.cpp", "CEvent.cpp", "CCmd.cpp", "CLogEvent.cpp", "srvcmd.cpp", "strptime.cpp", "amxcore.cpp", "amxtime.cpp", "power.cpp", "amxxlog.cpp", "fakemeta.cpp", "amxxfile.cpp", "CLang.cpp", "md5.cpp", "emsg.cpp", "CForward.cpp", "CPlugin.cpp", "CModule.cpp", "CMenu.cpp", "util.cpp");
-
-@C_SOURCE_FILES = ();
-my %OPTIONS, %OPT;
-
-$OPT{"debug"} = "-g -ggdb";
-$OPT{"opt"} = "-O2 -ffast-math -funroll-loops -fomit-frame-pointer -s -DNDEBUG -Wall -Wno-unknown-pragmas -DOPT_TYPE=\"optimized\" -fno-exceptions -fno-rtti";
-
-$OPTIONS{"include"} = "-I$sdk -I. -I$mm -I$sdk/engine -I$sdk/common -I$sdk/pm_shared -I$sdk/dlls";
-
-while ($cmd = shift)
-{
-	if ($cmd =~ /asm/)
-	{
-		if ($OPTIONS{"amd64"})
-		{
-			die "You cannot compile the ASM core with AMD64 yet.\n";
-		} else {
-			$OPTIONS{"asm"} = 1;
-		}
-	}
-	if ($cmd =~ /jit/)
-	{
-		if ($OPTIONS{"amd64"})
-		{
-			die "You cannot compile the JIT and AMD64 yet.\n";
-		} else {
-			$OPTIONS{"jit"} = 1;
-		}
-	} elsif ($cmd =~ /amd64/) {
-		if ($OPTIONS{"jit"} || $OPTIONS{"asm"})
-		{
-			die "You cannot compile the JIT or ASM and AMD64 yet.\n";
-		} else {
-			$OPTIONS{"amd64"} = 1;
-		}
-	} elsif ($cmd =~ /debug/) {
-		$OPTIONS{"debug"} = 1;
-	} elsif ($cmd =~ /proc=i(\d)86/) {
-		$proc = $1;
-		if ($OPTIONS{"amd64"})
-		{
-			die "You cannot compile for i".$proc."86 and AMD64.\n";
-		} else {
-			$OPTIONS{"proc"} = "i".$proc."86";
-		}
-	} elsif ($cmd =~ /clean/) {
-		$OPTIONS{"clean"} = 1;		
-	} elsif ($cmd =~ /lineop/) {
-		$OPTIONS{"lineop"} = 1;
-	}
-}
-
-$gcc = `$gccf --version`;
-if ($gcc =~ /2\.9/)
-{
-	#if ($OPTIONS{"jit"})
-	#{
-#		push(@CPP_SOURCE_FILES, "amx.cpp");
-#		$OPT{"opt"} .= " -malign-loops=2 -malign-jumps=2 -malign-functions=2";
-#	} else {
-		`ln -s amx.cpp amx.c`;
-		push(@C_SOURCE_FILES, "amx.c");
-#	}
-} else {
-	if ($OPTIONS{"amd64"})
-	{
-		`ln -s amx.cpp amx.c`;
-		push(@C_SOURCE_FILES, "amx.c");
-	} else {
-		push(@CPP_SOURCE_FILES, "amx.cpp");
-	}
-	$OPT{"opt"} .= " -falign-loops=2 -falign-jumps=2 -falign-functions=2";
-}
-
-if ($OPTIONS{"debug"})
-{
-	$cflags = $OPT{"debug"};
-} else {
-	if (!$OPTIONS{"amd64"})
-	{
-		$proc = $OPTIONS{"proc"};
-		if (!$proc)
-		{
-			$proc = 3;
-		}
-		$cflags = "-march=i".$proc."86 ".$OPT{"opt"};
-	} else {
-		$cflags = $OPT{"opt"};
-	}
-}
-
-if ($OPTIONS{"amd64"})
-{
-	$cflags = " -m64 -DSMALL_CELL_SIZE=64 -DHAVE_I64 $cflags";
-}
-
-if ($OPTIONS{"jit"})
-{
-	$cflags .= " -DJIT";
-}
-
-if ($OPTIONS{"asm"})
-{
-	$cflags .= " -DASM32";
-}
-
-if ($OPTIONS{"debug"})
-{
-	$outdir = "bin.debug";
-} else {
-	$outdir = "bin.opt";
-}
-
-if ($OPTIONS{"amd64"})
-{
-	$outdir .= ".amd64";
-	$bin = $PROJECT."_amd64.so";
-} else {
-	$proc = $OPTIONS{"proc"};
-	if ($proc)
-	{
-		$outdir .= ".i".$proc."86";
-		$bin = $PROJECT."_i".$proc."86.so";
-	} else {
-		$outdir .= ".i386";
-		$bin = $PROJECT."_i386.so";
-	}
-}
-
-if ($OPTIONS{"clean"})
-{
-	`rm $outdir/*.o`;
-	`rm $outdir/$bin`;
-	die("Project cleaned.\n");
-}
-
-#create the dirs
-#build link list
-my @LINK;
-for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++)
-{
-	$file = $CPP_SOURCE_FILES[$i];
-	$file =~ s/\.cpp/\.o/;
-	push(@LINK, $outdir."/".$file);
-}
-for ($i=0; $i<=$#C_SOURCE_FILES; $i++)
-{
-	$file = $C_SOURCE_FILES[$i];
-	$file =~ s/\.c/\.o/;
-	push(@LINK, $outdir."/".$file);
-}
-if ($OPTIONS{"jit"})
-{
-	if ($OPTIONS{"lineop"}) {
-		push(@LINK, "JIT/jits-lineop.o");
-	} else {
-		push(@LINK, "JIT/jits.o");
-	}	 
-}
-if ($OPTIONS{"amd64"})
-{
-	push(@LINK, "zlib/libz64.a");
-	push(@LINK, $amd64_lstdc);
-} else {
-	push(@LINK, "zlib/libz.a");
-}
-if ($OPTIONS{"asm"})
-{
-	push(@LINK, "amxexecn.o");
-}
-
-if (!(-d $outdir))
-{
-	mkdir($outdir);
-}
-if (!(-d "$outdir/JIT"))
-{
-	mkdir("$outdir/JIT");
-}
-
-$inc = $OPTIONS{"include"};
-
-for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++)
-{
-	$file = $CPP_SOURCE_FILES[$i];
-	$ofile = $file;
-	$ofile =~ s/\.cpp/\.o/;
-	$ofile = "$outdir/$ofile";
-	$gcc = "$gccf $cflags -Dstrcmpi=strcasecmp -fPIC $inc -c $file -o $ofile";
-	if (-e $ofile)
-	{
-		$file_time = (stat($file))[9];
-		$ofile_time = (stat($ofile))[9];
-		if ($file_time > $ofile_time)
-		{
-			`rm $ofile`;
-			print "$gcc\n";
-			`$gcc`;
-		}
-	} else {
-		print "$gcc\n";
-		`$gcc`;
-	}
-}
-
-for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++)
-{
-	$file = $C_SOURCE_FILES[$i];
-	$ofile = $file;
-	$ofile =~ s/\.c/\.o/;
-	$ofile = "$outdir/$ofile";
-	$gcc = "$ccf $cflags -Dstrcmpi=strcasecmp -fPIC $inc -c $file -o $ofile";
-	if (-e $ofile)
-	{
-		$file_time = (stat($file))[9];
-		$ofile_time = (stat($ofile))[9];
-		if ($file_time > $ofile_time)
-		{
-			print "$gcc\n";
-			`$gcc`;
-		}
-	} else {
-		print "$gcc\n";
-		`$gcc`;
-	}
-}
-
-$gcc = "$gccf $cflags -shared -ldl -lm @LINK -o $outdir/$bin";
-print "$gcc\n";
-`$gcc`;

amxmodx/amx.h

@@ -1,6 +1,6 @@
-/*  Abstract Machine for the Small compiler
+/*  Pawn Abstract Machine (for the Pawn language)
  *
- *  Copyright (c) ITB CompuPhase, 1997-2004
+ *  Copyright (c) ITB CompuPhase, 1997-2005
  *
  *  This software is provided "as-is", without any express or implied warranty.
  *  In no event will the authors be held liable for any damages arising from
@@ -17,57 +17,83 @@
  *  2.  Altered source versions must be plainly marked as such, and must not be
  *      misrepresented as being the original software.
  *  3.  This notice may not be removed or altered from any source distribution.
- *
- *  Version: $Id$
  */
 
-#if defined __linux__
+#if defined FREEBSD && !defined __FreeBSD__
+  #define __FreeBSD__
+#endif
+#if defined LINUX || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
   #include <sclinux.h>
 #endif
 
 #ifndef AMX_H_INCLUDED
 #define AMX_H_INCLUDED
 
-#if defined __LCC__ || defined __DMC__ || defined __linux__
+#if defined HAVE_STDINT_H
   #include <stdint.h>
-#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
-  /* The ISO C99 defines the int16_t and int_32t types. If the compiler got
-   * here, these types are probably undefined.
-   */
-  #if defined __FreeBSD__
-    #include <inttypes.h>
-  #else
-    typedef short int           int16_t;
-    typedef unsigned short int  uint16_t;
-    #if defined SN_TARGET_PS2
-      typedef int               int32_t;
-      typedef unsigned int      uint32_t;
+#else
+  #if defined __LCC__ || defined __DMC__ || defined LINUX || defined __APPLE__
+    #if defined HAVE_INTTYPES_H
+      #include <inttypes.h>
     #else
-      typedef long int          int32_t;
-      typedef unsigned long int uint32_t;
+      #include <stdint.h>
     #endif
-    #if defined __WIN32__ || defined _WIN32 || defined WIN32
-      typedef __int64			int64_t;
-      typedef unsigned __int64	uint64_t;
-      #define HAVE_I64
-    #elif defined __GNUC__
-      typedef long long			int64_t;
-      typedef unsigned long long uint64_t;
-      #define HAVE_I64
+  #elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
+    /* The ISO C99 defines the int16_t and int_32t types. If the compiler got
+     * here, these types are probably undefined.
+     */
+    #if defined __MACH__
+      #include <ppc/types.h>
+      typedef unsigned short int  uint16_t;
+      typedef unsigned long int   uint32_t;
+    #elif defined __FreeBSD__
+      #include <inttypes.h>
+    #else
+      typedef short int           int16_t;
+      typedef unsigned short int  uint16_t;
+      #if defined SN_TARGET_PS2
+        typedef int               int32_t;
+        typedef unsigned int      uint32_t;
+      #else
+        typedef long int          int32_t;
+        typedef unsigned long int uint32_t;
+      #endif
+      #if defined __WIN32__ || defined _WIN32 || defined WIN32
+        typedef __int64	          int64_t;
+        typedef unsigned __int64  uint64_t;
+        #define HAVE_I64
+      #elif defined __GNUC__
+        typedef long long         int64_t;
+        typedef unsigned long long uint64_t;
+        #define HAVE_I64
+      #endif
     #endif
   #endif
+  #define HAVE_STDINT_H
+#endif
+#if defined _LP64 || defined WIN64 || defined _WIN64
+  #if !defined __64BIT__
+    #define __64BIT__
+  #endif
 #endif
 
-#if defined __WIN32__ || defined _WIN32 || defined WIN32 /* || defined __MSDOS__ */
-  #if !defined alloca
-    #define alloca(n)   _alloca(n)
-  #endif
+#if !defined arraysize
+  #define arraysize(array)  (sizeof(array) / sizeof((array)[0]))
 #endif
 
 #ifdef  __cplusplus
 extern  "C" {
 #endif
 
+#if defined PAWN_DLL
+  #if !defined AMX_NATIVE_CALL
+    #define AMX_NATIVE_CALL __stdcall
+  #endif
+  #if !defined AMXAPI
+    #define AMXAPI          __stdcall
+  #endif
+#endif
+
 /* calling convention for native functions */
 #if !defined AMX_NATIVE_CALL
   #define AMX_NATIVE_CALL
@@ -78,6 +104,8 @@ extern  "C" {
     #define AMXAPI      __stdcall
   #elif defined CDECL
     #define AMXAPI      __cdecl
+  #elif defined GCC_HASCLASSVISIBILITY
+    #define AMXAPI __attribute__ ((visibility("default")))
   #else
     #define AMXAPI
   #endif
@@ -95,46 +123,39 @@ extern  "C" {
  *   5 (tagnames table)                         4
  *   6 (reformatted header)                     6
  *   7 (name table, opcodes SYMTAG & SYSREQ.D)  7
+ *   8 (opcode STMT, renewed debug interface)   8
  */
-#define CUR_FILE_VERSION  7     /* current file version; also the current AMX version */
+#define CUR_FILE_VERSION  8     /* current file version; also the current AMX version */
 #define MIN_FILE_VERSION  6     /* lowest supported file format version for the current AMX version */
-#define MIN_AMX_VERSION   7     /* minimum AMX version needed to support the current file format */
+#define MIN_AMX_VERSION   8     /* minimum AMX version needed to support the current file format */
 
-#if defined BIT16
-  #define SMALL_CELL_SIZE 16    /* for backward compatibility */
+#if !defined PAWN_CELL_SIZE
+  #define PAWN_CELL_SIZE 32     /* by default, use 32-bit cells */
 #endif
-#if !defined SMALL_CELL_SIZE
-  #define SMALL_CELL_SIZE 32    /* by default, use 32-bit cells */
-#endif
-#if SMALL_CELL_SIZE==16
+#if PAWN_CELL_SIZE==16
   typedef uint16_t  ucell;
   typedef int16_t   cell;
-#elif SMALL_CELL_SIZE==32
+#elif PAWN_CELL_SIZE==32
   typedef uint32_t  ucell;
   typedef int32_t   cell;
-#elif SMALL_CELL_SIZE==64
+#define REAL	float
+#elif PAWN_CELL_SIZE==64
   typedef uint64_t  ucell;
   typedef int64_t   cell;
+#define REAL	double
 #else
-  #error Unsupported cell size (SMALL_CELL_SIZE)
+  #error Unsupported cell size (PAWN_CELL_SIZE)
 #endif
 
-#if SMALL_CELL_SIZE==32
-  #define REAL          float
-#elif SMALL_CELL_SIZE==64
-  #define REAL          double
-#else
-  #error Unsupported cell size
-#endif
-
-#define UNPACKEDMAX   ((1 << (sizeof(cell)-1)*8) - 1)
+#define UNPACKEDMAX   ((1L << (sizeof(cell)-1)*8) - 1)
+#define UNLIMITED     (~1u >> 1)
 
 struct tagAMX;
 typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params);
 typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index,
                                    cell *result, cell *params);
 typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
-typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
+typedef int (AMXAPI *AMX_NATIVE_FILTER)(struct tagAMX *amx, int index);
 #if !defined _FAR
   #define _FAR
 #endif
@@ -143,12 +164,20 @@ typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
   #pragma warning(disable:4103)  /* disable warning message 4103 that complains
                                   * about pragma pack in a header file */
   #pragma warning(disable:4100)  /* "'%$S' : unreferenced formal parameter" */
+
+	#if _MSC_VER >= 1400
+		// MSVC8 - Replace POSIX stricmp with ISO C++ conformant one as it is deprecated
+		#define stricmp _stricmp
+
+		// Need this because of some stupid bug
+		#pragma warning (disable : 4996)
+	#endif
 #endif
 
 /* Some compilers do not support the #pragma align, which should be fine. Some
  * compilers give a warning on unknown #pragmas, which is not so fine...
  */
-#if defined SN_TARGET_PS2 || defined __GNUC__
+#if (defined SN_TARGET_PS2 || defined __GNUC__) && !defined AMX_NO_ALIGN
   #define AMX_NO_ALIGN
 #endif
 
@@ -159,8 +188,10 @@ typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
 #endif
 
 #if !defined AMX_NO_ALIGN
-  #if defined __linux__
+  #if defined LINUX || defined __FreeBSD__ || defined __APPLE__
     #pragma pack(1)         /* structures must be packed (byte-aligned) */
+  #elif defined MACOS && defined __MWERKS__
+	#pragma options align=mac68k
   #else
     #pragma pack(push)
     #pragma pack(1)         /* structures must be packed (byte-aligned) */
@@ -170,25 +201,30 @@ typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
   #endif
 #endif
 
-typedef struct {
+typedef struct tagAMX_NATIVE_INFO {
   const char _FAR *name PACKED;
   AMX_NATIVE func       PACKED;
-} AMX_NATIVE_INFO;
+} PACKED AMX_NATIVE_INFO;
 
 #define AMX_USERNUM     4
 #define sEXPMAX         19      /* maximum name length for file version <= 6 */
-#define sNAMEMAX        31      /* maximum name length of symbol name */
+#define sNAMEMAX        63      /* maximum name length of symbol name */
 
 typedef struct tagAMX_FUNCSTUB {
-  ucell address           PACKED;
-  const char name[sEXPMAX+1] PACKED;
-} AMX_FUNCSTUB;
+  ucell address         PACKED;
+  char name[sEXPMAX+1];
+} PACKED AMX_FUNCSTUB;
+
+typedef struct tagFUNCSTUBNT {
+  ucell address         PACKED;
+  ucell nameofs      PACKED;	//we need this for amxx to be backwards comaptible
+} PACKED AMX_FUNCSTUBNT;
 
 /* The AMX structure is the internal structure for many functions. Not all
  * fields are valid at all times; many fields are cached in local variables.
  */
 typedef struct tagAMX {
-  unsigned char _FAR *base PACKED; /* points to the AMX header ("amxhdr") plus the code, optionally also the data */
+  unsigned char _FAR *base PACKED; /* points to the AMX header plus the code, optionally also the data */
   unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */
   AMX_CALLBACK callback PACKED;
   AMX_DEBUG debug       PACKED; /* debug callback */
@@ -200,28 +236,26 @@ typedef struct tagAMX {
   cell stk              PACKED; /* stack pointer: relative to base + amxhdr->dat */
   cell stp              PACKED; /* top of the stack: relative to base + amxhdr->dat */
   int flags             PACKED; /* current status, see amx_Flags() */
-  /* for assertions and debug hook */
-  cell curline          PACKED;
-  cell curfile          PACKED;
-  int dbgcode           PACKED;
-  cell dbgaddr          PACKED;
-  cell dbgparam         PACKED;
-  char _FAR *dbgname    PACKED;
   /* user data */
-  long usertags[AMX_USERNUM] PACKED;
+  void _FAR *usertags[AMX_USERNUM] PACKED;
+  //okay userdata[3] in AMX Mod X is for the CPlugin * pointer
+  //we're also gonna set userdata[2] to a special debug structure
+  //lastly, userdata[1] is for opcode_list from amx_BrowseRelocate
   void _FAR *userdata[AMX_USERNUM] PACKED;
   /* native functions can raise an error */
   int error             PACKED;
+  /* passing parameters requires a "count" field */
+  int paramcount;
   /* the sleep opcode needs to store the full AMX status */
   cell pri              PACKED;
   cell alt              PACKED;
   cell reset_stk        PACKED;
   cell reset_hea        PACKED;
   cell sysreq_d         PACKED; /* relocated address/value for the SYSREQ.D opcode */
-    /* support variables for the JIT */
+  /* support variables for the JIT */
   int reloc_size      PACKED; /* required temporary buffer for relocations */
   long code_size      PACKED; /* estimated memory footprint of the native code */
-} AMX;
+} PACKED AMX;
 
 /* The AMX_HEADER structure is both the memory format as the file format. The
  * structure is used internaly.
@@ -229,8 +263,8 @@ typedef struct tagAMX {
 typedef struct tagAMX_HEADER {
   int32_t size          PACKED; /* size of the "file" */
   uint16_t magic        PACKED; /* signature */
-  char    file_version  PACKED; /* file format version */
-  char    amx_version   PACKED; /* required version of the AMX */
+  char    file_version;         /* file format version */
+  char    amx_version;          /* required version of the AMX */
   int16_t flags         PACKED;
   int16_t defsize       PACKED; /* size of a definition record */
   int32_t cod           PACKED; /* initial value of COD - code block */
@@ -243,26 +277,11 @@ typedef struct tagAMX_HEADER {
   int32_t libraries     PACKED; /* offset to the table of libraries */
   int32_t pubvars       PACKED; /* the "public variables" table */
   int32_t tags          PACKED; /* the "public tagnames" table */
-  int32_t nametable     PACKED; /* name table, file version 7 only */
-} AMX_HEADER            PACKED;
-#define AMX_MAGIC       0xf1e0
+  int32_t nametable     PACKED; /* name table */
+} PACKED AMX_HEADER;
 
-//double linked list for stack
-typedef struct tagAMX_TRACE
-{
-  cell					line	PACKED;
-  cell					file	PACKED;
-  struct tagAMX_TRACE	*next	PACKED;
-  struct tagAMX_TRACE	*prev	PACKED;
-} AMX_TRACE				PACKED;
-
-typedef struct tagAMX_DBG
-{
-  int32_t numFiles	PACKED;	/* number of chars in array */
-  char **files		PACKED; /* array of files */
-  AMX_TRACE *head		PACKED;	/* begin of link list */
-  AMX_TRACE *tail		PACKED; /* end of link list */
-} AMX_DBG				PACKED;
+//This is always the same for us
+#define AMX_MAGIC     0xf1e0
 
 enum {
   AMX_ERR_NONE,
@@ -279,6 +298,8 @@ enum {
   AMX_ERR_NATIVE,       /* native function failed */
   AMX_ERR_DIVIDE,       /* divide by zero */
   AMX_ERR_SLEEP,        /* go into sleepmode - code can be restarted */
+  AMX_ERR_INVSTATE,     /* invalid state for this access */
+  AMX_ERR_INVNATIVE,	/* invalid native was used */
 
   AMX_ERR_MEMORY = 16,  /* out of memory */
   AMX_ERR_FORMAT,       /* invalid file format */
@@ -291,29 +312,19 @@ enum {
   AMX_ERR_INIT_JIT,     /* cannot initialize the JIT */
   AMX_ERR_PARAMS,       /* parameter error */
   AMX_ERR_DOMAIN,       /* domain error, expression result does not fit in range */
-};
-
-enum {
-  DBG_INIT,             /* query/initialize */
-  DBG_FILE,             /* file number in curfile, filename in name */
-  DBG_LINE,             /* line number in curline, file number in curfile */
-  DBG_SYMBOL,           /* address in dbgaddr, class/type in dbgparam */
-  DBG_CLRSYM,           /* stack address below which locals should be removed. stack address in stk */
-  DBG_CALL,             /* function call, address jumped to in dbgaddr */
-  DBG_RETURN,           /* function returns */
-  DBG_TERMINATE,        /* program ends, code address in dbgaddr, reason in dbgparam */
-  DBG_SRANGE,           /* symbol size and dimensions (arrays); level in dbgaddr (!); length in dbgparam */
-  DBG_SYMTAG,           /* tag of the most recent symbol (if non-zero), tag in dbgparam */
+  AMX_ERR_GENERAL,      /* general error (unknown or unspecific error) */
 };
 
 /*      AMX_FLAG_CHAR16   0x01     no longer used */
 #define AMX_FLAG_DEBUG    0x02  /* symbolic info. available */
 #define AMX_FLAG_COMPACT  0x04  /* compact encoding */
-#define AMX_FLAG_BIGENDIAN 0x08 /* big endian encoding */
-#define AMX_FLAG_NOCHECKS  0x10 /* no array bounds checking */
-#define AMX_FLAG_LINEOPS 0x20 /* line ops are parsed by the JIT [loadtime only flag] */
-#define	AMX_FLAG_TRACED	0x40  /* the file has already been traced */
-#define AMX_FLAG_BROWSE 0x4000  /* browsing/relocating or executing */
+#define AMX_FLAG_BYTEOPC  0x08  /* opcode is a byte (not a cell) */
+#define AMX_FLAG_NOCHECKS 0x10  /* no array bounds checking; no STMT opcode */
+/*      AMX_FLAG_OLDFILE  0x20	   Old AMX Mod plugin */
+#define AMX_FLAG_PRENIT	 0x100	/* pre-initialized, do not check natives */
+#define AMX_FLAG_NTVREG 0x1000  /* all native functions are registered */
+#define AMX_FLAG_JITC   0x2000  /* abstract machine is JIT compiled */
+#define AMX_FLAG_BROWSE 0x4000  /* busy browsing */
 #define AMX_FLAG_RELOC  0x8000  /* jump/call addresses relocated */
 
 #define AMX_EXEC_MAIN   -1      /* start at program entry point */
@@ -321,16 +332,29 @@ enum {
 
 #define AMX_USERTAG(a,b,c,d)    ((a) | ((b)<<8) | ((long)(c)<<16) | ((long)(d)<<24))
 
-#define AMX_EXPANDMARGIN  64
+#if !defined AMX_COMPACTMARGIN
+  #define AMX_COMPACTMARGIN 64
+#endif
+
+#define UD_FINDPLUGIN	3
+#define UD_DEBUGGER		2
+#define UD_OPCODELIST	1
+#define	UD_HANDLER		0
+#define	UT_NATIVE		3
+#define UT_OPTIMIZER	2
+#define UT_BROWSEHOOK	1
+#define UT_BINLOGS		0
+
+typedef void (*BROWSEHOOK)(AMX *amx, cell *oplist, cell *cip);
 
 /* for native functions that use floating point parameters, the following
  * two macros are convenient for casting a "cell" into a "float" type _without_
  * changing the bit pattern
  */
-#if SMALL_CELL_SIZE==32
+#if PAWN_CELL_SIZE==32
   #define amx_ftoc(f)   ( * ((cell*)&f) )   /* float to cell */
   #define amx_ctof(c)   ( * ((float*)&c) )  /* cell to float */
-#elif SMALL_CELL_SIZE==64
+#elif PAWN_CELL_SIZE==64
   #define amx_ftoc(f)   ( * ((cell*)&f) )   /* float to cell */
   #define amx_ctof(c)   ( * ((double*)&c) ) /* cell to float */
 #else
@@ -344,7 +368,7 @@ enum {
       amx_StrLen(amx_cstr_, &amx_length_);                                  \
       if (amx_length_ > 0 &&                                                \
           ((result) = (void*)alloca((amx_length_ + 1) * sizeof(*(result)))) != NULL) \
-        amx_GetString((char*)(result), amx_cstr_, sizeof(*(result))>1);     \
+        amx_GetString((char*)(result), amx_cstr_, sizeof(*(result))>1, amx_length_); \
       else (result) = NULL;                                                 \
     } while (0)
 
@@ -353,23 +377,13 @@ uint32_t * AMXAPI amx_Align32(uint32_t *v);
 #if defined _I64_MAX || defined HAVE_I64
   uint64_t * AMXAPI amx_Align64(uint64_t *v);
 #endif
-
-#if SMALL_CELL_SIZE==32
-#define amx_AlignCell amx_Align32
-#elif SMALL_CELL_SIZE==64
-#define amx_AlignCell amx_Align64
-#else
-#error Unsupported cell size
-#endif
-
 int AMXAPI amx_Allot(AMX *amx, int cells, cell *amx_addr, cell **phys_addr);
 int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params);
+int AMXAPI amx_CheckNatives(AMX *amx, AMX_NATIVE_FILTER nf);
 int AMXAPI amx_Cleanup(AMX *amx);
 int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data);
-int AMXAPI amx_Debug(AMX *amx); /* default debug procedure, does nothing */
-int AMXAPI amx_DebugCall(AMX *amx, int mode);
-int AMXAPI amx_Exec(AMX *amx, cell *retval, int index, int numparams, ...);
-int AMXAPI amx_Execv(AMX *amx, cell *retval, int index, int numparams, cell params[]);
+int AMXAPI amx_ExecPerf(AMX* amx, cell* retval, int index);
+int AMXAPI amx_Exec(AMX *amx, cell *retval, int index);
 int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index);
 int AMXAPI amx_FindPublic(AMX *amx, const char *funcname, int *index);
 int AMXAPI amx_FindPubVar(AMX *amx, const char *varname, cell *amx_addr);
@@ -379,39 +393,72 @@ int AMXAPI amx_GetAddr(AMX *amx,cell amx_addr,cell **phys_addr);
 int AMXAPI amx_GetNative(AMX *amx, int index, char *funcname);
 int AMXAPI amx_GetPublic(AMX *amx, int index, char *funcname);
 int AMXAPI amx_GetPubVar(AMX *amx, int index, char *varname, cell *amx_addr);
-int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar);
+int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar, size_t size);
 int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id);
 int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr);
 int AMXAPI amx_Init(AMX *amx, void *program);
 int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code);
 int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap);
 int AMXAPI amx_NameLength(AMX *amx, int *length);
-AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name,AMX_NATIVE func);
+AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name, AMX_NATIVE func);
 int AMXAPI amx_NumNatives(AMX *amx, int *number);
 int AMXAPI amx_NumPublics(AMX *amx, int *number);
 int AMXAPI amx_NumPubVars(AMX *amx, int *number);
 int AMXAPI amx_NumTags(AMX *amx, int *number);
+int AMXAPI amx_Push(AMX *amx, cell value);
+int AMXAPI amx_PushArray(AMX *amx, cell *amx_addr, cell **phys_addr, const cell array[], int numcells);
+int AMXAPI amx_PushString(AMX *amx, cell *amx_addr, cell **phys_addr, const char *string, int pack, int use_wchar);
 int AMXAPI amx_RaiseError(AMX *amx, int error);
-int AMXAPI amx_Register(AMX *amx, AMX_NATIVE_INFO *nativelist, int number);
+int AMXAPI amx_Register(AMX *amx, const AMX_NATIVE_INFO *nativelist, int number);
+int AMXAPI amx_Reregister(AMX *amx, const AMX_NATIVE_INFO *nativelist, int number);
+int AMXAPI amx_RegisterToAny(AMX *amx, AMX_NATIVE f);
 int AMXAPI amx_Release(AMX *amx, cell amx_addr);
 int AMXAPI amx_SetCallback(AMX *amx, AMX_CALLBACK callback);
 int AMXAPI amx_SetDebugHook(AMX *amx, AMX_DEBUG debug);
-int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar);
+int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar, size_t size);
 int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr);
-int AMXAPI amx_StrLen(cell *cstring, int *length);
+int AMXAPI amx_StrLen(const cell *cstring, int *length);
+int AMXAPI amx_UTF8Check(const char *string, int *length);
 int AMXAPI amx_UTF8Get(const char *string, const char **endptr, cell *value);
+int AMXAPI amx_UTF8Len(const cell *cstr, int *length);
 int AMXAPI amx_UTF8Put(char *string, char **endptr, int maxchars, cell value);
-int AMXAPI amx_UTF8Check(const char *string);
-void amx_NullNativeTable(AMX *amx);
+int AMXAPI amx_GetLibraries(AMX *amx);
+const char *AMXAPI amx_GetLibrary(AMX *amx, int index, char *buffer, int len);
+int AMXAPI amx_SetStringOld(cell *dest,const char *source,int pack,int use_wchar);
+int AMXAPI amx_GetStringOld(char *dest,const cell *source,int use_wchar);
+
+#if PAWN_CELL_SIZE==16
+  #define amx_AlignCell(v) amx_Align16(v)
+#elif PAWN_CELL_SIZE==32
+  #define amx_AlignCell(v) amx_Align32(v)
+#elif PAWN_CELL_SIZE==64 && (defined _I64_MAX || defined HAVE_I64)
+  #define amx_AlignCell(v) amx_Align64(v)
+#else
+  #error Unsupported cell size
+#endif
+
+#define amx_RegisterFunc(amx, name, func) \
+  amx_Register((amx), amx_NativeInfo((name),(func)), 1);
 
 #if !defined AMX_NO_ALIGN
-  #if defined __linux__
+  #if defined LINUX || defined __FreeBSD__ || defined __APPLE__
     #pragma pack()    /* reset default packing */
+  #elif defined MACOS && defined __MWERKS__
+    #pragma options align=reset
   #else
     #pragma pack(pop) /* reset previous packing */
   #endif
 #endif
 
+#if defined BINLOG_ENABLED
+typedef struct tagBINLOG
+{
+	void	(*pfnLogNative)(AMX *amx, int native, int params);
+	void	(*pfnLogReturn)(AMX *amx, cell retval);
+	void	(*pfnLogParams)(AMX *amx, cell *params);
+} binlogfuncs_t;
+#endif
+
 #ifdef  __cplusplus
 }
 #endif

amxmodx/amx_mm.def

@@ -1,11 +0,0 @@
-; /usr/local/cross-tools/bin/i386-mingw32msvc-dlltool --base-file /tmp/cc4kB6s0.base --output-exp amx_mm.exp --dllname amx_mm.dll --output-def amx_mm.def --add-stdcall-alias --exclude-symbol=DllMainCRTStartup@12 --def /tmp/ccyI7I7K.def
-EXPORTS
-	GetEngineFunctions @ 1 ; 
-	GetEngineFunctions_Post @ 2 ; 
-	GetEntityAPI2 @ 3 ; 
-	GetEntityAPI2_Post @ 4 ; 
-	GiveFnptrsToDll = GiveFnptrsToDll@8 @ 5 ; 
-	GiveFnptrsToDll@8 @ 6 ; 
-	Meta_Attach @ 7 ; 
-	Meta_Detach @ 8 ; 
-	Meta_Query @ 9 ; 

amxmodx/amxcore.cpp

@@ -1,6 +1,6 @@
-/*  Core module for the Small AMX
+/*  Core module for the Pawn AMX
  *
- *  Copyright (c) ITB CompuPhase, 1997-2004
+ *  Copyright (c) ITB CompuPhase, 1997-2005
  *
  *  This software is provided "as-is", without any express or implied warranty.
  *  In no event will the authors be held liable for any damages arising from
@@ -17,9 +17,8 @@
  *  2.  Altered source versions must be plainly marked as such, and must not be
  *      misrepresented as being the original software.
  *  3.  This notice may not be removed or altered from any source distribution.
- *
- *  Version: $Id$
  */
+
 #if defined _UNICODE || defined __UNICODE__ || defined UNICODE
 # if !defined UNICODE   /* for Windows */
 #   define UNICODE
@@ -34,14 +33,7 @@
 #include <string.h>
 #include <limits.h>
 #include <assert.h>
-
-// this file does not include amxmodx.h, so we have to include the memory manager here
-#ifdef MEMORY_TEST
-#include "mmgr/mmgr.h"
-#endif // MEMORY_TEST
-
 #include "amx.h"
-
 #if defined __WIN32__ || defined _WIN32 || defined WIN32 || defined _Windows
   #include <windows.h>
 #endif
@@ -60,14 +52,13 @@
 # define _tcscpy        strcpy
 # define _tcsdup        strdup
 # define _tcslen        strlen
-# define _stprintf      sprintf
 #endif
 
 
 #define CHARBITS        (8*sizeof(char))
 typedef unsigned char   uchar;
 
-#if !defined NOPROPLIST
+#if !defined AMX_NOPROPLIST
 typedef struct _property_list {
   struct _property_list *next;
   cell id;
@@ -76,7 +67,7 @@ typedef struct _property_list {
   //??? safe AMX (owner of the property)
 } proplist;
 
-static proplist proproot = { NULL };
+static proplist proproot = { NULL, 0, NULL, 0 };
 
 static proplist *list_additem(proplist *root)
 {
@@ -142,15 +133,13 @@ static proplist *list_finditem(proplist *root,cell id,char *name,cell value,
 }
 #endif
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL numargs(AMX *amx, cell *params)
 {
   AMX_HEADER *hdr;
   uchar *data;
   cell bytes;
 
+  (void)params;
   hdr=(AMX_HEADER *)amx->base;
   data=amx->data ? amx->data : amx->base+(int)hdr->dat;
   /* the number of bytes is on the stack, at "frm + 2*cell" */
@@ -197,11 +186,9 @@ static cell AMX_NATIVE_CALL setarg(AMX *amx, cell *params)
   return 1;
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL heapspace(AMX *amx,cell *params)
 {
+  (void)params;
   return amx->stk - amx->hea;
 }
 
@@ -220,142 +207,22 @@ static cell AMX_NATIVE_CALL funcidx(AMX *amx,cell *params)
     return 0;
   } /* if */
 
-  amx_GetString(name,cstr,0);
+  amx_GetString(name,cstr,0,UNLIMITED);
   err=amx_FindPublic(amx,name,&index);
   if (err!=AMX_ERR_NONE)
     index=-1;   /* this is not considered a fatal error */
   return index;
 }
 
-int amx_StrPack(cell *dest,cell *source)
-{
-  int len;
-
-  amx_StrLen(source,&len);
-  if ((ucell)*source>UNPACKEDMAX) {
-    /* source string is already packed */
-    while (len >= 0) {
-      *dest++ = *source++;
-      len-=sizeof(cell);
-    } /* while */
-  } else {
-    /* pack string, from bottom up */
-    cell c;
-    int i;
-    for (c=0,i=0; i<len; i++) {
-      assert((*source & ~0xffL)==0);
-      c=(c<<CHARBITS) | *source++;
-      if (i%sizeof(cell) == sizeof(cell)-1) {
-        *dest++=c;
-        c=0;
-      } /* if */
-    } /* for */
-    if (i%sizeof(cell) != 0)    /* store remaining packed characters */
-      *dest=c << (sizeof(cell)-i%sizeof(cell))*CHARBITS;
-    else
-      *dest=0;                  /* store full cell of zeros */
-  } /* if */
-  return AMX_ERR_NONE;
-}
-
-int amx_StrUnpack(cell *dest,cell *source)
-{
-  if ((ucell)*source>UNPACKEDMAX) {
-    /* unpack string, from top down (so string can be unpacked in place) */
-    cell c;
-    int i,len;
-    amx_StrLen(source,&len);
-    dest[len]=0;
-    for (i=len-1; i>=0; i--) {
-      c=source[i/sizeof(cell)] >> (sizeof(cell)-i%sizeof(cell)-1)*CHARBITS;
-      dest[i]=c & UCHAR_MAX;
-    } /* for */
-  } else {
-    /* source string is already unpacked */
-    while ((*dest++ = *source++) != 0)
-      /* nothing */;
-  } /* if */
-  return AMX_ERR_NONE;
-}
-
-static int verify_addr(AMX *amx,cell addr)
-{
-  int err;
-  cell *cdest;
-
-  err=amx_GetAddr(amx,addr,&cdest);
-  if (err!=AMX_ERR_NONE)
-    amx_RaiseError(amx,err);
-  return err;
-}
-
-static cell AMX_NATIVE_CALL core_strlen(AMX *amx,cell *params)
-{
-  cell *cptr;
-  int len = 0;
-
-  if (amx_GetAddr(amx,params[1],&cptr)==AMX_ERR_NONE)
-    amx_StrLen(cptr,&len);
-  return len;
-}
-
-static cell AMX_NATIVE_CALL strpack(AMX *amx,cell *params)
-{
-  cell *cdest,*csrc;
-  int len,needed,err;
-  size_t lastaddr;
-
-  /* calculate number of cells needed for (packed) destination */
-  amx_GetAddr(amx,params[2],&csrc);
-  amx_StrLen(csrc,&len);
-  needed=(len+sizeof(cell))/sizeof(cell);     /* # of cells needed */
-  assert(needed>0);
-  lastaddr=(size_t)(params[1]+sizeof(cell)*needed-1);
-  if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE)
-    return 0;
-
-  amx_GetAddr(amx,params[1],&cdest);
-  err=amx_StrPack(cdest,csrc);
-  if (err!=AMX_ERR_NONE)
-    return amx_RaiseError(amx,err);
-
-  return len;
-}
-
-static cell AMX_NATIVE_CALL strunpack(AMX *amx,cell *params)
-{
-  cell *cdest,*csrc;
-  int len,err;
-  size_t lastaddr;
-
-  /* calculate number of cells needed for (packed) destination */
-  amx_GetAddr(amx,params[2],&csrc);
-  amx_StrLen(csrc,&len);
-  assert(len>=0);
-  lastaddr=(size_t)(params[1]+sizeof(cell)*(len+1)-1);
-  if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE)
-    return 0;
-
-  amx_GetAddr(amx,params[1],&cdest);
-  err=amx_StrUnpack(cdest,csrc);
-  if (err!=AMX_ERR_NONE)
-    return amx_RaiseError(amx,err);
-
-  return len;
-}
-
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL swapchars(AMX *amx,cell *params)
 {
   union {
     cell c;
-    #if SMALL_CELL_SIZE==16
+    #if PAWN_CELL_SIZE==16
       uchar b[2];
-    #elif SMALL_CELL_SIZE==32
+    #elif PAWN_CELL_SIZE==32
       uchar b[4];
-    #elif SMALL_CELL_SIZE==64
+    #elif PAWN_CELL_SIZE==64
       uchar b[8];
 	#else
 	  #error Unsupported cell size
@@ -363,20 +230,21 @@ static cell AMX_NATIVE_CALL swapchars(AMX *amx,cell *params)
   } value;
   uchar t;
 
+  (void)amx;
   assert((size_t)params[0]==sizeof(cell));
   value.c = params[1];
-  #if SMALL_CELL_SIZE==16
+  #if PAWN_CELL_SIZE==16
     t = value.b[0];
     value.b[0] = value.b[1];
     value.b[1] = t;
-  #elif SMALL_CELL_SIZE==32
+  #elif PAWN_CELL_SIZE==32
     t = value.b[0];
     value.b[0] = value.b[3];
     value.b[3] = t;
     t = value.b[1];
     value.b[1] = value.b[2];
     value.b[2] = t;
-  #elif SMALL_CELL_SIZE==64
+  #elif PAWN_CELL_SIZE==64
     t = value.b[0];
     value.b[0] = value.b[7];
     value.b[7] = t;
@@ -395,11 +263,9 @@ static cell AMX_NATIVE_CALL swapchars(AMX *amx,cell *params)
   return value.c;
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL core_tolower(AMX *amx,cell *params)
 {
+  (void)amx;
   #if defined __WIN32__ || defined _WIN32 || defined WIN32
     return (cell)CharLower((LPTSTR)params[1]);
   #elif defined _Windows
@@ -409,11 +275,9 @@ static cell AMX_NATIVE_CALL core_tolower(AMX *amx,cell *params)
   #endif
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL core_toupper(AMX *amx,cell *params)
 {
+  (void)amx;
   #if defined __WIN32__ || defined _WIN32 || defined WIN32
     return (cell)CharUpper((LPTSTR)params[1]);
   #elif defined _Windows
@@ -423,19 +287,15 @@ static cell AMX_NATIVE_CALL core_toupper(AMX *amx,cell *params)
   #endif
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL core_min(AMX *amx,cell *params)
 {
+  (void)amx;
   return params[1] <= params[2] ? params[1] : params[2];
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL core_max(AMX *amx,cell *params)
 {
+  (void)amx;
   return params[1] >= params[2] ? params[1] : params[2];
 }
 
@@ -451,7 +311,7 @@ static cell AMX_NATIVE_CALL core_clamp(AMX *amx,cell *params)
   return value;
 }
 
-#if !defined NOPROPLIST
+#if !defined AMX_NOPROPLIST
 static char *MakePackedString(cell *cptr)
 {
   int len;
@@ -459,10 +319,21 @@ static char *MakePackedString(cell *cptr)
 
   amx_StrLen(cptr,&len);
   dest=(char *)malloc(len+sizeof(cell));
-  amx_GetString(dest,cptr,0);
+  amx_GetString(dest,cptr,0,UNLIMITED);
   return dest;
 }
 
+static int verify_addr(AMX *amx,cell addr)
+{
+  int err;
+  cell *cdest;
+
+  err=amx_GetAddr(amx,addr,&cdest);
+  if (err!=AMX_ERR_NONE)
+    amx_RaiseError(amx,err);
+  return err;
+}
+
 static cell AMX_NATIVE_CALL getproperty(AMX *amx,cell *params)
 {
   cell *cstr;
@@ -480,7 +351,7 @@ static cell AMX_NATIVE_CALL getproperty(AMX *amx,cell *params)
       return 0;
     } /* if */
     amx_GetAddr(amx,params[4],&cstr);
-    amx_SetString(cstr,item->name,1,0);
+    amx_SetString(cstr,item->name,1,0,UNLIMITED);
   } /* if */
   free(name);
   return (item!=NULL) ? item->value : 0;
@@ -545,12 +416,14 @@ static cell AMX_NATIVE_CALL existproperty(AMX *amx,cell *params)
 }
 #endif
 
+#if !defined AMX_NORANDOM
 /* This routine comes from the book "Inner Loops" by Rick Booth, Addison-Wesley
  * (ISBN 0-201-47960-5). This is a "multiplicative congruential random number
  * generator" that has been extended to 31-bits (the standard C version returns
  * only 15-bits).
  */
-static unsigned long IL_StandardRandom_seed = 0L;
+#define INITIAL_SEED  0xcaa938dbL
+static unsigned long IL_StandardRandom_seed = INITIAL_SEED; /* always use a non-zero seed */
 #define IL_RMULT 1103515245L
 #if defined __BORLANDC__ || defined __WATCOMC__
   #pragma argsused
@@ -562,7 +435,7 @@ static cell AMX_NATIVE_CALL core_random(AMX *amx,cell *params)
 
     /* one-time initialization (or, mostly one-time) */
     #if !defined SN_TARGET_PS2 && !defined _WIN32_WCE
-        if (IL_StandardRandom_seed == 0L)
+        if (IL_StandardRandom_seed == INITIAL_SEED)
             IL_StandardRandom_seed=(unsigned long)time(NULL);
     #endif
 
@@ -579,6 +452,7 @@ static cell AMX_NATIVE_CALL core_random(AMX *amx,cell *params)
         result %= params[1];
     return (cell)result;
 }
+#endif
 
 
 AMX_NATIVE_INFO core_Natives[] = {
@@ -587,22 +461,13 @@ AMX_NATIVE_INFO core_Natives[] = {
   { "setarg",        setarg },
   { "heapspace",     heapspace },
   { "funcidx",       funcidx },
-  { "strlen",        core_strlen },
-  { "strpack",       strpack },
-  { "strunpack",     strunpack },
   { "swapchars",     swapchars },
   { "tolower",       core_tolower },
   { "toupper",       core_toupper },
-  { "random",        core_random },
   { "min",           core_min },
   { "max",           core_max },
   { "clamp",         core_clamp },
-#if !defined NOPROPLIST
-  { "getproperty",   getproperty },
-  { "setproperty",   setproperty },
-  { "deleteproperty",delproperty },
-  { "existproperty", existproperty },
-#endif
+  { "random",        core_random },
   { NULL, NULL }        /* terminator */
 };
 
@@ -611,12 +476,10 @@ int AMXEXPORT amx_CoreInit(AMX *amx)
   return amx_Register(amx, core_Natives, -1);
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 int AMXEXPORT amx_CoreCleanup(AMX *amx)
 {
-  #if !defined NOPROPLIST
+  (void)amx;
+  #if !defined AMX_NOPROPLIST
     //??? delete only the properties owned by the AMX
     while (proproot.next!=NULL)
       list_delete(&proproot,proproot.next);

amxmodx/amxdbg.cpp

@@ -0,0 +1,497 @@
+/*  Pawn debugger interface
+ *
+ *  Support functions for debugger applications
+ *
+ *  Copyright (c) ITB CompuPhase, 2005
+ *
+ *  This software is provided "as-is", without any express or implied warranty.
+ *  In no event will the authors be held liable for any damages arising from
+ *  the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1.  The origin of this software must not be misrepresented; you must not
+ *      claim that you wrote the original software. If you use this software in
+ *      a product, an acknowledgment in the product documentation would be
+ *      appreciated but is not required.
+ *  2.  Altered source versions must be plainly marked as such, and must not be
+ *      misrepresented as being the original software.
+ *  3.  This notice may not be removed or altered from any source distribution.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include "osdefs.h"     /* for _MAX_PATH */
+#include "amx.h"
+#include "amxdbg.h"
+
+// this file does not include amxmodx.h, so we have to include the memory manager here
+#ifdef MEMORY_TEST
+#include "mmgr/mmgr.h"
+#endif // MEMORY_TEST
+
+int AMXAPI dbg_FreeInfo(AMX_DBG *amxdbg)
+{
+  assert(amxdbg != NULL);
+  if (amxdbg->hdr != NULL)
+    free(amxdbg->hdr);
+  if (amxdbg->filetbl != NULL)
+    free(amxdbg->filetbl);
+  if (amxdbg->symboltbl != NULL)
+    free(amxdbg->symboltbl);
+  if (amxdbg->tagtbl != NULL)
+    free(amxdbg->tagtbl);
+  if (amxdbg->automatontbl != NULL)
+    free(amxdbg->automatontbl);
+  if (amxdbg->statetbl != NULL)
+    free(amxdbg->statetbl);
+  memset(amxdbg, 0, sizeof(AMX_DBG));
+  return AMX_ERR_NONE;
+}
+
+void memread(void *dest, char **src, size_t size)
+{
+	void *ptr = *src;
+	memcpy(dest, ptr, size);
+	*src += size;
+}
+
+const char *ClipFileName(const char *inp)
+{
+	static char buffer[256];
+	size_t len = strlen(inp);
+	const char *ptr = inp;
+
+	for (size_t i=0; i<len; i++)
+	{
+		if ((inp[i] == '\\' || inp[i] == '/') && (i != len-1))
+			ptr = inp + i + 1;
+	}
+	strcpy(buffer, ptr);
+
+	return buffer;
+}
+
+//Note - I changed this function to read from memory instead.
+// -- BAILOPAN
+int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, void *dbg_addr)
+{
+  AMX_DBG_HDR dbghdr;
+  unsigned char *ptr;
+  int index, dim;
+  AMX_DBG_SYMDIM *symdim;
+
+  assert(amxdbg != NULL);
+
+  char *addr = (char *)(dbg_addr);
+
+  memset(&dbghdr, 0, sizeof(AMX_DBG_HDR));
+  memread(&dbghdr, &addr, sizeof(AMX_DBG_HDR));
+
+  //brabbby graa gragghty graaahhhh
+  #if BYTE_ORDER==BIG_ENDIAN
+    amx_Align32((uint32_t*)&dbghdr.size);
+    amx_Align16(&dbghdr.magic);
+    amx_Align16(&dbghdr.flags);
+    amx_Align16(&dbghdr.files);
+    amx_Align16(&dbghdr.lines);
+    amx_Align16(&dbghdr.symbols);
+    amx_Align16(&dbghdr.tags);
+    amx_Align16(&dbghdr.automatons);
+    amx_Align16(&dbghdr.states);
+  #endif
+
+  if (dbghdr.magic != AMX_DBG_MAGIC)
+    return AMX_ERR_FORMAT;
+
+  /* allocate all memory */
+  memset(amxdbg, 0, sizeof(AMX_DBG));
+  amxdbg->hdr = (AMX_DBG_HDR *)malloc((size_t)dbghdr.size);
+  if (dbghdr.files > 0)
+    amxdbg->filetbl = (AMX_DBG_FILE **)malloc(dbghdr.files * sizeof(AMX_DBG_FILE *));
+  if (dbghdr.symbols > 0)
+    amxdbg->symboltbl = (AMX_DBG_SYMBOL **)malloc(dbghdr.symbols * sizeof(AMX_DBG_SYMBOL *));
+  if (dbghdr.tags > 0)
+    amxdbg->tagtbl = (AMX_DBG_TAG **)malloc(dbghdr.tags * sizeof(AMX_DBG_TAG *));
+  if (dbghdr.automatons > 0)
+    amxdbg->automatontbl = (AMX_DBG_MACHINE **)malloc(dbghdr.automatons * sizeof(AMX_DBG_MACHINE *));
+  if (dbghdr.states > 0)
+    amxdbg->statetbl = (AMX_DBG_STATE **)malloc(dbghdr.states * sizeof(AMX_DBG_STATE *));
+  if (amxdbg->hdr == NULL
+      || (dbghdr.files > 0 && amxdbg->filetbl == NULL)
+      || (dbghdr.symbols > 0 && amxdbg->symboltbl == NULL)
+      || (dbghdr.tags > 0 && amxdbg->tagtbl == NULL)
+      || (dbghdr.states > 0 && amxdbg->statetbl == NULL)
+      || (dbghdr.automatons > 0 && amxdbg->automatontbl == NULL))
+  {
+    dbg_FreeInfo(amxdbg);
+    return AMX_ERR_MEMORY;
+  } /* if */
+
+  /* load the entire symbolic information block into memory */
+  memcpy(amxdbg->hdr, &dbghdr, sizeof dbghdr);
+  ptr = (unsigned char *)(amxdbg->hdr + 1);
+  memread(ptr, &addr, (size_t)(dbghdr.size-sizeof(dbghdr)));
+
+  /* file table */
+  for (index = 0; index < dbghdr.files; index++) {
+    assert(amxdbg->filetbl != NULL);
+    amxdbg->filetbl[index] = (AMX_DBG_FILE *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_AlignCell(&amxdbg->filetbl[index]->address);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_FILE); *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+  } /* for */
+
+  //debug("Files: %d\n", amxdbg->hdr->files);
+  for (index=0;index<amxdbg->hdr->files; index++)
+  {
+	  strcpy((char *)amxdbg->filetbl[index]->name, ClipFileName(amxdbg->filetbl[index]->name));
+	  //debug(" [%d] %s\n", index, amxdbg->filetbl[index]->name);
+  }
+
+  /* line table */
+  amxdbg->linetbl = (AMX_DBG_LINE*)ptr;
+  #if BYTE_ORDER==BIG_ENDIAN
+    for (index = 0; index < dbghdr.lines; index++) {
+      amx_AlignCell(&amxdbg->linetbl[index].address);
+      amx_Align32((uint32_t*)&amxdbg->linetbl[index].line);
+    } /* for */
+  #endif
+  ptr += dbghdr.lines * sizeof(AMX_DBG_LINE);
+
+  /* symbol table (plus index tags) */
+  for (index = 0; index < dbghdr.symbols; index++) {
+    assert(amxdbg->symboltbl != NULL);
+    amxdbg->symboltbl[index] = (AMX_DBG_SYMBOL *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_AlignCell(&amxdbg->symboltbl[index]->address);
+      amx_Align16((uint16_t*)&amxdbg->symboltbl[index]->tag);
+      amx_AlignCell(&amxdbg->symboltbl[index]->codestart);
+      amx_AlignCell(&amxdbg->symboltbl[index]->codeend);
+      amx_Align16((uint16_t*)&amxdbg->symboltbl[index]->dim);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_SYMBOL); *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+    for (dim = 0; dim < amxdbg->symboltbl[index]->dim; dim++) {
+      symdim = (AMX_DBG_SYMDIM *)ptr;
+      amx_Align16((uint16_t*)&symdim->tag);
+      amx_AlignCell(&symdim->size);
+      ptr += sizeof(AMX_DBG_SYMDIM);
+    } /* for */
+  } /* for */
+
+  /* tag name table */
+  for (index = 0; index < dbghdr.tags; index++) {
+    assert(amxdbg->tagtbl != NULL);
+    amxdbg->tagtbl[index] = (AMX_DBG_TAG *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_Align16(&amxdbg->tagtbl[index]->tag);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_TAG) - 1; *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+  } /* for */
+
+  /* automaton name table */
+  for (index = 0; index < dbghdr.automatons; index++) {
+    assert(amxdbg->automatontbl != NULL);
+    amxdbg->automatontbl[index] = (AMX_DBG_MACHINE *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_Align16(&amxdbg->automatontbl[index]->automaton);
+      amx_AlignCell(&amxdbg->automatontbl[index]->address);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_MACHINE) - 1; *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+  } /* for */
+
+  /* state name table */
+  for (index = 0; index < dbghdr.states; index++) {
+    assert(amxdbg->statetbl != NULL);
+    amxdbg->statetbl[index] = (AMX_DBG_STATE *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_Align16(&amxdbg->statetbl[index]->state);
+      amx_Align16(&amxdbg->automatontbl[index]->automaton);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_STATE) - 1; *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+  } /* for */
+
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_LookupFile(AMX_DBG *amxdbg, ucell address, const char **filename)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(filename != NULL);
+  *filename = NULL;
+  /* this is a simple linear look-up; a binary search would be possible too */
+  for (index = 0; index < amxdbg->hdr->files && amxdbg->filetbl[index]->address <= address; index++)
+    /* nothing */;
+  /* reset for overrun */
+  if (--index < 0)
+    return AMX_ERR_NOTFOUND;
+
+  *filename = amxdbg->filetbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_LookupLine(AMX_DBG *amxdbg, ucell address, long *line)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(line != NULL);
+  *line = 0;
+  /* this is a simple linear look-up; a binary search would be possible too */
+  for (index = 0; index < amxdbg->hdr->lines && amxdbg->linetbl[index].address <= address; index++)
+    /* nothing */;
+  /* reset for overrun */
+  if (--index < 0)
+    return AMX_ERR_NOTFOUND;
+
+  *line = (long)amxdbg->linetbl[index].line;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_LookupFunction(AMX_DBG *amxdbg, ucell address, const char **funcname)
+{
+  /* dbg_LookupFunction() finds the function a code address is in. It can be
+   * used for stack walking, and for stepping through a function while stepping
+   * over sub-functions
+   */
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(funcname != NULL);
+  *funcname = NULL;
+  for (index = 0; index < amxdbg->hdr->symbols; index++) {
+    if (amxdbg->symboltbl[index]->ident == iFUNCTN
+        && amxdbg->symboltbl[index]->codestart <= address
+        && amxdbg->symboltbl[index]->codeend > address)
+      break;
+  } /* for */
+  if (index >= amxdbg->hdr->symbols)
+    return AMX_ERR_NOTFOUND;
+
+  *funcname = amxdbg->symboltbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetTagName(AMX_DBG *amxdbg, int tag, const char **name)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(name != NULL);
+  *name = NULL;
+  for (index = 0; index < amxdbg->hdr->tags && amxdbg->tagtbl[index]->tag != tag; index++)
+    /* nothing */;
+  if (index >= amxdbg->hdr->tags)
+    return AMX_ERR_NOTFOUND;
+
+  *name = amxdbg->tagtbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetAutomatonName(AMX_DBG *amxdbg, int automaton, const char **name)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(name != NULL);
+  *name = NULL;
+  for (index = 0; index < amxdbg->hdr->automatons && amxdbg->automatontbl[index]->automaton != automaton; index++)
+    /* nothing */;
+  if (index >= amxdbg->hdr->automatons)
+    return AMX_ERR_NOTFOUND;
+
+  *name = amxdbg->automatontbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetStateName(AMX_DBG *amxdbg, int state, const char **name)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(name != NULL);
+  *name = NULL;
+  for (index = 0; index < amxdbg->hdr->states && amxdbg->statetbl[index]->state != state; index++)
+    /* nothing */;
+  if (index >= amxdbg->hdr->states)
+    return AMX_ERR_NOTFOUND;
+
+  *name = amxdbg->statetbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetLineAddress(AMX_DBG *amxdbg, long line, const char *filename, ucell *address)
+{
+  /* Find a suitable "breakpoint address" close to the indicated line (and in
+   * the specified file). The address is moved up to the next "breakable" line
+   * if no "breakpoint" is available on the specified line. You can use function
+   * dbg_LookupLine() to find out at which precise line the breakpoint was set.
+   *
+   * The filename comparison is strict (case sensitive and path sensitive); the
+   * "filename" parameter should point into the "filetbl" of the AMX_DBG
+   * structure.
+   */
+  int file, index;
+  ucell bottomaddr,topaddr;
+
+  assert(amxdbg != NULL);
+  assert(filename != NULL);
+  assert(address != NULL);
+  *address = 0;
+
+  index = 0;
+  for (file = 0; file < amxdbg->hdr->files; file++) {
+    /* find the (next) mathing instance of the file */
+    if (strcmp(amxdbg->filetbl[file]->name, filename) != 0)
+      continue;
+    /* get address range for the current file */
+    bottomaddr = amxdbg->filetbl[file]->address;
+    topaddr = (file + 1 < amxdbg->hdr->files) ? amxdbg->filetbl[file+1]->address : (ucell)(cell)-1;
+    /* go to the starting address in the line table */
+    while (index < amxdbg->hdr->lines && amxdbg->linetbl[index].address < bottomaddr)
+      index++;
+    /* browse until the line is found or until the top address is exceeded */
+    while (index < amxdbg->hdr->lines
+           && amxdbg->linetbl[index].line < line
+           && amxdbg->linetbl[index].address < topaddr)
+      index++;
+    if (index >= amxdbg->hdr->lines)
+      return AMX_ERR_NOTFOUND;
+    if (amxdbg->linetbl[index].line >= line)
+      break;
+    /* if not found (and the line table is not yet exceeded) try the next
+     * instance of the same file (a file may appear twice in the file table)
+     */
+  } /* for */
+
+  if (strcmp(amxdbg->filetbl[file]->name, filename) != 0)
+    return AMX_ERR_NOTFOUND;
+
+  assert(index < amxdbg->hdr->lines);
+  *address = amxdbg->linetbl[index].address;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetFunctionAddress(AMX_DBG *amxdbg, const char *funcname, const char *filename, ucell *address)
+{
+  /* Find a suitable "breakpoint address" close to the indicated line (and in
+   * the specified file). The address is moved up to the first "breakable" line
+   * in the function. You can use function dbg_LookupLine() to find out at which
+   * precise line the breakpoint was set.
+   *
+   * The filename comparison is strict (case sensitive and path sensitive); the
+   * "filename" parameter should point into the "filetbl" of the AMX_DBG
+   * structure. The function name comparison is case sensitive too.
+   */
+  int index, err;
+  const char *tgtfile;
+  ucell funcaddr;
+
+  assert(amxdbg != NULL);
+  assert(funcname != NULL);
+  assert(filename != NULL);
+  assert(address != NULL);
+  *address = 0;
+
+  index = 0;
+  for ( ;; ) {
+    /* find (next) matching function */
+    while (index < amxdbg->hdr->symbols
+           && (amxdbg->symboltbl[index]->ident != iFUNCTN || strcmp(amxdbg->symboltbl[index]->name, funcname) != 0))
+      index++;
+    if (index >= amxdbg->hdr->symbols)
+      return AMX_ERR_NOTFOUND;
+    /* verify that this line falls in the appropriate file */
+    err = dbg_LookupFile(amxdbg, amxdbg->symboltbl[index]->address, &tgtfile);
+    if (err == AMX_ERR_NONE || strcmp(filename, tgtfile) == 0)
+      break;
+    index++;            /* line is the wrong file, search further */
+  } /* for */
+
+  /* now find the first line in the function where we can "break" on */
+  assert(index < amxdbg->hdr->symbols);
+  funcaddr = amxdbg->symboltbl[index]->address;
+  for (index = 0; index < amxdbg->hdr->lines && amxdbg->linetbl[index].address < funcaddr; index++)
+    /* nothing */;
+
+  if (index >= amxdbg->hdr->lines)
+    return AMX_ERR_NOTFOUND;
+  *address = amxdbg->linetbl[index].address;
+
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetVariable(AMX_DBG *amxdbg, const char *symname, ucell scopeaddr, const AMX_DBG_SYMBOL **sym)
+{
+  ucell codestart,codeend;
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(symname != NULL);
+  assert(sym != NULL);
+  *sym = NULL;
+
+  codestart = codeend = 0;
+  index = 0;
+  for ( ;; ) {
+    /* find (next) matching variable */
+    while (index < amxdbg->hdr->symbols
+           && (amxdbg->symboltbl[index]->ident == iFUNCTN || strcmp(amxdbg->symboltbl[index]->name, symname) != 0)
+           && (amxdbg->symboltbl[index]->codestart > scopeaddr || amxdbg->symboltbl[index]->codeend < scopeaddr))
+      index++;
+    if (index >= amxdbg->hdr->symbols)
+      break;
+    /* check the range, keep a pointer to the symbol with the smallest range */
+    if (strcmp(amxdbg->symboltbl[index]->name, symname) == 0
+        && ((codestart == 0 && codeend == 0)
+            || (amxdbg->symboltbl[index]->codestart >= codestart && amxdbg->symboltbl[index]->codeend <= codeend)))
+    {
+      *sym = amxdbg->symboltbl[index];
+      codestart = amxdbg->symboltbl[index]->codestart;
+      codeend = amxdbg->symboltbl[index]->codeend;
+    } /* if */
+    index++;
+  } /* for */
+
+  return (*sym == NULL) ? AMX_ERR_NOTFOUND : AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetArrayDim(AMX_DBG *amxdbg, const AMX_DBG_SYMBOL *sym, const AMX_DBG_SYMDIM **symdim)
+{
+  /* retrieves a pointer to the array dimensions structures of an array symbol */
+  const char *ptr;
+
+  assert(amxdbg != NULL);
+  assert(sym != NULL);
+  assert(symdim != NULL);
+  *symdim = NULL;
+
+  if (sym->ident != iARRAY && sym->ident != iREFARRAY)
+    return AMX_ERR_PARAMS;
+  assert(sym->dim > 0); /* array must have at least one dimension */
+
+  /* find the end of the symbol name */
+  for (ptr = sym->name; *ptr != '\0'; ptr++)
+    /* nothing */;
+  *symdim = (AMX_DBG_SYMDIM *)(ptr + 1);/* skip '\0' too */
+
+  return AMX_ERR_NONE;
+}

amxmodx/amxdbg.h

@@ -0,0 +1,170 @@
+/*  Abstract Machine for the Pawn compiler, debugger support
+ *
+ *  This file contains extra definitions that are convenient for debugger
+ *  support.
+ *
+ *  Copyright (c) ITB CompuPhase, 2005
+ *
+ *  This software is provided "as-is", without any express or implied warranty.
+ *  In no event will the authors be held liable for any damages arising from
+ *  the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1.  The origin of this software must not be misrepresented; you must not
+ *      claim that you wrote the original software. If you use this software in
+ *      a product, an acknowledgment in the product documentation would be
+ *      appreciated but is not required.
+ *  2.  Altered source versions must be plainly marked as such, and must not be
+ *      misrepresented as being the original software.
+ *  3.  This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef AMXDBG_H_INCLUDED
+#define AMXDBG_H_INCLUDED
+
+#ifndef AMX_H_INCLUDED
+  #include "amx.h"
+#endif
+
+#ifdef  __cplusplus
+extern  "C" {
+#endif
+
+/* Some compilers do not support the #pragma align, which should be fine. Some
+ * compilers give a warning on unknown #pragmas, which is not so fine...
+ */
+#if defined SN_TARGET_PS2 || defined __GNUC__
+  #define AMX_NO_ALIGN
+#endif
+
+#if defined __GNUC__
+  #define PACKED        __attribute__((packed))
+#else
+  #define PACKED
+#endif
+
+#if !defined AMX_NO_ALIGN
+  #if defined LINUX || defined __FreeBSD__ || defined __APPLE__
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+  #elif defined MACOS && defined __MWERKS__
+	#pragma options align=mac68k
+  #else
+    #pragma pack(push)
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+    #if defined __TURBOC__
+      #pragma option -a-    /* "pack" pragma for older Borland compilers */
+    #endif
+  #endif
+#endif
+
+typedef struct tagAMX_DBG_HDR {
+  int32_t size          PACKED; /* size of the debug information chunk */
+  uint16_t magic        PACKED; /* signature, must be 0xf1ef */
+  char    file_version;         /* file format version */
+  char    amx_version;          /* required version of the AMX */
+  int16_t flags         PACKED; /* currently unused */
+  int16_t files         PACKED; /* number of entries in the "file" table */
+  int16_t lines         PACKED; /* number of entries in the "line" table */
+  int16_t symbols       PACKED; /* number of entries in the "symbol" table */
+  int16_t tags          PACKED; /* number of entries in the "tag" table */
+  int16_t automatons    PACKED; /* number of entries in the "automaton" table */
+  int16_t states        PACKED; /* number of entries in the "state" table */
+} PACKED AMX_DBG_HDR;
+#define AMX_DBG_MAGIC   0xf1ef
+
+typedef struct tagAMX_DBG_FILE {
+  ucell   address       PACKED; /* address in the code segment where generated code (for this file) starts */
+  const char name[1];           /* ASCII string, zero-terminated */
+} PACKED AMX_DBG_FILE;
+
+typedef struct tagAMX_DBG_LINE {
+  ucell   address       PACKED; /* address in the code segment where generated code (for this line) starts */
+  int32_t line          PACKED; /* line number */
+} PACKED AMX_DBG_LINE;
+
+typedef struct tagAMX_DBG_SYMBOL {
+  ucell   address       PACKED; /* address in the data segment or relative to the frame */
+  int16_t tag           PACKED; /* tag for the symbol */
+  ucell   codestart     PACKED; /* address in the code segment from which this symbol is valid (in scope) */
+  ucell   codeend       PACKED; /* address in the code segment until which this symbol is valid (in scope) */
+  char    ident;                /* kind of symbol (function/variable) */
+  char    vclass;               /* class of symbol (global/local) */
+  int16_t dim           PACKED; /* number of dimensions */
+  const char name[1];           /* ASCII string, zero-terminated */
+} PACKED AMX_DBG_SYMBOL;
+
+typedef struct tagAMX_DBG_SYMDIM {
+  int16_t tag           PACKED; /* tag for the array dimension */
+  ucell   size          PACKED; /* size of the array dimension */
+} PACKED AMX_DBG_SYMDIM;
+
+typedef struct tagAMX_DBG_TAG {
+  int16_t tag           PACKED; /* tag id */
+  const char name[1];           /* ASCII string, zero-terminated */
+} PACKED AMX_DBG_TAG;
+
+typedef struct tagAMX_DBG_MACHINE {
+  int16_t automaton     PACKED; /* automaton id */
+  ucell address         PACKED; /* address of state variable */
+  const char name[1];           /* ASCII string, zero-terminated */
+} PACKED AMX_DBG_MACHINE;
+
+typedef struct tagAMX_DBG_STATE {
+  int16_t state         PACKED; /* state id */
+  int16_t automaton     PACKED; /* automaton id */
+  const char name[1];           /* ASCII string, zero-terminated */
+} PACKED AMX_DBG_STATE;
+
+typedef struct tagAMX_DBG {
+  AMX_DBG_HDR     _FAR *hdr         PACKED; /* points to the AMX_DBG header */
+  AMX_DBG_FILE    _FAR **filetbl    PACKED;
+  AMX_DBG_LINE    _FAR *linetbl     PACKED;
+  AMX_DBG_SYMBOL  _FAR **symboltbl  PACKED;
+  AMX_DBG_TAG     _FAR **tagtbl     PACKED;
+  AMX_DBG_MACHINE _FAR **automatontbl PACKED;
+  AMX_DBG_STATE   _FAR **statetbl   PACKED;
+} PACKED AMX_DBG;
+
+#if !defined iVARIABLE
+  #define iVARIABLE  1  /* cell that has an address and that can be fetched directly (lvalue) */
+  #define iREFERENCE 2  /* iVARIABLE, but must be dereferenced */
+  #define iARRAY     3
+  #define iREFARRAY  4  /* an array passed by reference (i.e. a pointer) */
+  #define iFUNCTN    9
+#endif
+
+
+int AMXAPI dbg_FreeInfo(AMX_DBG *amxdbg);
+int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, void *dbg_addr);
+
+int AMXAPI dbg_LookupFile(AMX_DBG *amxdbg, ucell address, const char **filename);
+int AMXAPI dbg_LookupFunction(AMX_DBG *amxdbg, ucell address, const char **funcname);
+int AMXAPI dbg_LookupLine(AMX_DBG *amxdbg, ucell address, long *line);
+
+int AMXAPI dbg_GetFunctionAddress(AMX_DBG *amxdbg, const char *funcname, const char *filename, ucell *address);
+int AMXAPI dbg_GetLineAddress(AMX_DBG *amxdbg, long line, const char *filename, ucell *address);
+int AMXAPI dbg_GetAutomatonName(AMX_DBG *amxdbg, int automaton, const char **name);
+int AMXAPI dbg_GetStateName(AMX_DBG *amxdbg, int state, const char **name);
+int AMXAPI dbg_GetTagName(AMX_DBG *amxdbg, int tag, const char **name);
+int AMXAPI dbg_GetVariable(AMX_DBG *amxdbg, const char *symname, ucell scopeaddr, const AMX_DBG_SYMBOL **sym);
+int AMXAPI dbg_GetArrayDim(AMX_DBG *amxdbg, const AMX_DBG_SYMBOL *sym, const AMX_DBG_SYMDIM **symdim);
+
+
+#if !defined AMX_NO_ALIGN
+  #if defined LINUX || defined __FreeBSD__ || defined __APPLE__
+    #pragma pack()    /* reset default packing */
+  #elif defined MACOS && defined __MWERKS__
+    #pragma options align=reset
+  #else
+    #pragma pack(pop) /* reset previous packing */
+  #endif
+#endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* AMXDBG_H_INCLUDED */

amxmodx/amxdefn.asm

@@ -0,0 +1,86 @@
+; Definition of the AMX structure for assembler syntax (NASM)
+
+	struc amx_s
+_base:       resd 1
+_dataseg:    resd 1
+_callback:   resd 1
+_debug:      resd 1
+_cip:        resd 1
+_frm:        resd 1
+_hea:        resd 1
+_hlw:        resd 1
+_stk:        resd 1
+_stp:        resd 1
+_flags:      resd 1
+_usertags:   resd 4	; 4 = AMX_USERNUM (#define'd in amx.h)
+_userdata:   resd 4	; 4 = AMX_USERNUM (#define'd in amx.h)
+_error:      resd 1
+_paramcount: resd 1
+_pri:        resd 1
+_alt:        resd 1
+_reset_stk:  resd 1
+_reset_hea:  resd 1
+_syscall_d:  resd 1
+%ifdef JIT
+        ; the two fields below are for the JIT; they do not exist in
+        ; the non-JIT version of the abstract machine
+_reloc_size: resd 1          ; memory block for relocations
+_code_size:  resd 1          ; memory size of the native code
+%endif
+	endstruc
+
+	struc amxhead_s
+_size:       resd 1  ; size of the "file"
+_magic:      resw 1  ; signature
+_file_version: resb 1; file format version
+_amx_version: resb 1 ; required version of the AMX
+_h_flags:    resw 1
+_defsize:    resw 1  ; size of one public/native function entry
+_cod:        resd 1  ; initial value of COD - code block
+_dat:        resd 1  ; initial value of DAT - data block
+_h_hea:      resd 1  ; initial value of HEA - start of the heap
+_h_stp:      resd 1  ; initial value of STP - stack top
+_h_cip:      resd 1  ; initial value of CIP - the instruction pointer
+_publics:    resd 1  ; offset to the "public functions" table
+_natives:    resd 1  ; offset to the "native functions" table
+_libraries:  resd 1  ; offset to the "library" table
+_pubvars:    resd 1  ; offset to the "public variables" table
+_tags:       resd 1  ; offset to the "public tagnames" table
+_nametable:  resd 1  ; offset to the name table, file version 7 only
+	endstruc
+
+
+AMX_ERR_NONE        EQU 0
+AMX_ERR_EXIT        EQU 1
+AMX_ERR_ASSERT      EQU 2
+AMX_ERR_STACKERR    EQU 3
+AMX_ERR_BOUNDS      EQU 4
+AMX_ERR_MEMACCESS   EQU 5
+AMX_ERR_INVINSTR    EQU 6
+AMX_ERR_STACKLOW    EQU 7
+AMX_ERR_HEAPLOW     EQU 8
+AMX_ERR_CALLBACK    EQU 9
+AMX_ERR_NATIVE      EQU 10
+AMX_ERR_DIVIDE      EQU 11      ; for catching divide errors
+AMX_ERR_SLEEP       EQU 12
+
+AMX_ERR_MEMORY      EQU 16
+AMX_ERR_FORMAT      EQU 17
+AMX_ERR_VERSION     EQU 18
+AMX_ERR_NOTFOUND    EQU 19
+AMX_ERR_INDEX       EQU 20
+AMX_ERR_DEBUG       EQU 21
+AMX_ERR_INIT        EQU 22
+AMX_ERR_USERDATA    EQU 23
+AMX_ERR_INIT_JIT    EQU 24
+AMX_ERR_PARAMS      EQU 25
+AMX_ERR_DOMAIN      EQU 26
+AMX_ERR_GENERAL     EQU 27
+
+AMX_FLAG_DEBUG      EQU 0002h   ; symbolic info. available
+AMX_FLAG_COMPACT    EQU 0004h
+AMX_FLAG_BYTEOPC    EQU 0008h
+AMX_FLAG_NOCHECKS   EQU 0010h
+AMX_FLAG_BROWSE     EQU 4000h
+AMX_FLAG_RELOC      EQU 8000h   ; jump/call addresses relocated
+

amxmodx/amxexecn.asm

@@ -1,4 +1,4 @@
-;       AMXEXECN.ASM    Abstract Machine for the "Small" language
+;       AMXEXECN.ASM    Abstract Machine for the "Pawn" language
 ;
 
 ;Some notes:
@@ -25,7 +25,7 @@
 ;
 ;Copyright and license of use, please read
 ;-----------------------------------------
-;The assembler implementation of the abstract machine for the Small language,
+;The assembler implementation of the abstract machine for the Pawn language,
 ;specifically the file AMXEXEC.ASM, is copyright (c) 1998-2000 by Marc Peter.
 ;
 ;Permission is hereby granted, without written agreement and without paid
@@ -56,6 +56,13 @@
 ;
 ;History (list of changes)
 ;-------------------------
+; 24 february 2013 by Scott Ehlert
+;       Aligned stack to 16-byte boundary for native calls in case they make library
+;       calls on Mac OS X or use SSE instructions.
+; 10 february 2006 by David Anderson
+;       Addition of float opcodes
+; 17 february 2005  by Thiadmer Riemersms
+;       Addition of the BREAK opcode, removal of the older debugging opcode table.
 ;  6 march 2004  by Thiadmer Riemersma
 ;       Corrected a bug in OP_FILL, where a cell preceding the array would
 ;       be overwritten (zero'ed out). This bug was brought to my attention
@@ -95,92 +102,7 @@
   %endif
 %endmacro
 
-
-; I could not get NASM's structure definition to work (it appears to confuse
-; ENDSTRUC with "end segment"). So the definition below uses constants for
-; the field offsets.
-;amx_s   STRUC
-    _base       EQU 00h ;DD ?
-    _dataseg    EQU 04h ;DD ?
-    _callback   EQU 08h ;DD ?
-    _debug      EQU 0ch ;DD ?
-    _cip        EQU 10h ;DD ?
-    _frm        EQU 14h ;DD ?
-    _hea        EQU 18h ;DD ?
-    _hlw        EQU 1ch ;DD ?
-    _stk        EQU 20h ;DD ?
-    _stp        EQU 24h ;DD ?
-    _flags      EQU 28h ;DD ?
-    _curline    EQU 2ch ;DD ?
-    _curfile    EQU 30h ;DD ?
-    _dbgcode    EQU 34h ;DD ?
-    _dbgaddr    EQU 38h ;DD ?
-    _dbgparam   EQU 3ch ;DD ?
-    _dbgname    EQU 40h ;DD ?
-    _usertags1  EQU 44h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _usertags2  EQU 44h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _usertags3  EQU 44h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _usertags4  EQU 44h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _userdata1  EQU 54h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _userdata2  EQU 54h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _userdata3  EQU 54h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _userdata4  EQU 54h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _error      EQU 64h ;DD ?
-    _pri        EQU 68h ;DD ?
-    _alt        EQU 6ch ;DD ?
-    _reset_stk  EQU 70h ;DD ?
-    _reset_hea  EQU 74h ;DD ?
-    _syscall_d  EQU 78h ;DD ?
-    ; the two fields below are for the JIT; they do not exist in
-    ; the non-JIT version of the abstract machine
-;   _reloc_size EQU 7ch ;DD ?            ; memory block for relocations
-;   _code_size  EQU 80h ;DD ?            ; memory size of the native code
-;amx_s   ENDS
-
-
-        AMX_ERR_NONE        EQU 0
-        AMX_ERR_EXIT        EQU 1
-        AMX_ERR_ASSERT      EQU 2
-        AMX_ERR_STACKERR    EQU 3
-        AMX_ERR_BOUNDS      EQU 4
-        AMX_ERR_MEMACCESS   EQU 5
-        AMX_ERR_INVINSTR    EQU 6
-        AMX_ERR_STACKLOW    EQU 7
-        AMX_ERR_HEAPLOW     EQU 8
-        AMX_ERR_CALLBACK    EQU 9
-        AMX_ERR_NATIVE      EQU 10
-        AMX_ERR_DIVIDE      EQU 11      ; MP: added for catching divide errors
-        AMX_ERR_SLEEP       EQU 12      ; (TR)
-
-        AMX_ERR_MEMORY      EQU 16
-        AMX_ERR_FORMAT      EQU 17
-        AMX_ERR_VERSION     EQU 18
-        AMX_ERR_NOTFOUND    EQU 19
-        AMX_ERR_INDEX       EQU 20
-        AMX_ERR_DEBUG       EQU 21
-        AMX_ERR_INIT        EQU 22
-        AMX_ERR_USERDATA    EQU 23
-        AMX_ERR_INIT_JIT    EQU 24
-        AMX_ERR_PARAMS      EQU 25
-        AMX_ERR_DOMAIN      EQU 26
-
-        DBG_INIT            EQU 0
-        DBG_FILE            EQU 1
-        DBG_LINE            EQU 2
-        DBG_SYMBOL          EQU 3
-        DBG_CLRSYM          EQU 4
-        DBG_CALL            EQU 5
-        DBG_RETURN          EQU 6
-        DBG_TERMINATE       EQU 7
-        DBG_SRANGE          EQU 8       ; (TR)
-        DBG_SYMTAG          EQU 9       ; (TR)
-
-        AMX_FLAG_CHAR16     EQU 0001h   ; characters are 16-bit
-        AMX_FLAG_DEBUG      EQU 0002h   ; symbolic info. available
-		AMX_FLAG_LINEOPS	EQU	0020h	; line op information
-		AMX_FLAG_TRACED		EQU	0040h	; 
-        AMX_FLAG_BROWSE     EQU 4000h
-        AMX_FLAG_RELOC      EQU 8000h   ; jump/call addresses relocated
+%include "amxdefn.asm"
 
 ;#define PUSH(v)         ( stk-=sizeof(cell), *(cell *)(data+(int)stk)=v )
 %macro  _PUSH   1
@@ -212,6 +134,28 @@
         jg      near err_stack
 %endmacro
 
+;Normal abort, saves pri/alt
+%macro	_ABORT 1
+		mov		ebp,amx
+        mov     [ebp+_pri], dword eax  ; store values in AMX structure (PRI, ALT)
+        mov     [ebp+_alt], dword edx  ; store values in AMX structure (PRI, ALT)
+		mov		[ebp+_error], dword %1
+		jmp		_return
+%endmacro
+
+;Checked abort, saves nothing and uses a conditional
+%macro	_CHKABORT 1
+		mov		ebp,amx
+		mov		[ebp+_error], %1
+		cmp		%1, AMX_ERR_NONE
+		jne		_return
+%endmacro
+
+;Fast abort, only aborts, nothing else
+%macro	_FASTABORT 0
+		jmp		_return
+%endmacro
+
 %macro  _CHKHEAP 0
         mov     ebp,amx
         mov     ebp,[ebp+_hlw]
@@ -248,6 +192,21 @@
     %endif
 %endmacro
 
+%macro  _STK_ALIGN 1            ; align stack to 16-byte boundary and
+                                ; allocate %1 bytes of stack space
+    %if %1 % 16 != 0
+        %error "expected 16-byte aligned value"
+    %endif
+        push     edi
+        mov      edi, esp
+        and      esp, 0xFFFFFFF0
+        sub      esp, %1
+%endmacro
+
+%macro _STK_RESTORE 0           ; restore stack pointer after 16-byte alignment
+        mov      esp, edi
+        pop      edi
+%endmacro
 
 Start_CODE
 
@@ -659,29 +618,6 @@ OP_POP_ALT:
 
 ;good
 OP_STACK:
-        mov     edx,ecx
-        add     ecx,[esi+4]
-        _CHKMARGIN
-        _CHKSTACK
-        mov     ebp,amx
-        test    DWORD [ebp+_flags],AMX_FLAG_DEBUG
-        jz      short op_stk_goon
-        ; update several structure fields and call the debug hook
-        mov     DWORD [ebp+_dbgcode],DBG_CLRSYM
-        mov     [ebp+_stk],ecx
-        push    eax
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax             ; pass parameter via the stack
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-    op_stk_goon:
-        add     esi,8
-        GO_ON
-
-OP_STACK_nodebug:
         mov     edx,ecx
         add     ecx,[esi+4]
         _CHKMARGIN
@@ -711,35 +647,6 @@ OP_PROC:
         GO_ON
 
 OP_RET:
-        _POP    ebx
-        _POP    esi
-        cmp     esi,code        ; verify ESI>=code
-        jb      err_memaccess
-        cmp     esi,codesiz     ; verify ESI<codesiz ("end-of-code" pointer)
-        jae     err_memaccess
-        mov     frm,ebx
-        add     ebx,edi
-        mov     ebp,amx
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_ret_goon
-        ; update several structure fields and call the debug hook
-        mov     DWORD [ebp+_dbgcode],DBG_RETURN
-        mov     [ebp+_dbgparam],eax
-        push    eax
-        mov     [ebp+_stk],ecx  ; store STK
-        mov     eax,hea
-        mov     [ebp+_hea],eax  ; store HEA
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-    op_ret_goon:
-        GO_ON
-
-OP_RET_nodebug:
         _POP    ebx
         _POP    esi
         cmp     esi,code        ; verify ESI>=code
@@ -760,107 +667,17 @@ OP_RETN:
         jae     err_memaccess
         mov     frm,ebx
         add     ebx,edi
-        mov     ebp,amx
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_retn_goon
-        ; update several structure fields and call the debug hook
-        mov     DWORD [ebp+_dbgcode],DBG_RETURN
-        mov     [ebp+_dbgparam],eax
-        push    eax
-        mov     [ebp+_stk],ecx  ; store STK
-        mov     eax,hea
-        mov     [ebp+_hea],eax  ; store HEA
-        mov     eax,ebp         ; parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        ; also send the DBG_CLRSYM code
-        mov     eax,[edi+ecx]
-        lea     ecx,[ecx+eax+4]
-        mov     DWORD [ebp+_dbgcode],DBG_CLRSYM
-        mov     [ebp+_stk],ecx
-        mov     eax,ebp         ; parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-        ; ECX already adjusted
-        GO_ON
-    op_retn_goon:
         mov     ebp,[edi+ecx]
         lea     ecx,[ecx+ebp+4]
         GO_ON
 
-OP_RETN_nodebug:
-        _POP    ebx
-        _POP    esi
-        cmp     esi,code        ; verify ESI>=code
-        jb      err_memaccess
-        cmp     esi,codesiz     ; verify ESI<codesiz ("end-of-code" pointer)
-        jae     err_memaccess
-        mov     frm,ebx
-        mov     ebp,[edi+ecx]
-        add     ebx,edi
-        lea     ecx,[ecx+ebp+4]
-        GO_ON
-
-;good
 OP_CALL:
-        lea     ebp,[esi+8]
-        mov     esi,[esi+4]
-        _PUSH   ebp
-        mov     ebp,amx
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_call_goon
-        ; update several structure fields and call the debug hook
-        push    eax
-        mov     eax,[esp+24]            ; this is "code", but ESP moved
-        mov     [ebp+_dbgaddr],esi
-        sub     [ebp+_dbgaddr],eax      ; dbgaddr = cip - code
-        mov     DWORD [ebp+_dbgcode],DBG_CALL
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-    op_call_goon:
-        GO_ON
-
-OP_CALL_nodebug:
         lea     ebp,[esi+8]
         mov     esi,[esi+4]
         _PUSH   ebp
         GO_ON
 
 OP_CALL_PRI:
-        lea     ebp,[esi+4]
-        mov     esi,eax
-        add     esi,code        ; cip = PRI + code
-        _PUSH   ebp
-        mov     ebp,amx
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_calli_goon
-        ; update several structure fields and call the debug hook
-        mov     [ebp+_dbgaddr],eax      ; dbgaddr = PRI (== cip - code)
-        mov     DWORD [ebp+_dbgcode],DBG_CALL
-        push    eax
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-    op_calli_goon:
-        GO_ON
-
-OP_CALL_PRI_nodebug:
         lea     ebp,[esi+4]
         mov     esi,eax
         add     esi,code        ; cip = PRI + code
@@ -928,7 +745,7 @@ OP_JGRTR:
 
 OP_JGEQ:
         cmp     eax,edx
-        jae     short jump_taken ; unsigned comparison
+        jae     short jump_taken    ; unsigned comparison
         add     esi,8
         GO_ON
 
@@ -941,19 +758,19 @@ OP_JSLESS:
 ;good
 OP_JSLEQ:
         cmp     eax,edx
-        jle     short jump_taken
+        jle     near jump_taken
         add     esi,8
         GO_ON
 
 OP_JSGRTR:
         cmp     eax,edx
-        jg      short jump_taken
+        jg      near jump_taken
         add     esi,8
         GO_ON
 
 OP_JSGEQ:
         cmp     eax,edx
-        jge     near jump_taken ; signed comparison
+        jge     near jump_taken    ; signed comparison
         add     esi,8
         GO_ON
 
@@ -1350,12 +1167,11 @@ OP_CMPS:
         _VERIFYADDRESS  eax             ; PRI
         _VERIFYADDRESS  edx             ; ALT
         mov     ebp,eax
-        add     ebp,[esi+4]
-        dec     ebp
+        add     ebp,[esi+4]             ; size in bytes
+        dec     ebp                     ; EBP = PRI + size - 1
         _VERIFYADDRESS  ebp             ; PRI + size - 1
-        mov     ebp,edx
-        add     ebp,[esi+4]
-        dec     ebp
+        sub     ebp,eax                 ; EBP = size - 1
+        add     ebp,edx                 ; EBP = ALT + size - 1
         _VERIFYADDRESS  ebp             ; ALT + size - 1
 
         push    ecx
@@ -1422,21 +1238,7 @@ OP_HALT:
         mov     eax,esi         ; EAX=CIP
         sub     eax,code
         mov     [ebp+_cip],eax
-        ; optionally call the debug hook
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short halt_goon
-        mov     DWORD [ebp+_dbgcode],DBG_TERMINATE
-        mov     [ebp+_dbgaddr],eax
-        mov     [ebp+_dbgparam],ebx
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-    halt_goon:
-        mov     eax,ebx         ; return the parameter of the HALT opcode
-        jmp     _return
+        _ABORT	ebx
 
 
 OP_BOUNDS:
@@ -1460,6 +1262,7 @@ OP_SYSREQ_PRI:
         mov     alt,edx         ; save ALT
 
         mov     [ebp+_stk],ecx  ; store values in AMX structure (STK, HEA, FRM)
+        ;we don't save regs since they're useless after this
         mov     ecx,hea
         mov     ebx,frm
         mov     [ebp+_hea],ecx
@@ -1480,18 +1283,19 @@ OP_SYSREQ_PRI:
         push    ebp
         push    esi
         push    edi
+        _STK_ALIGN 16           ; align stack to 16-byte boundary and
+                                ; allocate 16 bytes of stack space
         ; push the parameters
-        push    ecx
-        push    ebx
-        push    edx
-        push    eax
+        mov     [esp+12], ecx
+        mov     [esp+08], ebx
+        mov     [esp+04], edx
+        mov     [esp], eax
         call    [ebp+_callback]
-        _DROPARGS 10h           ; remove arguments from stack
+        _STK_RESTORE            ; restore stack pointer
         pop     edi             ; restore saved registers
         pop     esi
         pop     ebp
-        cmp     eax,AMX_ERR_NONE
-        jne     near _return    ; return error code, if any
+        _CHKABORT eax			; if result was invalid, leave
 
         mov     eax,pri         ; get retval into eax (PRI)
         mov     edx,alt         ; restore ALT
@@ -1524,16 +1328,18 @@ OP_SYSREQ_D:                    ; (TR)
         push    ebp
         push    esi
         push    edi
+        _STK_ALIGN 16           ; align stack to 16-byte boundary and
+                                ; allocate 16 bytes of stack space
         ; push the parameters
-        push    edx
-        push    eax
+        mov     [esp+04], edx
+        mov     [esp], eax
         call    ebx             ; direct call
-        _DROPARGS 8             ; remove arguments from stack
+        _STK_RESTORE            ; restore stack pointer
         pop     edi             ; restore saved registers
         pop     esi
         pop     ebp
-        cmp     DWORD [ebp+_error],AMX_ERR_NONE
-        jne     near _return    ; return error code, if any
+        mov		eax,[ebp+_error]
+        _CHKABORT eax
 
         ; function result is in eax (PRI)
         mov     edx,alt         ; restore ALT
@@ -1549,159 +1355,21 @@ OP_FILE:
 
 OP_LINE:
         add     esi,12
-        mov     ebp,amx
-        push    eax
-        push    edx
-        mov     eax,[esi-8]     ; get curline
-        mov     edx,[esi-4]     ; get curfile
-        mov     [ebp+_curline],eax
-        mov     [ebp+_curfile],edx
-        pop     edx
-        pop     eax
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short line_goon
-        ; update several structure fields
-        mov     [ebp+_pri],eax
-        mov     [ebp+_alt],edx  ; EAX and EDX are now free to use
-        mov     eax,frm
-        mov     edx,hea
-        mov     [ebp+_frm],eax  ; store values in AMX structure (STK, FRM & HEA)
-        mov     [ebp+_hea],edx
-        mov     [ebp+_stk],ecx
-        mov     eax,esi
-        sub     eax,code        ; EAX = CIP (relative to start of code segment)
-        mov     [ebp+_cip],eax
-        ; call the debugger hook
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        cmp     eax,AMX_ERR_NONE
-        je      short line_noabort  ; continue running
-        mov     [ebp+_dbgcode],eax  ; save EAX (error code) before restoring all regs
-        _RESTOREREGS            ; abort run, but restore stack first
-        mov     eax,[ebp+_dbgcode]  ; get error code in EAX back again
-        jmp     _return         ; return error code
-    line_noabort:
-        _RESTOREREGS
-        mov     eax,[ebp+_pri]  ; restore PRI and ALT
-        mov     edx,[ebp+_alt]
-    line_goon:
-        GO_ON
-
-
-OP_LINE_nodebug:
-        add     esi,12
-        mov     ebp,amx
-        push    eax
-        push    edx
-        mov     eax,[esi-8]     ; get curline
-        mov     edx,[esi-4]     ; get curfile
-        mov     [ebp+_curline],eax
-        mov     [ebp+_curfile],edx
-        pop     edx
-        pop     eax
         GO_ON
 
 
 OP_SYMBOL:
-        mov     ebp,amx
-        test    DWORD [ebp+_flags],AMX_FLAG_DEBUG
-        jz      short op_symbol_goon
-        push    eax
-        push    edx
-        mov     eax,[esi+8]     ; address
-        mov     edx,[esi+12]    ; flags
-        mov     [ebp+_dbgaddr],eax
-        mov     [ebp+_dbgparam],edx
-        mov     DWORD [ebp+_dbgcode],DBG_SYMBOL
-        mov     eax,esi
-        add     eax,16          ; start of symbol name
-        mov     [ebp+_dbgname],eax
-        mov     edx,[esp+8]     ; this is FRM, but offset by two PUSH'es
-        mov     [ebp+_frm],edx
-        mov     eax,ebp         ; parameter of the debugger hook
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debugger hook
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     edx
-        pop     eax
-    op_symbol_goon:
-        add     esi,[esi+4]
-        add     esi,8           ; skip "fixed" part
-        GO_ON
-
-
-OP_SYMBOL_nodebug:
         add     esi,[esi+4]
         add     esi,8           ; skip "fixed" part
         GO_ON
 
 
 OP_SRANGE:
-        mov     ebp,amx
-        add     esi,12
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_srange_goon
-        push    eax
-        push    edx
-        mov     eax,[esi-8]     ; get dimensions
-        mov     edx,[esi-4]     ; get size
-        mov     [ebp+_dbgaddr],eax
-        mov     [ebp+_dbgparam],edx
-        mov     DWORD [ebp+_dbgcode],DBG_SRANGE
-        mov     edx,frm
-        mov     [ebp+_frm],edx
-        mov     [ebp+_stk],ecx  ; store values in AMX structure (STK & FRM)
-        ; call the debugger hook
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     edx
-        pop     eax
-    op_srange_goon:
-        GO_ON
-
-
-OP_SRANGE_nodebug:
         add     esi,12
         GO_ON
 
 
 OP_SYMTAG:
-        mov     ebp,amx
-        add     esi,8
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_symtag_goon
-        mov     ebp,amx
-        push    eax
-        push    edx
-        mov     eax,[esi-4]     ; get tag
-        mov     edx,frm
-        mov     DWORD [ebp+_dbgcode],DBG_SRANGE
-        mov     [ebp+_dbgparam],eax
-        mov     [ebp+_frm],edx
-        mov     [ebp+_stk],ecx  ; store values in AMX structure (STK & FRM)
-        ; call the debugger hook
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     edx
-        pop     eax
-    op_symtag_goon:
-        GO_ON
-
-
-OP_SYMTAG_nodebug:              ; (TR)
         add     esi,8
         GO_ON
 
@@ -1759,47 +1427,179 @@ OP_PUSHADDR:
 
 
 OP_NOP:
+        add     esi,4
+        GO_ON
+        
+OP_FLOAT_MUL:
+		add   esi,4
+		fld   dword [edi+ecx+4]
+		fmul	dword [edi+ecx+8]
+		sub   esp,4
+		fstp	dword [esp]
+		pop   eax
+		GO_ON
+		
+OP_FLOAT_DIV:
+		add   esi,4
+		fld   dword [edi+ecx+4]
+		fdiv	dword [edi+ecx+8]
+		sub   esp,4
+		fstp	dword [esp]
+		pop   eax
+		GO_ON
+		
+OP_FLOAT_ADD:
+		add   esi,4
+		fld   dword [edi+ecx+4]
+		fadd	dword [edi+ecx+8]
+		sub   esp,4
+		fstp	dword [esp]
+		pop   eax
+		GO_ON
+		
+OP_FLOAT_SUB:
+		add   esi,4
+		fld   dword [edi+ecx+4]
+		fsub	dword [edi+ecx+8]
+		sub   esp, 4
+		fstp	dword [esp]
+		pop   eax
+		GO_ON
+		
+OP_FLOAT_TO:
+		add     esi,4
+		fild    dword [edi+ecx+4]
+		sub     esp,4
+		fstp    dword [esp]
+		pop     eax
+		GO_ON
+		
+OP_FLOAT_ROUND:
+		add	    esi,4
+		;get the float control word
+		push    0
+		mov     ebp,esp
+		fstcw   [ebp]
+		mov     eax,[ebp]
+		push    eax
+		;clear the top bits
+		xor     ah,ah
+		;get the control method
+		push    edx
+		mov     edx,[edi+ecx+8]
+		and     edx,3	;sanity check
+		shl     edx,2	;shift it to right position
+		;set the bits
+		or      ah,dl	;set bits 15,14 of FCW to rounding method
+		or      ah,3	;set precision to 64bit
+
+		;calculate
+		sub     esp,4
+		fld     dword [edi+ecx+4]
+		test    edx,edx
+		jnz     .skip_correct
+		;nearest mode
+		;correct so as to AVOID bankers rounding
+		or      ah, 4   ;set rounding mode to floor
+		fadd    dword [g_round_nearest]
+
+	.skip_correct:
+		mov     [ebp], eax
+		fldcw   [ebp]
+		frndint
+		fistp   dword [esp]
+		pop     eax
+	.done:
+		pop     edx
+		;restore bits
+		pop     ebp
+		mov     [esp], ebp
+		fldcw   [esp]
+		pop      ebp
+		GO_ON
+		
+OP_FLOAT_CMP:
+		add     esi, 4
+		fld     dword [edi+ecx+8]
+		fld     dword [edi+ecx+4]
+		fucompp
+		fnstsw  ax
+		fwait
+		sahf
+		cmovz   eax, [g_flags+4]
+		cmova   eax, [g_flags+8]
+		cmovb   eax, [g_flags+0]
+		GO_ON
+		
+OP_BREAK:
+        mov     ebp,amx         ; get amx into ebp
+        add     esi,4
+        cmp     DWORD [ebp+_debug], 0
+        jnz     break_calldebug
+        GO_ON                   ; debug hook not active, ignore
+
+    break_calldebug:
+        ; store the status in the AMX (FRM, STK, HEA, CIP, and PRI + ALT)
+        mov     [ebp+_pri],eax
+        mov     [ebp+_alt],edx  ; EAX and EDX are now free to use
+        mov     eax,frm
+        mov     edx,hea
+        mov     [ebp+_frm],eax  ; store values in AMX structure (STK, FRM & HEA)
+        mov     [ebp+_hea],edx
+        mov     [ebp+_stk],ecx
+        mov     eax,esi
+        sub     eax,code        ; EAX = CIP (relative to start of code segment)
+        mov     [ebp+_cip],eax
+        ; call the debug hook
+        mov     eax,ebp         ; 1st parm: amx
+        _SAVEREGS
+        _STK_ALIGN 16           ; align stack to 16-byte boundary and
+                                ; allocate 16 bytes of stack space
+        mov     [esp], eax
+        call    [ebp+_debug]    ; call debug function
+        _STK_RESTORE            ; restore stack pointer
+        cmp     eax,AMX_ERR_NONE
+        je      short break_noabort; continue running
+        mov     [ebp+_error],eax   ; save EAX (error code) before restoring all regs
+        _RESTOREREGS               ; abort run, but restore stack first
+        mov     eax,[ebp+_error]   ; get error code in EAX back again
+        _FASTABORT
+    break_noabort:
+        _RESTOREREGS
+        mov     eax,[ebp+_pri]  ; restore PRI and ALT
+        mov     edx,[ebp+_alt]
         GO_ON
 
 
 OP_INVALID:
-        mov     eax,AMX_ERR_INVINSTR
-        jmp     _return
+        _ABORT	AMX_ERR_INVINSTR
 
 err_call:
-        mov     eax,AMX_ERR_CALLBACK
-        jmp     _return
+        _ABORT	AMX_ERR_CALLBACK
 
 err_stack:
-        mov     eax,AMX_ERR_STACKERR
-        jmp     _return
+        _ABORT	AMX_ERR_STACKERR
 
 err_stacklow:
-        mov     eax,AMX_ERR_STACKLOW
-        jmp     _return
+        _ABORT	AMX_ERR_STACKLOW
 
 err_memaccess:
-        mov     eax,AMX_ERR_MEMACCESS
-        jmp     _return
+        _ABORT	AMX_ERR_MEMACCESS
 
 err_bounds:
-        mov     eax,AMX_ERR_BOUNDS
-        jmp     _return
+        _ABORT	AMX_ERR_BOUNDS
 
 err_heaplow:
-        mov     eax,AMX_ERR_HEAPLOW
-        jmp     _return
+        _ABORT	AMX_ERR_HEAPLOW
 
 err_divide:
-        mov     eax,AMX_ERR_DIVIDE
-        jmp     _return
-
+        _ABORT	AMX_ERR_DIVIDE
 
 _return:
-        ; save a few paraneters, mostly for the "sleep"function
+        ; save a few parameters, mostly for the "sleep"function
         mov     ebp,amx         ; get amx into ebp
-        mov     [ebp+_pri],eax  ; store values in AMX structure (PRI, ALT)
-        mov     [ebp+_alt],edx  ; store values in AMX structure (PRI, ALT)
+        mov		[ebp+_cip],esi	; get corrected cip for amxmodx
+        mov		eax,[ebp+_error]; get error code
 
         pop     esi             ; remove FRM from stack
 
@@ -1827,6 +1627,14 @@ Start_DATA
 
 lodb_and DD     0ffh, 0ffffh, 0, 0ffffffffh
 
+g_round_nearest	DD	0.5
+
+		GLOBAL g_flags
+g_flags:
+		DD		-1
+		DD		0
+		DD		1
+
         GLOBAL  amx_opcodelist
         GLOBAL  _amx_opcodelist
 amx_opcodelist:
@@ -1967,144 +1775,11 @@ _amx_opcodelist DD OP_INVALID
         DD      OP_NOP
         DD      OP_SYSREQ_D
         DD      OP_SYMTAG
-
-        GLOBAL  amx_opcodelist_nodebug
-        GLOBAL  _amx_opcodelist_nodebug
-amx_opcodelist_nodebug:
-_amx_opcodelist_nodebug DD OP_INVALID
-        DD      OP_LOAD_PRI
-        DD      OP_LOAD_ALT
-        DD      OP_LOAD_S_PRI
-        DD      OP_LOAD_S_ALT
-        DD      OP_LREF_PRI
-        DD      OP_LREF_ALT
-        DD      OP_LREF_S_PRI
-        DD      OP_LREF_S_ALT
-        DD      OP_LOAD_I
-        DD      OP_LODB_I
-        DD      OP_CONST_PRI
-        DD      OP_CONST_ALT
-        DD      OP_ADDR_PRI
-        DD      OP_ADDR_ALT
-        DD      OP_STOR_PRI
-        DD      OP_STOR_ALT
-        DD      OP_STOR_S_PRI
-        DD      OP_STOR_S_ALT
-        DD      OP_SREF_PRI
-        DD      OP_SREF_ALT
-        DD      OP_SREF_S_PRI
-        DD      OP_SREF_S_ALT
-        DD      OP_STOR_I
-        DD      OP_STRB_I
-        DD      OP_LIDX
-        DD      OP_LIDX_B
-        DD      OP_IDXADDR
-        DD      OP_IDXADDR_B
-        DD      OP_ALIGN_PRI
-        DD      OP_ALIGN_ALT
-        DD      OP_LCTRL
-        DD      OP_SCTRL
-        DD      OP_MOVE_PRI
-        DD      OP_MOVE_ALT
-        DD      OP_XCHG
-        DD      OP_PUSH_PRI
-        DD      OP_PUSH_ALT
-        DD      OP_PUSH_R_PRI
-        DD      OP_PUSH_C
-        DD      OP_PUSH
-        DD      OP_PUSH_S
-        DD      OP_POP_PRI
-        DD      OP_POP_ALT
-        DD      OP_STACK_nodebug
-        DD      OP_HEAP
-        DD      OP_PROC
-        DD      OP_RET_nodebug
-        DD      OP_RETN_nodebug
-        DD      OP_CALL_nodebug
-        DD      OP_CALL_PRI_nodebug
-        DD      OP_JUMP
-        DD      OP_JREL
-        DD      OP_JZER
-        DD      OP_JNZ
-        DD      OP_JEQ
-        DD      OP_JNEQ
-        DD      OP_JLESS
-        DD      OP_JLEQ
-        DD      OP_JGRTR
-        DD      OP_JGEQ
-        DD      OP_JSLESS
-        DD      OP_JSLEQ
-        DD      OP_JSGRTR
-        DD      OP_JSGEQ
-        DD      OP_SHL
-        DD      OP_SHR
-        DD      OP_SSHR
-        DD      OP_SHL_C_PRI
-        DD      OP_SHL_C_ALT
-        DD      OP_SHR_C_PRI
-        DD      OP_SHR_C_ALT
-        DD      OP_SMUL
-        DD      OP_SDIV
-        DD      OP_SDIV_ALT
-        DD      OP_UMUL
-        DD      OP_UDIV
-        DD      OP_UDIV_ALT
-        DD      OP_ADD
-        DD      OP_SUB
-        DD      OP_SUB_ALT
-        DD      OP_AND
-        DD      OP_OR
-        DD      OP_XOR
-        DD      OP_NOT
-        DD      OP_NEG
-        DD      OP_INVERT
-        DD      OP_ADD_C
-        DD      OP_SMUL_C
-        DD      OP_ZERO_PRI
-        DD      OP_ZERO_ALT
-        DD      OP_ZERO
-        DD      OP_ZERO_S
-        DD      OP_SIGN_PRI
-        DD      OP_SIGN_ALT
-        DD      OP_EQ
-        DD      OP_NEQ
-        DD      OP_LESS
-        DD      OP_LEQ
-        DD      OP_GRTR
-        DD      OP_GEQ
-        DD      OP_SLESS
-        DD      OP_SLEQ
-        DD      OP_SGRTR
-        DD      OP_SGEQ
-        DD      OP_EQ_C_PRI
-        DD      OP_EQ_C_ALT
-        DD      OP_INC_PRI
-        DD      OP_INC_ALT
-        DD      OP_INC
-        DD      OP_INC_S
-        DD      OP_INC_I
-        DD      OP_DEC_PRI
-        DD      OP_DEC_ALT
-        DD      OP_DEC
-        DD      OP_DEC_S
-        DD      OP_DEC_I
-        DD      OP_MOVS
-        DD      OP_CMPS
-        DD      OP_FILL
-        DD      OP_HALT
-        DD      OP_BOUNDS
-        DD      OP_SYSREQ_PRI
-        DD      OP_SYSREQ_C
-        DD      OP_FILE
-        DD      OP_LINE_nodebug
-        DD      OP_SYMBOL_nodebug
-        DD      OP_SRANGE_nodebug
-        DD      OP_JUMP_PRI
-        DD      OP_SWITCH
-        DD      OP_CASETBL
-        DD      OP_SWAP_PRI
-        DD      OP_SWAP_ALT
-        DD      OP_PUSHADDR
-        DD      OP_NOP
-        DD      OP_SYSREQ_D
-        DD      OP_SYMTAG_nodebug
+        DD      OP_BREAK
+        DD      OP_FLOAT_MUL
+        DD      OP_FLOAT_DIV
+        DD      OP_FLOAT_ADD
+        DD      OP_FLOAT_SUB
+        DD      OP_FLOAT_TO
+        DD      OP_FLOAT_ROUND
+        DD      OP_FLOAT_CMP

amxmodx/amxmodx.h

@@ -1,53 +1,42 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef AMXMODX_H
 #define AMXMODX_H
 
-
+#if defined PLATFORM_POSIX
+#include <unistd.h>
+#include <stdlib.h>
+#include "sclinux.h"
+#endif
+#include <ctype.h>				//tolower, etc
 #include "string.h"
 #include <extdll.h>
 #include <meta_api.h>
 
-#ifdef MEMORY_TEST
-#include "mmgr/mmgr.h"
+#ifdef _MSC_VER
+	// MSVC8 - replace POSIX functions with ISO C++ conformant ones as they are deprecated
+	#if _MSC_VER >= 1400
+		#define unlink _unlink
+		#define mkdir _mkdir
+		#define strdup _strdup
+	#endif
 #endif
 
-#include "md5.h"
-#include "CVector.h"
-#include "CList.h"
-#include "CQueue.h"
+#include "hashing.h"
 #include "modules.h"
-#include "CString.h"
 #include "CPlugin.h"
+#include "CLibrarySys.h"
+#include <auto-string.h>
+#include <amtl/am-string.h>
+#include <amtl/am-vector.h>
+#include <amtl/am-inlinelist.h>
 #include "CMisc.h"
 #include "CVault.h"
 #include "CModule.h"
@@ -55,39 +44,62 @@
 #include "CLogEvent.h"
 #include "CForward.h"
 #include "CCmd.h"
-#include "CMenu.h"
 #include "CEvent.h"
 #include "CLang.h"
 #include "fakemeta.h"
 #include "amxxlog.h"
+#include "CvarManager.h"
+#include "CoreConfig.h"
+#include "CFrameAction.h"
+#include <amxmodx_version.h>
+#include <HLTypeConversion.h>
 
 #define AMXXLOG_Log g_log.Log
-#define AMX_VERSION     "0.2"
+#define AMXXLOG_Error g_log.LogError
 
-extern AMX_NATIVE_INFO  core_Natives[];
-extern AMX_NATIVE_INFO  time_Natives[];
-extern AMX_NATIVE_INFO  power_Natives[];
-extern  AMX_NATIVE_INFO amxmod_Natives[];
-extern  AMX_NATIVE_INFO file_Natives[];
-extern  AMX_NATIVE_INFO float_Natives[];
-extern  AMX_NATIVE_INFO string_Natives[];
-extern  AMX_NATIVE_INFO vault_Natives[];
+extern AMX_NATIVE_INFO core_Natives[];
+extern AMX_NATIVE_INFO time_Natives[];
+extern AMX_NATIVE_INFO power_Natives[];
+extern AMX_NATIVE_INFO amxmodx_Natives[];
+extern AMX_NATIVE_INFO file_Natives[];
+extern AMX_NATIVE_INFO float_Natives[];
+extern AMX_NATIVE_INFO string_Natives[];
+extern AMX_NATIVE_INFO vault_Natives[];
+extern AMX_NATIVE_INFO msg_Natives[];
+extern AMX_NATIVE_INFO vector_Natives[];
+extern AMX_NATIVE_INFO g_SortNatives[];
+extern AMX_NATIVE_INFO g_DataStructNatives[];
+extern AMX_NATIVE_INFO g_StackNatives[];
+extern AMX_NATIVE_INFO g_TextParserNatives[];
+extern AMX_NATIVE_INFO g_CvarNatives[];
+extern AMX_NATIVE_INFO g_GameConfigNatives[];
 
-
-#ifndef __linux__
+#if defined PLATFORM_WINDOWS
 #define DLLOAD(path) (DLHANDLE)LoadLibrary(path)
-#define DLPROC(m,func) GetProcAddress(m,func)
+#define DLPROC(m, func) GetProcAddress(m, func)
 #define DLFREE(m) FreeLibrary(m)
 #else
-#define DLLOAD(path) (DLHANDLE)dlopen(path, RTLD_NOW)
-#define DLPROC(m,func) dlsym(m,func)
+#define DLLOAD(path) (DLHANDLE)dlopen(path, RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND)
+#define DLPROC(m, func) dlsym(m, func)
 #define DLFREE(m) dlclose(m)
 #endif
 
-#ifndef __linux__
-typedef HINSTANCE DLHANDLE;
+#if defined __GNUC__
+	#include <stdint.h>
+	typedef intptr_t _INT_PTR;
 #else
-typedef void* DLHANDLE;
+	#if defined AMD64
+		typedef __int64 _INT_PTR;
+	#else
+		typedef __int32 _INT_PTR;
+	#endif
+#endif
+
+#if defined PLATFORM_WINDOWS
+	typedef HINSTANCE DLHANDLE;
+#else
+	typedef void* DLHANDLE;
+	#define INFINITE 0xFFFFFFFF
 #endif
 
 #ifndef GETPLAYERAUTHID
@@ -101,64 +113,92 @@ typedef void* DLHANDLE;
 #define SETCLIENTLISTENING  (*g_engfuncs.pfnVoice_SetClientListening)
 #define SETCLIENTMAXSPEED   (*g_engfuncs.pfnSetClientMaxspeed)
 
+#define MAX_BUFFER_LENGTH 16384
+
 char* UTIL_SplitHudMessage(register const char *src);
 int UTIL_ReadFlags(const char* c);
-void UTIL_ClientPrint( edict_t *pEntity, int msg_dest,  char *msg );
-void UTIL_FakeClientCommand(edict_t *pEdict, const char *cmd, const char *arg1 = NULL, const char *arg2 = NULL);
-void UTIL_GetFlags(char* flags,int flag);
-void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, char *pMessage);
-void UTIL_IntToString(int value, char *output);
-void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name);
-void UTIL_ShowMenu( edict_t* pEntity, int slots, int time, char *menu, int mlen );
 
+void UTIL_ClientPrint(edict_t *pEntity, int msg_dest, char *msg);
+void UTIL_FakeClientCommand(edict_t *pEdict, const char *cmd, const char *arg1 = NULL, const char *arg2 = NULL, bool fwd = false);
+void UTIL_GetFlags(char* flags, int flag);
+void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, const char *pMessage);
+void UTIL_DHudMessage(edict_t *pEntity, const hudtextparms_t &textparms, const char *pMessage, unsigned int length);
+void UTIL_IntToString(int value, char *output);
+void UTIL_ShowMOTD(edict_t *client, char *motd, int mlen, const char *name);
+void UTIL_ShowMenu(edict_t* pEntity, int slots, int time, char *menu, int mlen);
+void UTIL_ClientSayText(edict_t *pEntity, int sender, char *msg);
+void UTIL_TeamInfo(edict_t *pEntity, int playerIndex, const char *pszTeamName);
+
+template <typename D> int UTIL_CheckValidChar(D *c);
+template <typename D, typename S> unsigned int strncopy(D *dest, const S *src, size_t count);
+unsigned int UTIL_GetUTF8CharBytes(const char *stream);
+size_t UTIL_ReplaceAll(char *subject, size_t maxlength, const char *search, const char *replace, bool caseSensitive);
+size_t UTIL_ReplaceAll(char *subject, size_t maxlength, const char *search, size_t searchLen, const char *replace, size_t replaceLen, bool caseSensitive);
+char *UTIL_ReplaceEx(char *subject, size_t maxLen, const char *search, size_t searchLen, const char *replace, size_t replaceLen, bool caseSensitive);
+void UTIL_TrimLeft(char *buffer);
+void UTIL_TrimRight(char *buffer);
+
+char* utf8stristr(const char *string1, const char *string2);
+int utf8strncasecmp(const char *string1, const char *string2, size_t n);
+int utf8strcasecmp(const char *string1, const char *string2);
 
 #define GET_PLAYER_POINTER(e)   (&g_players[ENTINDEX(e)])
-//#define GET_PLAYER_POINTER(e)   (&g_players[(((int)e-g_edict_point)/sizeof(edict_t ))])
+//#define GET_PLAYER_POINTER(e)   (&g_players[(((int)e-g_edict_point)/sizeof(edict_t))])
 #define GET_PLAYER_POINTER_I(i) (&g_players[i])
 
-struct WeaponsVault {
-  String fullName;
-  short int iId;
-  short int ammoSlot;
+struct WeaponsVault
+{
+	ke::AString fullName;
+	short int iId;
+	short int ammoSlot;
 };
 
-struct fakecmd_t {
-  char args[256];
-  const char *argv[3];
-  //char argv[3][128];
-  int argc;
-  bool fake;
+struct fakecmd_t
+{
+	char args[256];
+	const char *argv[3];
+	int argc;
+	bool fake;
+	bool notify; // notify to plugins.
 };
 
 extern CLog g_log;
 extern CPluginMngr g_plugins;
 extern CTaskMngr g_tasksMngr;
+extern CFrameActionMngr g_frameActionMngr;
 extern CPlayer g_players[33];
 extern CPlayer* mPlayer;
 extern CmdMngr g_commands;
-extern CList<CCVar> g_cvars;
-extern CList<ForceObject> g_forcemodels;
-extern CList<ForceObject> g_forcesounds;
-extern CList<ForceObject> g_forcegeneric;
-extern CList<CModule,const char *> g_modules;
-extern CList<CPlayer*> g_auth;
+extern ke::Vector<ke::AutoPtr<ForceObject>> g_forcemodels;
+extern ke::Vector<ke::AutoPtr<ForceObject>> g_forcesounds;
+extern ke::Vector<ke::AutoPtr<ForceObject>> g_forcegeneric;
+extern ke::Vector<ke::AutoPtr<CPlayer *>> g_auth;
+extern ke::InlineList<CModule> g_modules;
+extern ke::InlineList<CScript> g_loadedscripts;
 extern EventsMngr g_events;
 extern Grenades g_grenades;
 extern LogEventsMngr g_logevents;
-extern MenuMngr g_menucmds;
 extern CLangMngr g_langMngr;
-extern String g_log_dir;
-extern String g_mod_name;
+extern ke::AString g_log_dir;
+extern ke::AString g_mod_name;
 extern TeamIds g_teamsIds;
 extern Vault g_vault;
-extern CForwardMngr  g_forwards;
+extern CForwardMngr g_forwards;
 extern WeaponsVault g_weaponsData[MAX_WEAPONS];
 extern XVars g_xvars;
 extern bool g_bmod_cstrike;
 extern bool g_bmod_dod;
+extern bool g_bmod_dmc;
+extern bool g_bmod_ricochet;
+extern bool g_bmod_valve;
+extern bool g_bmod_gearbox;
+extern bool g_official_mod;
 extern bool g_dontprecache;
 extern int g_srvindex;
 extern cvar_t* amxmodx_version;
+extern cvar_t* amxmodx_debug;
+extern cvar_t* amxmodx_language;
+extern cvar_t* amxmodx_perflog;
 extern cvar_t* hostname;
 extern cvar_t* mp_timelimit;
 extern fakecmd_t g_fakecmd;
@@ -166,6 +206,7 @@ extern float g_game_restarting;
 extern float g_game_timeleft;
 extern float g_task_time;
 extern float g_auth_time;
+extern bool g_NewDLL_Available;
 extern hudtextparms_t g_hudset;
 //extern int g_edict_point;
 extern int g_players_num;
@@ -198,6 +239,8 @@ extern int gmsgWeaponList;
 extern int gmsgintermission;
 extern int gmsgResetHUD;
 extern int gmsgRoundTime;
+extern int gmsgSayText;
+extern int gmsgInitHUD;
 
 void Client_AmmoPickup(void*);
 void Client_AmmoX(void*);
@@ -210,18 +253,17 @@ void Client_VGUIMenu(void*);
 void Client_WeaponList(void*);
 void Client_DamageEnd(void*);
 void Client_DeathMsg(void*);
+void Client_InitHUDEnd(void*);
 
 void amx_command();
 void plugin_srvcmd();
 
-const char* stristr(const char* a,const char* b);
+const char* stristr(const char* a, const char* b);
 char *strptime(const char *buf, const char *fmt, struct tm *tm, short addthem);
 
-int loadModules(const char* filename);
+int loadModules(const char* filename, PLUG_LOADTIME now);
 void detachModules();
 void detachReloadModules();
-void attachModules();
-void attachMetaModModules(PLUG_LOADTIME now, const char* filename);
 
 // Count modules
 enum CountModulesMode
@@ -233,42 +275,53 @@ enum CountModulesMode
 
 int countModules(CountModulesMode mode);
 void modules_callPluginsLoaded();
+void modules_callPluginsUnloaded();
+void modules_callPluginsUnloading();
 
-int add_amxnatives(module_info_s* info,AMX_NATIVE_INFO*natives);
-cell* get_amxaddr(AMX *amx,cell amx_addr);
-char* build_pathname(char *fmt, ... );
-char* format_amxstring(AMX *amx, cell *params, int parm,int& len);
-AMX* get_amxscript(int, void**,const char**);
+cell* get_amxaddr(AMX *amx, cell amx_addr);
+char* build_pathname(const char *fmt, ...);
+char* build_pathname_r(char *buffer, size_t maxlen, const char *fmt, ...);
+char* format_amxstring(AMX *amx, cell *params, int parm, int& len);
+AMX* get_amxscript(int, void**, const char**);
 const char* get_amxscriptname(AMX* amx);
-char* get_amxstring(AMX *amx,cell amx_addr,int id,int& len);
+char* get_amxstring(AMX *amx, cell amx_addr, int id, int& len);
+char* get_amxstring_null(AMX *amx, cell amx_addr, int id, int& len);
+cell* get_amxvector_null(AMX *amx, cell amx_addr);
+extern "C" size_t get_amxstring_r(AMX *amx, cell amx_addr, char *destination, int maxlen);
+
 int amxstring_len(cell* cstr);
 int load_amxscript(AMX* amx, void** program, const char* path, char error[64], int debug);
-int set_amxnatives(AMX* amx,char error[64]);
-int set_amxstring(AMX *amx,cell amx_addr,const char *source,int max);
-int unload_amxscript(AMX* amx,void** program);
-void copy_amxmemory(cell* dest,cell* src,int len);
+int load_amxscript_ex(AMX* amx, void** program, const char* path, char *error, size_t maxLength, int debug);
+int set_amxnatives(AMX* amx, char error[64]);
+int set_amxstring(AMX *amx, cell amx_addr, const char *source, int max);
+int set_amxstring_simple(cell *dest, const char *source, int max);
+template <typename T> int set_amxstring_utf8(AMX *amx, cell amx_addr, const T *source, size_t sourcelen, size_t maxlen);
+int set_amxstring_utf8_char(AMX *amx, cell amx_addr, const char *source, size_t sourcelen, size_t maxlen);
+int set_amxstring_utf8_cell(AMX *amx, cell amx_addr, const cell *source, size_t sourcelen, size_t maxlen);
+int unload_amxscript(AMX* amx, void** program);
+
+void copy_amxmemory(cell* dest, cell* src, int len);
 void get_modname(char*);
-void print_srvconsole( char *fmt, ... );
-void report_error( int code, char* fmt, ... );
-void* alloc_amxmemory(void**, int size);
-void free_amxmemory(void **ptr);
+void print_srvconsole(const char *fmt, ...);
+void report_error(int code, const char* fmt, ...);
 // get_localinfo
-const char* get_localinfo( const char* name , const char* def );
-cell AMX_NATIVE_CALL require_module(AMX *amx, cell *params);
-void LogError(AMX *amx, int err, const char *fmt, ...);
+const char* get_localinfo(const char* name, const char* def);
+extern "C" void LogError(AMX *amx, int err, const char *fmt, ...);
 
 enum ModuleCallReason
 {
-	ModuleCall_NotCalled = 0,			// nothing
-	ModuleCall_Query,					// in Query func
-	ModuleCall_Attach,					// in Attach func
-	ModuleCall_Detach,					// in Detach func
+	ModuleCall_NotCalled = 0,					// nothing
+	ModuleCall_Query,							// in Query func
+	ModuleCall_Attach,							// in Attach func
+	ModuleCall_Detach,							// in Detach func
 };
 
 extern ModuleCallReason g_ModuleCallReason;		// modules.cpp
 extern CModule *g_CurrentlyCalledModule;		// modules.cpp
 extern const char *g_LastRequestedFunc;			// modules.cpp
-extern CQueue<String> CurModuleList;
+
+void Module_CacheFunctions();
+void Module_UncacheFunctions();
 
 void *Module_ReqFnptr(const char *funcName);	// modules.cpp
 
@@ -286,7 +339,38 @@ extern int FF_PluginLog;
 extern int FF_PluginEnd;
 extern int FF_InconsistentFile;
 extern int FF_ClientAuthorized;
+extern int FF_ChangeLevel;
+extern int FF_ClientConnectEx;
+
+extern bool g_coloredmenus;
+
+typedef void (*AUTHORIZEFUNC)(int player, const char *authstring);
+
+#define MM_CVAR2_VERS	13
+
+struct func_s
+{
+	void *pfn;
+	const char *desc;
+};
+
+enum AdminProperty
+{
+	Admin_Auth = 0,
+	Admin_Password,
+	Admin_Access,
+	Admin_Flags
+};
+
+enum PrintColor
+{
+	print_team_default = 0,
+	print_team_grey =-1,
+	print_team_red = -2,
+	print_team_blue = -3,
+};
+
+extern enginefuncs_t *g_pEngTable;
+extern HLTypeConversion TypeConversion;
 
-extern CFakeMeta g_FakeMeta;
 #endif // AMXMODX_H
-

amxmodx/amxtime.cpp

@@ -2,8 +2,6 @@
  *
  *  Copyright (c) ITB CompuPhase, 2001-2002
  *  This file may be freely used. No warranties of any kind.
- *
- *  Version: $Id$
  */
 #include <time.h>
 #include <assert.h>
@@ -18,6 +16,8 @@
 #	endif
 #endif
 
+#include <stdlib.h>
+
 // this file does not include amxmodx.h, so we have to include the memory manager here
 #ifdef MEMORY_TEST
 #include "mmgr/mmgr.h"
@@ -52,7 +52,7 @@ static cell AMX_NATIVE_CALL _time(AMX *amx, cell *params)
   /* the time() function returns the number of seconds since January 1 1970
    * in Universal Coordinated Time (the successor to Greenwich Mean Time)
    */
-  return sec1970;
+  return (cell)sec1970;
 }
 
 #if defined __BORLANDC__ || defined __WATCOMC__

amxmodx/amxx_mm.def

@@ -1,11 +0,0 @@
-; /usr/local/cross-tools/bin/i386-mingw32msvc-dlltool --base-file /tmp/cc4kB6s0.base --output-exp amx_mm.exp --dllname amx_mm.dll --output-def amx_mm.def --add-stdcall-alias --exclude-symbol=DllMainCRTStartup@12 --def /tmp/ccyI7I7K.def
-EXPORTS
-	GetEngineFunctions @ 1 ; 
-	GetEngineFunctions_Post @ 2 ; 
-	GetEntityAPI2 @ 3 ; 
-	GetEntityAPI2_Post @ 4 ; 
-	GiveFnptrsToDll = GiveFnptrsToDll@8 @ 5 ; 
-	GiveFnptrsToDll@8 @ 6 ; 
-	Meta_Attach @ 7 ; 
-	Meta_Detach @ 8 ; 
-	Meta_Query @ 9 ; 

amxmodx/amxxfile.cpp

@@ -1,33 +1,11 @@
-/* AMX Mod X 
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
 #include "amxxfile.h"
@@ -36,28 +14,25 @@
 /**********************
  ****** AMXXFILE ******
  **********************/
+
 #if defined __GNUC__
-  #define PACKED        __attribute__((packed))
+	#define PACKED		__attribute__((packed))
 #else
-  #define PACKED
+	#define PACKED
 #endif
 
-#if defined __linux__
-  #pragma pack(1)         /* structures must be packed (byte-aligned) */
+#if defined(__linux__) || defined(__APPLE__)
+	#pragma pack(1)				/* structures must be packed (byte-aligned) */
 #else
-  #pragma pack(1)         /* structures must be packed (byte-aligned) */
-  #if defined __TURBOC__
-    #pragma option -a-    /* "pack" pragma for older Borland compilers */
-  #endif
+	#pragma pack(1)				/* structures must be packed (byte-aligned) */
+	#if defined __TURBOC__
+		#pragma option -a-		/* "pack" pragma for older Borland compilers */
+	#endif
 #endif
 
-typedef char	mint8_t;
-typedef int16_t		mint16_t;
-typedef int32_t		mint32_t;
-
 struct TableEntry
 {
-	mint8_t cellSize PACKED;
+	mint8_t cellSize;
 	mint32_t origSize PACKED;			// contains AMX_HEADER->stp
 	mint32_t offset PACKED;
 };
@@ -76,6 +51,9 @@ struct TableEntry
 
 CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 {
+	m_Bh.plugins = NULL;
+	m_AmxxFile = false;
+	
 	if (!filename)
 	{
 		m_Status = Err_InvalidParam;
@@ -84,8 +62,8 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 
 	m_Status = Err_None;
 	m_CellSize = cellsize;
-
 	m_pFile = fopen(filename, "rb");
+	
 	if (!m_pFile)
 	{
 		m_Status = Err_FileOpen;
@@ -96,42 +74,71 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 	DATAREAD(&magic, sizeof(magic), 1);
 
 	m_OldFile = false;
-	if (magic != 0x414D5842)
+	
+	if (magic == 0x524C4542)
 	{
-		// check for old file
-		AMX_HEADER hdr;
-		rewind(m_pFile);
-		fread(&hdr, sizeof(hdr), 1, m_pFile);
-		amx_Align16(&hdr.magic);
-		if (hdr.magic == AMX_MAGIC)
-		{
-			if (cellsize != 4)
-			{
-				m_Status = Err_SectionNotFound;
-				fclose(m_pFile);
-				m_pFile = NULL;
-				return;
-			}
-
-			m_OldFile = true;
-			return;
-		}
-		else
-		{
-			// no known file format
-			m_Status = Err_FileInvalid;
-			fclose(m_pFile);
-			m_pFile = NULL;
-			return;
-		}
-	} else if ( magic == 0x524C4542 ) {
 		//we have an invalid, old, RLEB file
 		m_Status = Err_OldFile;
 		fclose(m_pFile);
 		m_pFile = NULL;
+		
 		return;
-	} else {
-
+	}
+	else if (magic == MAGIC_HEADER2)
+	{
+		DATAREAD(&m_Bh.version, sizeof(int16_t), 1);
+		
+		if (m_Bh.version > MAGIC_VERSION)
+		{
+			m_Status = Err_OldFile;
+			fclose(m_pFile);
+			m_pFile = NULL;
+			
+			return;
+		}
+		
+		m_AmxxFile = true;
+		DATAREAD(&m_Bh.numPlugins, sizeof(mint8_t), 1);
+		m_Bh.plugins = new PluginEntry[m_Bh.numPlugins];
+		PluginEntry *pe;
+		m_SectionHdrOffset = 0;
+		m_Entry = -1;
+		
+		for (mint8_t i = 0; i < m_Bh.numPlugins; i++)
+		{
+			pe = &(m_Bh.plugins[(unsigned)i]);
+			DATAREAD(&pe->cellsize, sizeof(mint8_t), 1);
+			DATAREAD(&pe->disksize, sizeof(int32_t), 1);
+			DATAREAD(&pe->imagesize, sizeof(int32_t), 1);
+			DATAREAD(&pe->memsize, sizeof(int32_t), 1);
+			DATAREAD(&pe->offs, sizeof(int32_t), 1);
+		}
+		
+		for (mint8_t i = 0; i < m_Bh.numPlugins; i++)
+		{
+			pe = &(m_Bh.plugins[(unsigned)i]);
+			
+			if (pe->cellsize == m_CellSize)
+			{
+				m_Entry = i;
+				break;
+			}
+		}
+		
+		if (m_Entry == -1)
+		{
+			m_Status = Err_SectionNotFound;
+			fclose(m_pFile);
+			m_pFile = NULL;
+			
+			return;
+		}
+		
+		pe = &(m_Bh.plugins[m_Entry]);
+		m_SectionLength = pe->disksize;
+	}
+	else if (magic == MAGIC_HEADER)
+	{
 		// try to find the section
 		mint8_t numOfPlugins;
 		DATAREAD(&numOfPlugins, sizeof(numOfPlugins), 1);
@@ -140,6 +147,7 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 	
 		m_SectionHdrOffset = 0;
 		int i = 0;
+		
 		for (i = 0; i < static_cast<int>(numOfPlugins); ++i)
 		{
 			DATAREAD(&entry, sizeof(entry), 1);
@@ -149,6 +157,7 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 				break;
 			}
 		}
+		
 		if (!m_SectionHdrOffset)
 		{
 			m_Status = Err_SectionNotFound;
@@ -158,19 +167,46 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 		}
 
 		// compute section length
-		if ((i+1) < static_cast<int>(numOfPlugins))
+		if ((i + 1) < static_cast<int>(numOfPlugins))
 		{
 			// there is a next section
 			TableEntry nextEntry;
 			DATAREAD(&nextEntry, sizeof(nextEntry), 1);
 			m_SectionLength = nextEntry.offset - entry.offset;
-		}
-		else
-		{
+		} else {
 			fseek(m_pFile, 0, SEEK_END);
 			m_SectionLength = ftell(m_pFile) - (long)entry.offset;
 		}
-	}
+	} else {
+		// check for old file
+		AMX_HEADER hdr;
+		rewind(m_pFile);
+		fread(&hdr, sizeof(hdr), 1, m_pFile);
+		amx_Align16(&hdr.magic);
+		
+		if (hdr.magic == AMX_MAGIC)
+		{
+			if (cellsize != 4)
+			{
+				m_Status = Err_SectionNotFound;
+				fclose(m_pFile);
+				m_pFile = NULL;
+				
+				return;
+			}
+
+			m_OldFile = true;
+			
+			return;
+		} else {
+			// no known file format
+			m_Status = Err_FileInvalid;
+			fclose(m_pFile);
+			m_pFile = NULL;
+			
+			return;
+		}
+	} 
 }
 
 CAmxxReader::~CAmxxReader()
@@ -180,6 +216,12 @@ CAmxxReader::~CAmxxReader()
 		fclose(m_pFile);
 		m_pFile = NULL;
 	}
+	
+	if (m_Bh.plugins)
+	{
+		delete [] m_Bh.plugins;
+		m_Bh.plugins = NULL;
+	}
 }
 
 CAmxxReader::Error CAmxxReader::GetStatus()
@@ -205,7 +247,6 @@ size_t CAmxxReader::GetBufferSize()
 	if (!m_pFile)
 		return 0;
 
-
 	long save = ftell(m_pFile);
 
 	if (m_OldFile)
@@ -214,20 +255,31 @@ size_t CAmxxReader::GetBufferSize()
 		AMX_HEADER hdr;
 		DATAREAD(&hdr, sizeof(hdr), 1);
 		fseek(m_pFile, save, SEEK_SET);
+		
 		return hdr.stp;
 	}
+	else if (m_AmxxFile)
+	{
+		PluginEntry *pe = &(m_Bh.plugins[m_Entry]);
+		
+		if (pe->imagesize > pe->memsize)
+			return pe->imagesize + 1;
+		
+		return pe->memsize + 1;
+	}
 
 	fseek(m_pFile, m_SectionHdrOffset, SEEK_SET);
 
 	TableEntry entry;
 	DATAREAD(&entry, sizeof(entry), 1);
 	fseek(m_pFile, save, SEEK_SET);
+	
 	return entry.origSize + 1;			// +1 : safe
 }
 
 #undef DATAREAD
 #define DATAREAD(addr, itemsize, itemcount) \
-	if (fread(addr, itemsize, itemcount, m_pFile) != itemcount) \
+	if (fread(addr, itemsize, itemcount, m_pFile) != static_cast<size_t>(itemcount)) \
 	{ \
 		if (feof(m_pFile)) \
 			m_Status = Err_FileInvalid; \
@@ -237,7 +289,18 @@ size_t CAmxxReader::GetBufferSize()
 		m_pFile = NULL; \
 		return m_Status; \
 	}
-
+#define DATAREAD_RELEASE(addr, itemsize, itemcount) \
+	if (fread(addr, itemsize, itemcount, m_pFile) != static_cast<size_t>(itemcount)) \
+	{ \
+		if (feof(m_pFile)) \
+			m_Status = Err_FileInvalid; \
+		else \
+			m_Status = Err_FileRead; \
+		fclose(m_pFile); \
+		m_pFile = NULL; \
+		delete[] tempBuffer;\
+		return m_Status; \
+	}
 CAmxxReader::Error CAmxxReader::GetSection(void *buffer)
 {
 	if (!m_pFile)
@@ -251,31 +314,51 @@ CAmxxReader::Error CAmxxReader::GetSection(void *buffer)
 		rewind(m_pFile);
 		DATAREAD(buffer, 1, filesize);
 		m_Status = Err_None;
+		
 		return m_Status;
 	}
-
-	// new file type: go to the section table entry
-	fseek(m_pFile, m_SectionHdrOffset, SEEK_SET);
-	// go to the offset
-	TableEntry entry;
-	DATAREAD(&entry, sizeof(entry), 1);
-	fseek(m_pFile, entry.offset, SEEK_SET);
-//	AMXXLOG_Log("|||| Offset needed: %d At: %d", entry.offset, ftell(m_pFile));
-	uLongf destLen = GetBufferSize();
-	// read the data to a temporary buffer
-	char *tempBuffer = new char[m_SectionLength + 1];
-	//fread(tempBuffer, sizeof(char), m_SectionLength, m_pFile);
-	DATAREAD((void*)tempBuffer, 1, m_SectionLength);
-	// decompress
-//	AMXXLOG_Log("|||| First Bytes: %d %d %d %d", tempBuffer[0], tempBuffer[1], tempBuffer[2], tempBuffer[3]);
-	int result = uncompress((Bytef *)buffer, &destLen,
-			(Bytef *)tempBuffer, m_SectionLength);
-	delete [] tempBuffer;
-//	AMXXLOG_Log("|||| Result: %d, m_SectionLength=%d, destLen=%d", result, m_SectionLength, destLen);
-	if (result != Z_OK)
+	else if (m_AmxxFile)
 	{
-		m_Status = Err_Decompress;
-		return Err_Decompress;
+		PluginEntry *pe = &(m_Bh.plugins[m_Entry]);
+		char *tempBuffer = new char[m_SectionLength + 1];
+		fseek(m_pFile, pe->offs, SEEK_SET);
+		DATAREAD_RELEASE((void *)tempBuffer, 1, m_SectionLength);
+		uLongf destLen = GetBufferSize();
+		int result = uncompress((Bytef *)buffer, &destLen, (Bytef *)tempBuffer, m_SectionLength);
+		delete [] tempBuffer;
+		
+		if (result != Z_OK)
+		{
+			AMXXLOG_Log("[AMXX] Zlib error encountered: %d(%d)", result, m_SectionLength);
+			m_Status = Err_Decompress;
+			return Err_Decompress;
+		}
+		
+		return Err_None;
+	} else {
+		// new file type: go to the section table entry
+		fseek(m_pFile, m_SectionHdrOffset, SEEK_SET);
+		// go to the offset
+		TableEntry entry;
+		DATAREAD(&entry, sizeof(entry), 1);
+		fseek(m_pFile, entry.offset, SEEK_SET);
+		uLongf destLen = GetBufferSize();
+		// read the data to a temporary buffer
+		char *tempBuffer = new char[m_SectionLength + 1];
+		//fread(tempBuffer, sizeof(char), m_SectionLength, m_pFile);
+		DATAREAD_RELEASE((void*)tempBuffer, 1, m_SectionLength);
+		// decompress
+		int result = uncompress((Bytef *)buffer, &destLen, (Bytef *)tempBuffer, m_SectionLength);
+		delete [] tempBuffer;
+		
+		if (result != Z_OK)
+		{
+			AMXXLOG_Log("[AMXX] Zlib error encountered: %d(%d)", result, m_SectionLength);
+			m_Status = Err_Decompress;
+			
+			return Err_Decompress;
+		}
+		
+		return Err_None;
 	}
-	return Err_None;
 }

amxmodx/amxxfile.h

@@ -1,37 +1,40 @@
-/* AMX Mod X 
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef __AMXXFILE_H__
 #define __AMXXFILE_H__
 
+#define MAGIC_HEADER		0x414D5842
+#define MAGIC_HEADER2		0x414D5858
+#define	MAGIC_VERSION		0x0300
+
+typedef char		mint8_t;
+typedef int16_t		mint16_t;
+typedef int32_t		mint32_t;
+
+struct PluginEntry
+{
+	mint8_t cellsize;	//cell size
+	int32_t imagesize;	//uncompressed image size
+	int32_t disksize;	//compressed image size
+	int32_t memsize;	//memory image size
+	int32_t offs;		//file offset
+};
+
+struct BinHeader
+{
+	int32_t		magic;
+	mint16_t	version;
+	mint8_t		numPlugins;
+	PluginEntry *plugins;
+};
+
 class CAmxxReader
 {
 public:
@@ -53,6 +56,9 @@ private:
 	FILE *m_pFile;
 
 	bool m_OldFile;					// old .amx file
+	bool m_AmxxFile;				// new 'AMXX' header format
+	BinHeader m_Bh;					// binary header
+	int m_Entry;					// entry #
 
 	int m_CellSize;
 	int m_SectionHdrOffset;			// offset to the table in the header that describes the required section
@@ -64,8 +70,7 @@ public:
 	Error GetStatus();						// Get the current status
 	size_t GetBufferSize();					// Get the size for the buffer
 	Error GetSection(void *buffer);			// Copy the currently selected section to the buffer
+	inline bool IsOldFile() const { return m_OldFile; }
 };
 
-
 #endif // __AMXXFILE_H__
-

amxmodx/amxxlog.cpp

@@ -1,32 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 // amxx_logging localinfo:
 //  0 = no logging
@@ -35,19 +14,23 @@
 //  3 = HL Logs
 
 #include <time.h>
-#ifndef __linux__
-#include <io.h>
+#if defined(_WIN32)
+	#include <io.h>
 #endif
 #include "amxmodx.h"
 
-#ifndef __linux__
-#define	vsnprintf	_vsnprintf
+#if defined(_WIN32WIN32)
+	#define	vsnprintf	_vsnprintf
 #endif
 
+#include <amxmodx_version.h>
+
 CLog::CLog()
 {
 	m_LogType = 0;
-	m_LogFile.clear();
+	m_LogFile = nullptr;
+	m_FoundError = false;
+	m_LoggedErrMap = false;
 }
 
 CLog::~CLog()
@@ -58,13 +41,14 @@ CLog::~CLog()
 void CLog::CloseFile()
 {
 	// log "log file closed" to old file, if any
-	if (!m_LogFile.empty())
+	if (m_LogFile.length())
 	{
-		FILE *fp = fopen(m_LogFile.c_str(), "r");
+		FILE *fp = fopen(m_LogFile.chars(), "r");
+
 		if (fp)
 		{
 			fclose(fp);
-			fopen(m_LogFile.c_str(), "a+");
+			fp = fopen(m_LogFile.chars(), "a+");
 
 			// get time
 			time_t td;
@@ -77,76 +61,99 @@ void CLog::CloseFile()
 			fprintf(fp, "L %s: %s\n", date, "Log file closed.");
 			fclose(fp);
 		}
-		m_LogFile.clear();
+
+		m_LogFile = nullptr;
 	}
 }
 
 void CLog::CreateNewFile()
 {
 	CloseFile();
+
 	// build filename
 	time_t td;
 	time(&td);
 	tm *curTime = localtime(&td);
 
+	char file[PLATFORM_MAX_PATH];
+	char name[256];
 	int i = 0;
+
 	while (true)
 	{
-		m_LogFile.assign(build_pathname("%s/L%02d%02d%03d.log", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday, i));
-		FILE *pTmpFile = fopen(m_LogFile.c_str(), "r");		// open for reading to check whether the file exists
+		ke::SafeSprintf(name, sizeof(name), "%s/L%02d%02d%03d.log", g_log_dir.chars(), curTime->tm_mon + 1, curTime->tm_mday, i);
+		build_pathname_r(file, sizeof(file), "%s", name);
+		FILE *pTmpFile = fopen(file, "r");			// open for reading to check whether the file exists
+
 		if (!pTmpFile)
 			break;
+
 		fclose(pTmpFile);
 		++i;
 	}
+	m_LogFile = file;
+
 	// Log logfile start
-	FILE *fp = fopen(m_LogFile.c_str(), "w");
+	FILE *fp = fopen(m_LogFile.chars(), "w");
+
 	if (!fp)
 	{
 		ALERT(at_logged, "[AMXX] Unexpected fatal logging error. AMXX Logging disabled.\n");
 		SET_LOCALINFO("amxx_logging", "0");
+	} else {
+		fprintf(fp, "AMX Mod X log file started (file \"%s\") (version \"%s\")\n", name, AMXX_VERSION);
+		fclose(fp);
 	}
-	fprintf(fp, "AMX Mod X log file started (file \"%s/L%02d%02d%03d.log\") (version \"%s\")\n", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday, i, AMX_VERSION);
-	fclose(fp);
 }
 
-void CLog::UseFile(const String &fileName)
+void CLog::UseFile(const ke::AString &fileName)
 {
-	m_LogFile.assign(build_pathname("%s/%s", g_log_dir.c_str(), fileName.c_str()));
+	static char file[PLATFORM_MAX_PATH];
+	m_LogFile = build_pathname_r(file, sizeof(file), "%s/%s", g_log_dir.chars(), fileName.chars());
+}
+
+void CLog::SetLogType(const char* localInfo)
+{
+	m_LogType = atoi(get_localinfo(localInfo, "1"));
+
+	if (m_LogType < 0 || m_LogType > 3)
+	{
+		SET_LOCALINFO(localInfo, "1");
+		m_LogType = 1;
+
+		print_srvconsole("[AMXX] Invalid amxx_logging value; setting back to 1...");
+	}
 }
 
 void CLog::MapChange()
 {
 	// create dir if not existing
-#ifdef __linux
-	mkdir(build_pathname("%s", g_log_dir.c_str()), 0700);
+	char file[PLATFORM_MAX_PATH];
+#if defined(__linux__) || defined(__APPLE__)
+	mkdir(build_pathname_r(file, sizeof(file), "%s", g_log_dir.chars()), 0700);
 #else
-	mkdir(build_pathname("%s", g_log_dir.c_str()));
+	mkdir(build_pathname_r(file, sizeof(file), "%s", g_log_dir.chars()));
 #endif
 
-	m_LogType = atoi(get_localinfo("amxx_logging", "1"));
-	if (m_LogType < 0 || m_LogType > 3)
-	{
-		SET_LOCALINFO("amxx_logging", "1");
-		m_LogType = 1;
-		print_srvconsole("[AMXX] Invalid amxx_logging value; setting back to 1...");
-	}
+	SetLogType("amxx_logging");
+
+	m_LoggedErrMap = false;
 
 	if (m_LogType == 2)
 	{
 		// create new logfile
 		CreateNewFile();
-	}
-	else if (m_LogType == 1)
-	{
-		Log("-------- Mapchange --------");
-	}
-	else
+	} else if (m_LogType == 1) {
+		Log("-------- Mapchange to %s --------", STRING(gpGlobals->mapname));
+	} else {
 		return;
+	}
 }
 
 void CLog::Log(const char *fmt, ...)
 {
+	static char file[PLATFORM_MAX_PATH];
+
 	if (m_LogType == 1 || m_LogType == 2)
 	{
 		// get time
@@ -158,57 +165,104 @@ void CLog::Log(const char *fmt, ...)
 		strftime(date, 31, "%m/%d/%Y - %H:%M:%S", curTime);
 
 		// msg
-		char msg[3072];
+		static char msg[3072];
 
 		va_list arglst;
 		va_start(arglst, fmt);
 		vsnprintf(msg, 3071, fmt, arglst);
 		va_end(arglst);
 
-		FILE *pF;
+		FILE *pF = NULL;
 		if (m_LogType == 2)
 		{
-			pF = fopen(m_LogFile.c_str(), "a+");
+			pF = fopen(m_LogFile.chars(), "a+");
 			if (!pF)
 			{
 				CreateNewFile();
-				pF = fopen(m_LogFile.c_str(), "a+");
+				pF = fopen(m_LogFile.chars(), "a+");
+
 				if (!pF)
 				{
-					ALERT(at_logged, "[AMXX] Unexpected fatal logging error (couldn't open %s for a+). AMXX Logging disabled for this map.\n", m_LogFile.c_str());
+					ALERT(at_logged, "[AMXX] Unexpected fatal logging error (couldn't open %s for a+). AMXX Logging disabled for this map.\n", m_LogFile.chars());
 					m_LogType = 0;
 					return;
 				}
 			}
+		} else {
+			build_pathname_r(file, sizeof(file), "%s/L%04d%02d%02d.log", g_log_dir.chars(), (curTime->tm_year + 1900), curTime->tm_mon + 1, curTime->tm_mday);
+			pF = fopen(file, "a+");
 		}
-		else
-		{
-			pF = fopen(build_pathname("%s/L%02d%02d.log", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday), "a+");
-		}
+
 		if (pF)
 		{
 			fprintf(pF, "L %s: %s\n", date, msg);
 			fclose(pF);
-		}
-		else
-		{
-			ALERT(at_logged, "[AMXX] Unexpected fatal logging error (couldn't open %s for a+). AMXX Logging disabled for this map.\n", m_LogFile.c_str());
+		} else {
+			ALERT(at_logged, "[AMXX] Unexpected fatal logging error (couldn't open %s for a+). AMXX Logging disabled for this map.\n", file);
 			m_LogType = 0;
 			return;
 		}
 
 		// print on server console
 		print_srvconsole("L %s: %s\n", date, msg);
-	}
-	else if (m_LogType == 3)
-	{
+	} else if (m_LogType == 3) {
 		// build message
-		// :TODO: Overflow possible here
-		char msg[3072];
+		static char msg_[3072];
 		va_list arglst;
 		va_start(arglst, fmt);
-		vsnprintf(msg, 3071, fmt, arglst);
+		vsnprintf(msg_, 3071, fmt, arglst);
 		va_end(arglst);
-		ALERT(at_logged, "%s\n", msg);
+		ALERT(at_logged, "%s\n", msg_);
 	}
 }
+
+void CLog::LogError(const char *fmt, ...)
+{
+	static char file[PLATFORM_MAX_PATH];
+	static char name[256];
+
+	if (m_FoundError)
+	{
+		return;
+	}
+
+	// get time
+	time_t td;
+	time(&td);
+	tm *curTime = localtime(&td);
+
+	char date[32];
+	strftime(date, 31, "%m/%d/%Y - %H:%M:%S", curTime);
+
+	// msg
+	static char msg[3072];
+
+	va_list arglst;
+	va_start(arglst, fmt);
+	vsnprintf(msg, sizeof(msg)-1, fmt, arglst);
+	va_end(arglst);
+
+	FILE *pF = NULL;
+	ke::SafeSprintf(name, sizeof(name), "%s/error_%04d%02d%02d.log", g_log_dir.chars(), curTime->tm_year + 1900, curTime->tm_mon + 1, curTime->tm_mday);
+	build_pathname_r(file, sizeof(file), "%s", name);
+	pF = fopen(file, "a+");
+
+	if (pF)
+	{
+		if (!m_LoggedErrMap)
+		{
+			fprintf(pF, "L %s: Start of error session.\n", date);
+			fprintf(pF, "L %s: Info (map \"%s\") (file \"%s\")\n", date, STRING(gpGlobals->mapname), name);
+			m_LoggedErrMap = true;
+		}
+		fprintf(pF, "L %s: %s\n", date, msg);
+		fclose(pF);
+	} else {
+		ALERT(at_logged, "[AMXX] Unexpected fatal logging error (couldn't open %s for a+). AMXX Error Logging disabled for this map.\n", file);
+		m_FoundError = true;
+		return;
+	}
+
+	// print on server console
+	print_srvconsole("L %s: %s\n", date, msg);
+}

amxmodx/amxxlog.h

@@ -1,32 +1,11 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef __AMXXLOG_H__
 #define __AMXXLOG_H__
@@ -34,19 +13,23 @@
 class CLog
 {
 private:
-	String m_LogFile;
+	ke::AString m_LogFile;
 	int m_LogType;
+	bool m_FoundError;
+	bool m_LoggedErrMap;
 
-	void GetLastFile(int &outMonth, int &outDay, String &outFilename);
-	void UseFile(const String &fileName);
+	void GetLastFile(int &outMonth, int &outDay, ke::AString &outFilename);
+	void UseFile(const ke::AString &fileName);
 public:
 	CLog();
 	~CLog();
+	
 	void CreateNewFile();
 	void CloseFile();
+	void SetLogType(const char* localInfo);
 	void MapChange();
 	void Log(const char *fmt, ...);
+	void LogError(const char *fmt, ...);
 };
 
 #endif // __AMXXLOG_H__
-

amxmodx/binlog.cpp

@@ -0,0 +1,371 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#if defined BINLOG_ENABLED
+
+#include <time.h>
+#include "amxmodx.h"
+#include "binlog.h"
+#include "debugger.h"
+
+BinLog g_BinLog;
+int g_binlog_level = 0;
+int g_binlog_maxsize = 0;
+
+// Helper function to get a filename index
+#define USHR(x) ((unsigned int)(x)>>1)
+int LookupFile(AMX_DBG *amxdbg, ucell address)
+{
+	int high, low, mid;
+
+	high = amxdbg->hdr->files;
+	low = -1;
+
+	while (high - low > 1)
+	{
+		mid = USHR(low + high);
+		if (amxdbg->filetbl[mid]->address <= address)
+		{
+			low = mid;
+		} else {
+			high = mid;
+		}
+	}
+
+	if (low == -1)
+	{
+		return -1;
+	}
+
+	return low;
+}
+
+bool BinLog::Open()
+{
+	const char *data = get_localinfo("amxmodx_datadir", "addons/amxmodx/data");
+	char path[PLATFORM_MAX_PATH];
+	build_pathname_r(path, sizeof(path), "%s/binlogs", data);
+
+	if (!DirExists(path))
+	{
+		mkdir(path
+#if defined(__linux__) || defined(__APPLE__)
+			, 0755
+#endif
+			);
+		if (!DirExists(path))
+			return false;
+	}
+
+	char file[PLATFORM_MAX_PATH];
+	build_pathname_r(file, sizeof(file), "%s/binlogs/lastlog", data);
+
+	unsigned int lastcntr = 0;
+	FILE *lastlog = fopen(file, "rb");
+	if (lastlog)
+	{
+		if (fread(&lastcntr, sizeof(int), 1, lastlog) != 1)
+			lastcntr = 0;
+		fclose(lastlog);
+	}
+	lastlog = fopen(file, "wb");
+	if (lastlog)
+	{
+		lastcntr++;
+		fwrite(&lastcntr, sizeof(int), 1, lastlog);
+		fclose(lastlog);
+	}
+	build_pathname_r(file, sizeof(file), "%s/binlogs/binlog%04d.blg", data, lastcntr);
+	m_logfile = file;
+
+	/**
+	* it's now safe to create the binary log
+	*/
+	FILE *fp = fopen(m_logfile.chars(), "wb");
+	if (!fp)
+		return false;
+
+	int magic = BINLOG_MAGIC;
+	short vers = BINLOG_VERSION;
+	char c = sizeof(time_t);
+	fwrite(&magic, sizeof(int), 1, fp);
+	fwrite(&vers, sizeof(short), 1, fp);
+	fwrite(&c, sizeof(char), 1, fp);
+
+	WritePluginDB(fp);
+	fclose(fp);
+
+	m_state = true;
+
+	WriteOp(BinLog_Start, -1);
+
+	return true;
+}
+
+void BinLog::Close()
+{
+	WriteOp(BinLog_End, -1);
+	m_state = false;
+}
+
+void BinLog::WriteOp(BinLogOp op, int plug, ...)
+{
+	if (!m_state)
+		return;
+
+	FILE *fp = fopen(m_logfile.chars(), "ab");
+	if (!fp)
+		return;
+
+	if (g_binlog_maxsize && op != BinLog_End)
+	{
+		fseek(fp, 0, SEEK_END);
+		if (ftell(fp) > (g_binlog_maxsize * (1024 * 1024)))
+		{
+			fclose(fp);
+			Close();
+			Open();
+			fp = fopen(m_logfile.chars(), "ab");
+			if (!fp)
+				return;
+		}
+	}
+
+	unsigned char c = static_cast<char>(op);
+	time_t t = time(NULL);
+	float gt = gpGlobals->time;
+	fwrite(&c, sizeof(char), 1, fp);
+	fwrite(&t, sizeof(time_t), 1, fp);
+	fwrite(&gt, sizeof(float), 1, fp);
+	fwrite(&plug, sizeof(int), 1, fp);
+
+	va_list ap;
+	va_start(ap, plug);
+
+	AMX *amx = NULL;
+	bool debug = false;
+	AMX_DBG *dbg = NULL;
+	CPluginMngr::CPlugin *pl = NULL;
+
+	if (plug != -1)
+	{
+		pl = g_plugins.findPlugin(plug);
+		if ((debug = pl->isDebug()))
+		{
+			amx = pl->getAMX();
+			dbg = static_cast<Debugger *>(amx->userdata[UD_DEBUGGER])->m_pAmxDbg;
+		}
+	}
+
+	switch (c)
+	{
+	case BinLog_Registered:
+		{
+			const char *title = va_arg(ap, const char *);
+			const char *vers = va_arg(ap, const char *);
+			c = (char)strlen(title);
+			fwrite(&c, sizeof(char), 1, fp);
+			fwrite(title, sizeof(char), c+1, fp);
+			c = (char)strlen(vers);
+			fwrite(&c, sizeof(char), 1 ,fp);
+			fwrite(vers, sizeof(char), c+1, fp);
+			break;
+		}
+	case BinLog_NativeCall:
+		{
+			int file;
+			int native = va_arg(ap, int);
+			int params = va_arg(ap, int);
+			fwrite(&native, sizeof(int), 1, fp);
+			fwrite(&params, sizeof(int), 1, fp);
+			if (debug)
+			{
+				file = LookupFile(dbg, amx->cip);
+				fwrite(&file, sizeof(int), 1, fp);
+			} else {
+				file = 0;
+				fwrite(&file, sizeof(int), 1, fp);
+			}
+			break;
+		}
+	case BinLog_NativeRet:
+		{
+			cell retval = va_arg(ap, cell);
+			fwrite(&retval, sizeof(cell), 1, fp);
+			break;
+		}
+	case BinLog_NativeError:
+		{
+			int err = va_arg(ap, int);
+			const char *msg = va_arg(ap, const char *);
+			short len = (short)strlen(msg);
+			fwrite(&err, sizeof(int), 1, fp);
+			fwrite(&len, sizeof(short), 1, fp);
+			fwrite(msg, sizeof(char), len+1, fp);
+			break;
+		}
+	case BinLog_CallPubFunc:
+		{
+			int file;
+			int num = va_arg(ap, int);
+			fwrite(&num, sizeof(int), 1, fp);
+			if (debug)
+			{
+				file = LookupFile(dbg, amx->cip);
+				fwrite(&file, sizeof(int), 1, fp);
+			} else {
+				file = 0;
+				fwrite(&file, sizeof(int), 1, fp);
+			}
+			break;
+		}
+	case BinLog_SetLine:
+		{
+			int file;
+			int line = va_arg(ap, int);
+			fwrite(&line, sizeof(int), 1, fp);
+			if (debug)
+			{
+				file = LookupFile(dbg, amx->cip);
+				fwrite(&file, sizeof(int), 1, fp);
+			} else {
+				file = 0;
+				fwrite(&file, sizeof(int), 1, fp);
+			}
+			break;
+		}
+	case BinLog_FormatString:
+		{
+			int param = va_arg(ap, int);
+			int maxlen = va_arg(ap, int);
+			const char *str = va_arg(ap, const char *);
+			short len = (short)strlen(str);
+			fwrite(&param, sizeof(int), 1, fp);
+			fwrite(&maxlen, sizeof(int), 1, fp);
+			fwrite(&len, sizeof(short), 1, fp);
+			fwrite(str, sizeof(char), len+1, fp);
+			break;
+		}
+	case BinLog_NativeParams:
+		{
+			cell *params = va_arg(ap, cell *);
+			cell num = params[0] / sizeof(cell);
+			fwrite(&num, sizeof(cell), 1, fp);
+			for (cell i=1; i<=num; i++)
+				fwrite(&(params[i]), sizeof(cell), 1, fp);
+			break;
+		}
+	case BinLog_GetString:
+		{
+			cell addr = va_arg(ap, cell);
+			const char *str = va_arg(ap, const char *);
+			short len = (short)strlen(str);
+			fwrite(&addr, sizeof(cell), 1, fp);
+			fwrite(&len, sizeof(short), 1, fp);
+			fwrite(str, sizeof(char), len+1, fp);
+			break;
+		}
+	case BinLog_SetString:
+		{
+			cell addr = va_arg(ap, cell);
+			int maxlen = va_arg(ap, int);
+			const char *str = va_arg(ap, const char *);
+			short len = (short)strlen(str);
+			fwrite(&addr, sizeof(cell), 1, fp);
+			fwrite(&maxlen, sizeof(int), 1, fp);
+			fwrite(&len, sizeof(short), 1, fp);
+			fwrite(str, sizeof(char), len+1, fp);
+			break;
+		}
+	};
+
+	va_end(ap);
+	fclose(fp);
+}
+
+void BinLog::WritePluginDB(FILE *fp)
+{
+	int num = g_plugins.getPluginsNum();
+	fwrite(&num, sizeof(int), 1, fp);
+
+	CPluginMngr::CPlugin *pl;
+	char c;
+	unsigned char len;
+	for (CPluginMngr::iterator iter = g_plugins.begin(); iter; ++iter)
+	{
+		pl = &(*iter);
+		if (pl->isValid())
+			c = 1;
+		else
+			c = 0;
+		if (c && pl->isDebug())
+			c = 2;
+		fwrite(&c, sizeof(char), 1, fp);
+		if (c)
+		{
+			Debugger *pd = NULL;
+			len = (char)strlen(pl->getName());
+			fwrite(&len, sizeof(char), 1, fp);
+			len++;
+			fwrite(pl->getName(), sizeof(char), len, fp);
+			int natives, publics, files;
+			AMX *amx = pl->getAMX();
+			// Write the number of Filenames
+			if (c == 2)
+			{
+				pd = static_cast<Debugger *>(amx->userdata[UD_DEBUGGER]);
+				files = pd->m_pAmxDbg->hdr->files;
+				fwrite(&files, sizeof(int), 1, fp);
+			}
+			amx_NumNatives(amx, &natives);
+			amx_NumPublics(amx, &publics);
+			fwrite(&natives, sizeof(int), 1, fp);
+			fwrite(&publics, sizeof(int), 1, fp);
+			char name[34];
+			// Write the Filenames to the binfile
+			if (c == 2)
+			{
+				AMX_DBG_FILE **ftable = pd->m_pAmxDbg->filetbl;
+				for (int i=0; i<files; i++)
+				{
+					len = (char)strlen(ftable[i]->name);
+					fwrite(&len, sizeof(char), 1, fp);
+					len++;
+					fwrite(ftable[i]->name, sizeof(char), len, fp);
+				}
+			}
+			for (int i=0; i<natives; i++)
+			{
+				amx_GetNative(amx, i, name);
+				len = (char)strlen(name);
+				fwrite(&len, sizeof(char), 1, fp);
+				len++;
+				fwrite(name, sizeof(char), len, fp);
+			}
+			for (int i=0; i<publics; i++)
+			{
+				amx_GetPublic(amx, i, name);
+				len = (char)strlen(name);
+				fwrite(&len, sizeof(char), 1, fp);
+				len++;
+				fwrite(name, sizeof(char), len, fp);
+			}
+		} else {
+			char empty[] = " ";
+			len = 1;
+			fwrite(&len, sizeof(char), 1, fp);
+			fwrite(empty, sizeof(char), len, fp);
+			int no = 0;
+			fwrite(&no, sizeof(int), 1, fp);
+			fwrite(&no, sizeof(int), 1, fp);
+		}
+	}
+}
+
+#endif //BINLOG_ENABLED

amxmodx/binlog.h

@@ -0,0 +1,93 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef _INCLUDE_BINLOG_H
+#define _INCLUDE_BINLOG_H
+
+#if defined BINLOG_ENABLED
+
+#include <amtl/am-string.h>
+
+#define BINLOG_MAGIC	0x414D424C
+#define BINLOG_VERSION	0x0300
+
+/**
+ * Format of binlog:
+ * uint32		magic
+ * uint16		version
+ * uint8		sizeof(time_t)
+ * uint32		num plugins
+ * [
+ *  uint8		status codes
+ *  str[int8]	filename
+ *  if(status==2)
+ *    uint32	num filenames
+ *  uint32		num natives
+ *  uint32		num publics
+ *  if (status==2)
+ *    [
+ *     str[uint8] file name
+ *    ]
+ *  [
+ *   str[uint8] native name
+ *  ]
+ *  [
+ *   str[uint8] public name
+ *  ]
+ * ]
+ * [
+ *  uint8		operation code
+ *  time_t		realtime
+ *  float		gametime
+ *  int32		plugin id
+ *  <extra info>
+ * ]
+ * If filename id is 0 skip as plugin was not in debug mode, if -1 there was an error.
+ */
+
+enum BinLogOp
+{
+	BinLog_Start=1,
+	BinLog_End,
+	BinLog_NativeCall,	//<int32 native id> <int32_t num_params> <int32_t filename id>
+	BinLog_NativeError, //<int32 errornum> <str[int16] string>
+	BinLog_NativeRet,	//<cell value>
+	BinLog_CallPubFunc,	//<int32 public id> <int32_t filename id>
+	BinLog_SetLine,		//<int32 line no#> <int32_t filename id>
+	BinLog_Registered,	//<string title> <string version>
+	BinLog_FormatString, //<int32 param#> <int32 maxlen> <str[int16] string>
+	BinLog_NativeParams, //<int32 num> <cell ...>
+	BinLog_GetString,	//<cell addr> <string[int16]>
+	BinLog_SetString,	//<cell addr> <int maxlen> <string[int16]>
+};
+
+class BinLog
+{
+public:
+	BinLog() : m_state(false)
+	{
+	};
+public:
+	bool Open();
+	void Close();
+	void WriteOp(BinLogOp op, int plug, ...);
+private:
+	void WritePluginDB(FILE *fp);
+private:
+	ke::AString m_logfile;
+	bool m_state;
+};
+
+extern BinLog g_BinLog;
+extern int g_binlog_level;
+extern int g_binlog_maxsize;
+
+#endif //BINLOG_ENABLED
+
+#endif //_INCLUDE_BINLOG_H

amxmodx/cvars.cpp

@@ -0,0 +1,729 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "CvarManager.h"
+#include "amxmodx.h"
+#include "nongpl_matches.h"
+
+char CVarTempBuffer[64];
+const char *invis_cvar_list[5] ={ "amxmodx_version", "amxmodx_modules", "amx_debug", "amx_mldebug", "amx_client_languages" };
+
+// create_cvar(const name[], const default_value[], flags = 0, const description[] = "", bool:has_min = false, Float:min_val = 0.0, bool:has_max = false, Float:max_val = 0.0)
+static cell AMX_NATIVE_CALL create_cvar(AMX *amx, cell *params)
+{
+	int length;
+	const char* name     = get_amxstring(amx, params[1], 0, length);
+	const char* value    = get_amxstring(amx, params[2], 1, length);
+	const char* helpText = get_amxstring(amx, params[4], 2, length);
+
+	int flags = params[3];
+
+	CPluginMngr::CPlugin *plugin = g_plugins.findPluginFast(amx);
+
+	if (CheckBadConList(name, 0))
+	{
+		plugin->AddToFailCounter(1);
+	}
+
+	CvarInfo* info = g_CvarManager.CreateCvar(name, value, plugin->getName(), plugin->getId(), flags, helpText);
+
+	if (info)
+	{
+		bool hasMin  = params[5] != 0;
+		bool hasMax  = params[7] != 0;
+		float minVal = amx_ctof(params[6]);
+		float maxVal = amx_ctof(params[8]);
+		
+		if (hasMin && hasMax)
+		{
+			if (minVal > maxVal)
+			{
+				LogError(amx, AMX_ERR_NATIVE, "The minimum value can not be above the maximum value");
+				return 0;
+			}
+			else if (maxVal < minVal)
+			{
+				LogError(amx, AMX_ERR_NATIVE, "The maximum value can not be below the minimum value");
+				return 0;
+			}
+		}
+
+		g_CvarManager.SetCvarMin(info, hasMin, minVal, plugin->getId());
+		g_CvarManager.SetCvarMax(info, hasMax, maxVal, plugin->getId());
+
+		return reinterpret_cast<cell>(info->var);
+	}
+
+	return 0;
+}
+
+// register_cvar(const name[], const string[], flags=0, Float:fvalue=0.0)
+static cell AMX_NATIVE_CALL register_cvar(AMX *amx, cell *params)
+{
+	int length;
+	const char* name  = get_amxstring(amx, params[1], 0, length);
+	const char* value = get_amxstring(amx, params[2], 1, length);
+
+	int   flags = params[3];
+	float fvalue = amx_ctof(params[4]);
+
+	CPluginMngr::CPlugin *plugin = g_plugins.findPluginFast(amx);
+
+	if (CheckBadConList(name, 0))
+	{
+		plugin->AddToFailCounter(1);
+	}
+
+	CvarInfo* info = g_CvarManager.CreateCvar(name, value, plugin->getName(), plugin->getId(), flags);
+
+	if (info)
+	{
+		return reinterpret_cast<cell>(info->var);
+	}
+
+	return 0;
+}
+
+// cvar_exists(const cvar[])
+static cell AMX_NATIVE_CALL cvar_exists(AMX *amx, cell *params)
+{
+	int ilen;
+	return (g_CvarManager.FindCvar(get_amxstring(amx, params[1], 0, ilen)) ? 1 : 0);
+}
+
+// get_cvar_pointer(const cvar[])
+static cell AMX_NATIVE_CALL get_cvar_pointer(AMX *amx, cell *params)
+{
+	int len;
+	const char *name = get_amxstring(amx, params[1], 0, len);
+
+	CvarInfo* info = g_CvarManager.FindCvar(name);
+
+	return reinterpret_cast<cell>(info ? info->var : 0);
+}
+
+// hook_cvar_change(cvarHandle, const callback[])
+static cell AMX_NATIVE_CALL hook_cvar_change(AMX *amx, cell *params)
+{
+	cvar_t* var = reinterpret_cast<cvar_t*>(params[1]);
+
+	if (!var)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid cvar handle: %p", var);
+		return 0;
+	}
+
+	const char* callback;
+	AutoForward* forward = g_CvarManager.HookCvarChange(var, amx, params[2], &callback);
+
+	if (!forward)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Function \"%s\" is not present", callback);
+		return 0;
+	}
+
+	return reinterpret_cast<cell>(forward);
+}
+
+// enable_cvar_hook(cvarhook:handle);
+static cell AMX_NATIVE_CALL enable_cvar_hook(AMX *amx, cell *params)
+{
+	AutoForward* forward = reinterpret_cast<AutoForward*>(params[1]);
+
+	if (!forward)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid cvar hook handle: %p", forward);
+		return 0;
+	}
+
+	forward->state = AutoForward::FSTATE_OK;
+
+	return 1;
+}
+
+// disable_cvar_hook(cvarhook:handle);
+static cell AMX_NATIVE_CALL disable_cvar_hook(AMX *amx, cell *params)
+{
+	AutoForward* forward = reinterpret_cast<AutoForward*>(params[1]);
+
+	if (!forward)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid cvar hook handle: %p", forward);
+		return 0;
+	}
+
+	forward->state =  AutoForward::FSTATE_STOP;
+
+	return 1;
+}
+
+// get_cvar_flags(const cvar[])
+static cell AMX_NATIVE_CALL get_cvar_flags(AMX *amx, cell *params)
+{
+	int ilen;
+	char* sCvar = get_amxstring(amx, params[1], 0, ilen);
+
+	CvarInfo* info = g_CvarManager.FindCvar(sCvar);
+
+	return info ? info->var->flags : 0;
+}
+
+// get_cvar_float(const cvarname[])
+static cell AMX_NATIVE_CALL get_cvar_float(AMX *amx, cell *params)
+{
+	int length;
+	const char* name = get_amxstring(amx, params[1], 0, length);
+
+	CvarInfo* info = g_CvarManager.FindCvar(name);
+
+	return info ? amx_ftoc(info->var->value) : 0;
+}
+
+// get_cvar_num(const cvarname[])
+static cell AMX_NATIVE_CALL get_cvar_num(AMX *amx, cell *params)
+{
+	int length;
+	const char* name = get_amxstring(amx, params[1], 0, length);
+
+	CvarInfo* info = g_CvarManager.FindCvar(name);
+
+	return info ? (int)info->var->value : 0;
+}
+
+// get_cvar_string(const cvarname[], output[], iLen)
+static cell AMX_NATIVE_CALL get_cvar_string(AMX *amx, cell *params)
+{
+	int length;
+	const char* name = get_amxstring(amx, params[1], 0, length);
+
+	CvarInfo* info = g_CvarManager.FindCvar(name);
+
+	const char *value = info ? info->var->string : "";
+	length = info ? strlen(value) : 0;
+
+	return set_amxstring_utf8(amx, params[2], value, length, params[3]);
+}
+
+// set_cvar_flags(const cvar[], flags)
+static cell AMX_NATIVE_CALL set_cvar_flags(AMX *amx, cell *params)
+{
+	int ilen;
+	const char* sCvar = get_amxstring(amx, params[1], 0, ilen);
+
+	if (!strcmp(sCvar, "amx_version") || !strcmp(sCvar, "amxmodx_version") || !strcmp(sCvar, "fun_version") || !strcmp(sCvar, "sv_cheats"))
+		return 0;
+
+	CvarInfo* info = g_CvarManager.FindCvar(sCvar);
+
+	if (info)
+	{
+		info->var->flags |= (int)(params[2]);
+		return 1;
+	}
+
+	return 0;
+}
+
+// set_cvar_float(const cvar[], Float:value)
+static cell AMX_NATIVE_CALL set_cvar_float(AMX *amx, cell *params)
+{
+	int length;
+	const char* name = get_amxstring(amx, params[1], 0, length);
+
+	CvarInfo* info = g_CvarManager.FindCvar(name);
+
+	if (info)
+	{
+		ke::SafeSprintf(CVarTempBuffer, sizeof(CVarTempBuffer), "%f", amx_ctof(params[2]));
+		CVAR_DIRECTSET(info->var, &CVarTempBuffer[0]);
+	}
+
+	return 1;
+}
+
+// set_cvar_num(const cvarname[], value)
+static cell AMX_NATIVE_CALL set_cvar_num(AMX *amx, cell *params)
+{
+	int length;
+	const char* name = get_amxstring(amx, params[1], 0, length);
+	int value = params[2];
+
+	CvarInfo* info = g_CvarManager.FindCvar(name);
+
+	if (info)
+	{
+		ke::SafeSprintf(CVarTempBuffer, sizeof(CVarTempBuffer), "%d", value);
+		CVAR_DIRECTSET(info->var, &CVarTempBuffer[0]);
+	}
+
+	return 1;
+}
+
+// set_cvar_string(const cvar[], const value[])
+static cell AMX_NATIVE_CALL set_cvar_string(AMX *amx, cell *params)
+{
+	int length;
+	const char* name  = get_amxstring(amx, params[1], 0, length);
+
+	CvarInfo* info = g_CvarManager.FindCvar(name);
+
+	if (info)
+	{
+		CVAR_DIRECTSET(info->var, get_amxstring(amx, params[2], 1, length));
+	}
+
+	return 1;
+}
+
+// get_pcvar_flags(pcvar)
+static cell AMX_NATIVE_CALL get_pcvar_flags(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	if (!ptr)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	return ptr->flags;
+}
+
+// Float:get_pcvar_float(pcvar)
+static cell AMX_NATIVE_CALL get_pcvar_float(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	if (!ptr)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	return amx_ftoc(ptr->value);
+}
+
+// get_pcvar_num(pcvar)
+static cell AMX_NATIVE_CALL get_pcvar_num(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	if (!ptr)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	return (int)ptr->value;
+}
+
+// bool:get_pcvar_bool(pcvar)
+static cell AMX_NATIVE_CALL get_pcvar_bool(AMX *amx, cell *params)
+{
+	return !!get_pcvar_num(amx, params);
+}
+
+// get_pcvar_string(pcvar, string[], maxlen)
+static cell AMX_NATIVE_CALL get_pcvar_string(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	if (!ptr)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	return set_amxstring_utf8(amx, params[2], ptr->string ? ptr->string : "", ptr->string ? strlen(ptr->string) : 0, params[3]);
+}
+
+// get_pcvar_bounds(pcvar, CvarBounds:type, &Float:value)
+static cell AMX_NATIVE_CALL get_pcvar_bounds(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	CvarInfo* info = nullptr;
+
+	if (!ptr || !(info = g_CvarManager.FindCvar(ptr->name)))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	bool hasBound = false;
+	float bound;
+
+	switch (params[2])
+	{
+		case CvarBound_Lower:
+			hasBound = info->bound.hasMin;
+			bound = info->bound.minVal;
+			break;
+		case CvarBound_Upper:
+			hasBound = info->bound.hasMax;
+			bound = info->bound.maxVal;
+			break;
+		default:
+			LogError(amx, AMX_ERR_NATIVE, "Invalid CvarBounds value: %d", params[2]);
+			return 0;
+	}
+
+	*get_amxaddr(amx, params[3]) = amx_ftoc(bound);
+
+	return hasBound;
+}
+
+// bind_pcvar_float(pcvar, &Float:var)
+static cell AMX_NATIVE_CALL bind_pcvar_float(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	CvarInfo* info = nullptr;
+
+	if (!ptr || !(info = g_CvarManager.FindCvar(ptr->name)))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	return g_CvarManager.BindCvar(info, CvarBind::CvarType_Float, amx, params[2]);
+}
+
+// bind_pcvar_num(pcvar, &any:var)
+static cell AMX_NATIVE_CALL bind_pcvar_num(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	CvarInfo* info = nullptr;
+
+	if (!ptr || !(info = g_CvarManager.FindCvar(ptr->name)))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	return g_CvarManager.BindCvar(info, CvarBind::CvarType_Int, amx, params[2]);
+}
+
+// bind_pcvar_string(pcvar, any:var[], varlen)
+static cell AMX_NATIVE_CALL bind_pcvar_string(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	CvarInfo* info = nullptr;
+
+	if (!ptr || !(info = g_CvarManager.FindCvar(ptr->name)))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	return g_CvarManager.BindCvar(info, CvarBind::CvarType_String, amx, params[2], params[3]);
+}
+
+// set_pcvar_flags(pcvar, flags)
+static cell AMX_NATIVE_CALL set_pcvar_flags(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	if (!ptr)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	ptr->flags = static_cast<int>(params[2]);
+
+	return 1;
+}
+
+// set_pcvar_float(pcvar, Float:num)
+static cell AMX_NATIVE_CALL set_pcvar_float(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	if (!ptr)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	ke::SafeSprintf(CVarTempBuffer, sizeof(CVarTempBuffer), "%f", amx_ctof(params[2]));
+	CVAR_DIRECTSET(ptr, &CVarTempBuffer[0]);
+
+	return 1;
+}
+
+// set_pcvar_num(pcvar, num)
+static cell AMX_NATIVE_CALL set_pcvar_num(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	if (!ptr)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	ke::SafeSprintf(CVarTempBuffer, sizeof(CVarTempBuffer), "%d", params[2]);
+	CVAR_DIRECTSET(ptr, &CVarTempBuffer[0]);
+
+	return 1;
+}
+
+// set_pcvar_string(pcvar, const string[])
+static cell AMX_NATIVE_CALL set_pcvar_string(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	if (!ptr)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	int len;
+
+	CVAR_DIRECTSET(ptr, get_amxstring(amx, params[2], 0, len));
+
+	return 1;
+}
+
+// set_pcvar_bounds(pcvar, CvarBounds:type, bool:set, Float:value = 0.0)
+static cell AMX_NATIVE_CALL set_pcvar_bounds(AMX *amx, cell *params)
+{
+	cvar_t *ptr = reinterpret_cast<cvar_t *>(params[1]);
+	CvarInfo* info = nullptr;
+
+	if (!ptr || !(info = g_CvarManager.FindCvar(ptr->name)))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid CVAR pointer");
+		return 0;
+	}
+
+	bool set = params[3] != 0;
+	int pluginId = g_plugins.findPluginFast(amx)->getId();
+	float value  = amx_ctof(params[4]);
+
+	switch (params[2])
+	{
+		case CvarBound_Lower:
+		{
+			if (set && info->bound.hasMax && value > info->bound.maxVal)
+			{
+				LogError(amx, AMX_ERR_NATIVE, "The minimum value can not be above the maximum value");
+				return 0;
+			}
+
+			g_CvarManager.SetCvarMin(info, set, value, pluginId);
+			break;
+		}
+		case CvarBound_Upper:
+		{
+			if (set && info->bound.hasMin && value < info->bound.minVal)
+			{
+				LogError(amx, AMX_ERR_NATIVE, "The maximum value can not be below the minimum value");
+				return 0;
+			}
+
+			g_CvarManager.SetCvarMax(info, set, value, pluginId);
+			break;
+		}
+		default:
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid CvarBounds value: %d", params[2]);
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+// remove_cvar_flags(const cvar[], flags=-1)
+static cell AMX_NATIVE_CALL remove_cvar_flags(AMX *amx, cell *params)
+{
+	int ilen;
+	char* sCvar = get_amxstring(amx, params[1], 0, ilen);
+
+	if (!strcmp(sCvar, "amx_version") || !strcmp(sCvar, "amxmodx_version") || !strcmp(sCvar, "fun_version") || !strcmp(sCvar, "sv_cheats"))
+		return 0;
+
+	CvarInfo* info = g_CvarManager.FindCvar(sCvar);
+
+	if (info)
+	{
+		info->var->flags &= ~((int)(params[2]));
+		return 1;
+	}
+
+	return 0;
+}
+
+// get_plugins_cvar(id, name[], namelen, &flags=0, &plugin_id=0, &pcvar_handle=0, description[]="", desc_len=0)
+static cell AMX_NATIVE_CALL get_plugins_cvar(AMX *amx, cell *params)
+{
+	CvarInfo* info = g_CvarManager.FindCvar(params[1]);
+
+	if (info)
+	{
+		set_amxstring(amx, params[2], info->name.chars(), params[3]);
+		*get_amxaddr(amx, params[4]) = info->var->flags;
+		*get_amxaddr(amx, params[5]) = info->pluginId;
+		*get_amxaddr(amx, params[6]) = reinterpret_cast<cell>(info->var);
+
+		if (*params / sizeof(cell) >= 7)
+		{
+			set_amxstring(amx, params[7], info->description.chars(), params[8]);
+		}
+
+		return 1;
+	}
+
+	return 0;
+}
+
+// get_plugins_cvarsnum()
+static cell AMX_NATIVE_CALL get_plugins_cvarsnum(AMX *amx, cell *params)
+{
+	return g_CvarManager.GetRegCvarsCount();
+}
+
+#if defined AMD64
+static bool g_warned_ccqv = false;
+#endif
+// query_client_cvar(id, const cvar[], const resultfunc[])
+static cell AMX_NATIVE_CALL query_client_cvar(AMX *amx, cell *params)
+{
+	int numParams = params[0] / sizeof(cell);
+
+	if (numParams != 3 && numParams != 5)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid number of parameters passed!");
+		return 0;
+	}
+
+#if defined AMD64
+	if (!g_warned_ccqv)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "[AMXX] Client CVAR Querying is not available on AMD64 (one time warn)");
+		g_warned_ccqv = true;
+	}
+
+	return 0;
+#endif
+
+	if (!g_NewDLL_Available)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Client CVAR querying is not enabled - check MM version!");
+		return 0;
+	}
+
+	int id = params[1];
+
+	if (id < 1 || id > gpGlobals->maxClients)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid player id %d", id);
+		return 0;
+	}
+
+	CPlayer *pPlayer = GET_PLAYER_POINTER_I(id);
+
+	if (!pPlayer->initialized || pPlayer->IsBot())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Player %d is either not connected or a bot", id);
+		return 0;
+	}
+
+	int dummy;
+	const char *cvarname = get_amxstring(amx, params[2], 0, dummy);
+	const char *resultfuncname = get_amxstring(amx, params[3], 1, dummy);
+
+	// public clientcvarquery_result(id, const cvar[], const result[], [const param[]])
+	int iFunc;
+
+	if (numParams == 5 && params[4] != 0)
+		iFunc = registerSPForwardByName(amx, resultfuncname, FP_CELL, FP_STRING, FP_STRING, FP_ARRAY, FP_DONE);
+	else
+		iFunc = registerSPForwardByName(amx, resultfuncname, FP_CELL, FP_STRING, FP_STRING, FP_DONE);
+
+	if (iFunc == -1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Function \"%s\" is not present", resultfuncname);
+		return 0;
+	}
+
+	ClientCvarQuery_Info *queryObject = new ClientCvarQuery_Info;
+	queryObject->resultFwd = iFunc;
+	queryObject->requestId = MAKE_REQUESTID(PLID);
+
+	if (numParams == 5 && params[4] != 0)
+	{
+		queryObject->paramLen = params[4] + 1;
+		queryObject->params = new cell[queryObject->paramLen];
+
+		if (!queryObject->params)
+		{
+			delete queryObject;
+			unregisterSPForward(iFunc);
+			LogError(amx, AMX_ERR_MEMORY, "Hmm. Out of memory?");
+			return 0;
+		}
+
+		memcpy(reinterpret_cast<void*>(queryObject->params), reinterpret_cast<const void *>(get_amxaddr(amx, params[5])), queryObject->paramLen * sizeof(cell));
+
+		queryObject->params[queryObject->paramLen - 1] = 0;
+	}
+	else {
+		queryObject->params = NULL;
+		queryObject->paramLen = 0;
+	}
+
+	pPlayer->queries.push_back(queryObject);
+
+	QUERY_CLIENT_CVAR_VALUE2(pPlayer->pEdict, cvarname, queryObject->requestId);
+
+	return 1;
+}
+
+AMX_NATIVE_INFO g_CvarNatives[] =
+{
+	{"create_cvar",				create_cvar},
+	{"register_cvar",			register_cvar},
+	{"cvar_exists",				cvar_exists},
+	{"get_cvar_pointer",		get_cvar_pointer},
+
+	{"hook_cvar_change",        hook_cvar_change},
+	{"enable_cvar_hook",		enable_cvar_hook},
+	{"disable_cvar_hook",		disable_cvar_hook},
+
+	{"get_cvar_flags",			get_cvar_flags},
+	{"get_cvar_float",			get_cvar_float},
+	{"get_cvar_num",			get_cvar_num},
+	{"get_cvar_string",			get_cvar_string},
+
+	{"set_cvar_flags",			set_cvar_flags},
+	{"set_cvar_float",			set_cvar_float},
+	{"set_cvar_num",			set_cvar_num},
+	{"set_cvar_string",			set_cvar_string},
+
+	{"get_pcvar_flags",			get_pcvar_flags},
+	{"get_pcvar_float",			get_pcvar_float},
+	{"get_pcvar_num",			get_pcvar_num},
+	{"get_pcvar_bool",			get_pcvar_bool},
+	{"get_pcvar_string",		get_pcvar_string},
+	{"get_pcvar_bounds",		get_pcvar_bounds},
+
+	{"set_pcvar_flags",			set_pcvar_flags},
+	{"set_pcvar_float",			set_pcvar_float},
+	{"set_pcvar_num",			set_pcvar_num},
+	{"set_pcvar_bool",			set_pcvar_num},
+	{"set_pcvar_string",		set_pcvar_string},
+	{"set_pcvar_bounds",		set_pcvar_bounds},
+
+	{"remove_cvar_flags",		remove_cvar_flags},
+
+	{"bind_pcvar_float",		bind_pcvar_float},
+	{"bind_pcvar_num",			bind_pcvar_num},
+	{"bind_pcvar_string",		bind_pcvar_string},
+
+	{"get_plugins_cvar",		get_plugins_cvar},
+	{"get_plugins_cvarsnum",	get_plugins_cvarsnum},
+
+	{"query_client_cvar",		query_client_cvar},
+
+	{NULL,						NULL}
+};

amxmodx/datapacks.cpp

@@ -0,0 +1,250 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ */
+
+#include "CDataPack.h"
+
+NativeHandle<CDataPack> DataPackHandles;
+
+static cell AMX_NATIVE_CALL CreateDataPack(AMX* amx, cell* params)
+{
+	return static_cast<cell>(DataPackHandles.create());
+}
+
+static cell AMX_NATIVE_CALL WritePackCell(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	d->PackCell(params[2]);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL WritePackFloat(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	d->PackFloat(amx_ctof(params[2]));
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL WritePackString(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	int len;
+	const char *str = get_amxstring(amx, params[2], 0, len);
+
+	d->PackString(str);
+
+	return len;
+}
+
+static cell AMX_NATIVE_CALL ReadPackCell(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	if (!d->CanReadCell())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Datapack operation is invalid.");
+		return 0;
+	}
+
+	return d->ReadCell();
+}
+
+static cell AMX_NATIVE_CALL ReadPackFloat(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	if (!d->CanReadFloat())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Datapack operation is invalid.");
+		return 0;
+	}
+
+	float value = d->ReadFloat();
+
+	return amx_ftoc(value);
+}
+
+static cell AMX_NATIVE_CALL ReadPackString(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	if (!d->CanReadString(NULL))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Datapack operation is invalid.");
+		return 0;
+	}
+
+	size_t len;
+	const char *str = d->ReadString(&len);
+
+	return set_amxstring_utf8(amx, params[2], str, len, params[3]);
+}
+
+static cell AMX_NATIVE_CALL ResetPack(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	d->Reset();
+
+	if (params[2])
+	{
+		d->ResetSize();
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL GetPackPosition(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	return static_cast<cell>(d->GetPosition());
+}
+
+static cell AMX_NATIVE_CALL SetPackPosition(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	if (!d->SetPosition(params[2]))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid DataPack position, %d is out of bounds", params[2]);
+		return 0;
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL IsPackEnded(AMX* amx, cell* params)
+{
+	CDataPack *d = DataPackHandles.lookup(params[1]);
+
+	if (!d)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	return d->IsReadable(1) ? false : true;
+}
+
+static cell AMX_NATIVE_CALL DestroyDataPack(AMX* amx, cell* params)
+{
+	cell *ptr = get_amxaddr(amx, params[1]);
+
+	CDataPack *d = DataPackHandles.lookup(*ptr);
+
+	if (!d)
+	{
+		return 0;
+	}
+
+	if (DataPackHandles.destroy(*ptr))
+	{
+		*ptr = 0;
+		return 1;
+	}
+
+	return 0;
+}
+
+
+AMX_NATIVE_INFO g_DatapackNatives[] = 
+{
+	{ "CreateDataPack" , CreateDataPack },
+	{ "WritePackCell"  , WritePackCell },
+	{ "WritePackFloat" , WritePackFloat },
+	{ "WritePackString", WritePackString },
+	{ "ReadPackCell"   , ReadPackCell },
+	{ "ReadPackFloat"  , ReadPackFloat },
+	{ "ReadPackString" , ReadPackString },
+	{ "ResetPack"      , ResetPack },
+	{ "GetPackPosition", GetPackPosition },
+	{ "SetPackPosition", SetPackPosition },
+	{ "IsPackEnded"    , IsPackEnded },
+	{ "DestroyDataPack", DestroyDataPack },
+	{ nullptr          , nullptr}
+};

amxmodx/datastructs.cpp

@@ -0,0 +1,935 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "amxmodx.h"
+#include "datastructs.h"
+#include <amtl/am-utility.h>
+
+NativeHandle<CellArray> ArrayHandles;
+
+// Array:ArrayCreate(cellsize=1, reserved=32);
+static cell AMX_NATIVE_CALL ArrayCreate(AMX* amx, cell* params)
+{
+	// params[1] (cellsize) is how big in cells each element is.
+	// this MUST be greater than 0!
+	int cellsize = params[1];
+
+	// params[2] (reserved) is how many elements to allocate
+	// immediately when the list is created.
+	int reserved = params[2];
+
+	if (cellsize <= 0)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array size (%d)", cellsize);
+		return -1;
+	}
+
+	if (reserved < 0)
+	{
+		reserved = 0;
+	}
+
+	return ArrayHandles.create(cellsize, reserved);
+}
+
+// native ArrayClear(Array:which);
+static cell AMX_NATIVE_CALL ArrayClear(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	vec->clear();
+
+	return 1;
+}
+
+// native ArraySize(Array:which);
+static cell AMX_NATIVE_CALL ArraySize(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	return vec->size();
+}
+
+// native bool:ArrayResize(Array:which, newsize);
+static cell AMX_NATIVE_CALL ArrayResize(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	if (!vec->resize(params[2]))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Unable to resize array to \"%u\"", params[2]);
+		return 0;
+	}
+
+	return 1;
+}
+
+// native Array:ArrayClone(Array:which);
+static cell AMX_NATIVE_CALL ArrayClone(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	auto data = vec->clone();
+
+	if (!data)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Failed to clone array. Out of memory.");
+		return 0;
+	}
+
+	return ArrayHandles.clone(data);
+}
+
+// native ArrayGetArray(Array:which, item, any:output[], size = -1);
+static cell AMX_NATIVE_CALL ArrayGetArray(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = (size_t)params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx, vec->size());
+		return 0;
+	}
+
+	cell *blk = vec->at(idx);
+	size_t indexes = vec->blocksize();
+
+	if (*params / sizeof(cell) == 4)
+	{
+		if (params[4] != -1 && (size_t)params[4] <= vec->blocksize())
+		{
+			indexes = params[4];
+		}
+	}
+
+	cell *addr = get_amxaddr(amx, params[3]);
+
+	memcpy(addr, blk, sizeof(cell) * indexes);
+
+	return indexes;
+}
+
+// native any:ArrayGetCell(Array:which, item, block = 0, bool:asChar = false);
+static cell AMX_NATIVE_CALL ArrayGetCell(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = (size_t)params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx, vec->size());
+		return 0;
+	}
+
+	cell *blk = vec->at(idx);
+
+	if (*params / sizeof(cell) <= 2)
+	{
+		return *blk;
+	}
+
+	idx = (size_t)params[3];
+
+	if (!params[4])
+	{
+		if (idx >= vec->blocksize())
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid block %d (blocksize: %d)", idx, vec->blocksize());
+			return 0;
+		}
+
+		return blk[idx];
+	}
+	else 
+	{
+		if (idx >= vec->blocksize() * 4)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid byte %d (blocksize: %d bytes)", idx, vec->blocksize() * 4);
+			return 0;
+		}
+
+		return (cell)*((char *)blk + idx);
+	}
+
+	return 0;
+}
+
+// native ArrayGetString(Array:which, item, output[], size);
+static cell AMX_NATIVE_CALL ArrayGetString(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = (size_t)params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx, vec->size());
+		return 0;
+	}
+
+	cell *blk = vec->at(idx);
+	return set_amxstring_utf8(amx, params[3], blk, amxstring_len(blk), params[4]);
+}
+
+// native ArraySetArray(Array:which, item, const any:input[], size =-1);
+static cell AMX_NATIVE_CALL ArraySetArray(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = (size_t)params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx, vec->size());
+		return 0;
+	}
+
+	cell *blk = vec->at(idx);
+	size_t indexes = vec->blocksize();
+
+	if (*params / sizeof(cell) == 4)
+	{
+		if (params[4] != -1 && (size_t)params[4] <= vec->blocksize())
+		{
+			indexes = params[4];
+		}
+	}
+
+	cell *addr = get_amxaddr(amx, params[3]);
+
+	memcpy(blk, addr, sizeof(cell) * indexes);
+
+	return indexes;
+}
+
+// native ArraySetCell(Array:which, item, any:input, block = 0, bool:asChar = false);
+static cell AMX_NATIVE_CALL ArraySetCell(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = (size_t)params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx, vec->size());
+		return 0;
+	}
+
+	cell *blk = vec->at(idx);
+	idx = (size_t)params[4];
+
+	if (*params / sizeof(cell) <= 3)
+	{
+		*blk = params[3];
+		return 1;
+	}
+
+	if (params[5] == 0)
+	{
+		if (idx >= vec->blocksize())
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid block %d (blocksize: %d)", idx, vec->blocksize());
+			return 0;
+		}
+		blk[idx] = params[3];
+	}
+	else 
+	{
+		if (idx >= vec->blocksize() * 4)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid byte %d (blocksize: %d bytes)", idx, vec->blocksize() * 4);
+			return 0;
+		}
+		*((char *)blk + idx) = (char)params[3];
+	}
+
+	return 1;
+}
+
+// native ArraySetString(Array:which, item, const input[]);
+static cell AMX_NATIVE_CALL ArraySetString(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = (size_t)params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx, vec->size());
+		return 0;
+	}
+
+	cell *blk = vec->at(idx);
+
+	int len;
+	char *str = get_amxstring(amx, params[3], 0, len);
+
+	return strncopy(blk, str, ke::Min((size_t)len + 1, vec->blocksize()));
+}
+
+// native ArrayPushArray(Array:which, const any:input[], size = -1);
+static cell AMX_NATIVE_CALL ArrayPushArray(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	cell *blk = vec->push();
+
+	if (!blk)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Failed to grow array");
+		return 0;
+	}
+
+	cell *addr = get_amxaddr(amx, params[2]);
+	size_t indexes = vec->blocksize();
+
+	if (*params / sizeof(cell) == 3)
+	{
+		if (params[3] != -1 && (size_t)params[3] <= vec->blocksize())
+		{
+			indexes = params[3];
+		}
+	}
+
+	memcpy(blk, addr, sizeof(cell) * indexes);
+
+	return static_cast<cell>((vec->size() - 1));
+}
+
+// native ArrayPushCell(Array:which, any:input);
+static cell AMX_NATIVE_CALL ArrayPushCell(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	cell *blk = vec->push();
+
+	if (!blk)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Failed to grow array");
+		return 0;
+	}
+
+	*blk = params[2];
+
+	return static_cast<cell>((vec->size() - 1));
+}
+
+// native ArrayPushString(Array:which, const input[]);
+static cell AMX_NATIVE_CALL ArrayPushString(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	cell *blk = vec->push();
+	if (!blk)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Failed to grow array");
+		return 0;
+	}
+
+	strncopy(blk, get_amxaddr(amx, params[2]), vec->blocksize());
+
+	return static_cast<cell>((vec->size() - 1));
+}
+
+// native DoNotUse : ArrayGetStringHandle(Array : which, item);
+static cell AMX_NATIVE_CALL ArrayGetStringHandle(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = (size_t)params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx, vec->size());
+		return 0;
+	}
+
+	cell* ptr = vec->at(idx);
+
+	if (ptr == NULL)
+	{
+		return 0;
+	}
+
+	return reinterpret_cast<cell>(ptr);
+}
+
+// native ArrayInsertArrayAfter(Array:which, item, const any:input[]);
+static cell AMX_NATIVE_CALL ArrayInsertArrayAfter(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = params[2] + 1;
+
+	if (idx > vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertArrayAfter (%d:%d)", idx, vec->size());
+		return 0;
+	}
+
+	cell *addr = get_amxaddr(amx, params[3]);
+
+	memcpy(vec->insert_at(idx), addr, sizeof(cell) * vec->blocksize());
+
+	return 1;
+}
+
+// native ArrayInsertCellAfter(Array:which, item, any:input);
+static cell AMX_NATIVE_CALL ArrayInsertCellAfter(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = params[2] + 1;
+
+	if (idx > vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertCellAfter (%d:%d)", idx, vec->size());
+		return 0;
+	}
+
+	*vec->insert_at(idx) = params[3];
+
+	return 1;
+}
+
+// native ArrayInsertStringAfter(Array:which, item, const input[]);
+static cell AMX_NATIVE_CALL ArrayInsertStringAfter(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = params[2] + 1;
+
+	if (idx > vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertStringAfter (%d:%d)", idx, vec->size());
+		return 0;
+	}
+
+	int len;
+	const char *str = get_amxstring(amx, params[3], 0, len);
+
+	return strncopy(vec->insert_at(idx), str, ke::Min((size_t)len + 1, vec->blocksize()));
+}
+
+// native ArrayInsertArrayBefore(Array:which, item, const any:input[]);
+static cell AMX_NATIVE_CALL ArrayInsertArrayBefore(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertArrayBefore (%d:%d)", idx, vec->size());
+		return 0;
+	}
+
+	cell *addr = get_amxaddr(amx, params[3]);
+
+	memcpy(vec->insert_at(idx), addr, vec->blocksize() * sizeof(cell));
+
+	return 1;
+}
+
+// native ArrayInsertCellBefore(Array:which, item, const any:input);
+static cell AMX_NATIVE_CALL ArrayInsertCellBefore(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertCellBefore (%d:%d)", idx, vec->size());
+		return 0;
+	}
+
+	*vec->insert_at(idx) = params[3];
+
+	return 1;
+}
+// native ArrayInsertStringBefore(Array:which, item, const input[]);
+static cell AMX_NATIVE_CALL ArrayInsertStringBefore(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertStringBefore (%d:%d)", idx, vec->size());
+		return 0;
+	}
+
+	int len;
+	const char *str = get_amxstring(amx, params[3], 0, len);
+
+	return strncopy(vec->insert_at(idx), str, ke::Min((size_t)len + 1, vec->blocksize()));
+}
+
+// native ArraySwap(Array:which, item1, item2);
+static cell AMX_NATIVE_CALL ArraySwap(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx1 = (size_t)params[2];
+	size_t idx2 = (size_t)params[3];
+
+	if (idx1 >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx1, vec->size());
+		return 0;
+	}
+
+	if (idx2 >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx2, vec->size());
+		return 0;
+	}
+
+	vec->swap(idx1, idx2);
+
+	return 1;
+}
+
+// native ArrayDeleteItem(Array:which, item);
+static cell AMX_NATIVE_CALL ArrayDeleteItem(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	size_t idx = (size_t)params[2];
+
+	if (idx >= vec->size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d (count: %d)", idx, vec->size());
+		return 0;
+	}
+
+	vec->remove(idx);
+
+	return 1;
+}
+
+// native ArrayDestroy(&Array:which);
+static cell AMX_NATIVE_CALL ArrayDestroy(AMX* amx, cell* params)
+{
+	cell *handle = get_amxaddr(amx, params[1]);
+
+	CellArray* vec = ArrayHandles.lookup(*handle);
+
+	if (!vec)
+	{
+		return 0;
+	}
+
+	if (ArrayHandles.destroy(*handle))
+	{
+		*handle = 0;
+		return 1;
+	}
+
+	return 1;
+}
+
+
+struct ArraySort_s
+{
+	int   func;
+	cell  array_hndl;
+	cell* array_base;
+	cell  array_bsize;
+	cell  data;
+	cell  size;
+	cell  addr1;
+	cell  addr2;
+	AMX  *amx;
+};
+
+ArraySort_s SortInfo;
+
+int SortArrayList(const void *elem1, const void *elem2)
+{
+	return executeForwards(
+		SortInfo.func,
+		SortInfo.array_hndl,
+		((cell)((cell *)elem1 - SortInfo.array_base)) / SortInfo.array_bsize,
+		((cell)((cell *)elem2 - SortInfo.array_base)) / SortInfo.array_bsize,
+		SortInfo.data,
+		SortInfo.size
+	);
+}
+
+// native ArraySort(Array:array, const comparefunc[], data[]="", data_size=0);
+static cell AMX_NATIVE_CALL ArraySort(AMX* amx, cell* params)
+{
+	cell handle = params[1];
+	CellArray* vec = ArrayHandles.lookup(handle);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", handle);
+		return 0;
+	}
+
+	int len;
+	char* funcName = get_amxstring(amx, params[2], 0, len);
+	
+	// MySortFunc(Array:array, item1, item2, const data[], data_size)
+	int func = registerSPForwardByName(amx, funcName, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+	if (func < 0)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "The public function \"%s\" was not found.", funcName);
+		return 0;
+	}
+
+	size_t arraysize = vec->size();
+	size_t blocksize = vec->blocksize();
+	cell *array = vec->base();
+
+	ArraySort_s oldinfo = SortInfo;
+
+	SortInfo.func        = func;
+	SortInfo.array_base  = array;
+	SortInfo.array_bsize = static_cast<cell>(blocksize);
+	SortInfo.array_hndl  = handle;
+	SortInfo.data        = params[3];
+	SortInfo.size        = params[4];
+
+	qsort(array, arraysize, blocksize * sizeof(cell), SortArrayList);
+
+	SortInfo = oldinfo;
+
+	unregisterSPForward(func);
+
+	return 1;
+}
+
+
+int SortArrayListExCell(const void *elem1, const void *elem2)
+{
+	size_t index1 = ((cell)((cell *)elem1 - SortInfo.array_base)) / SortInfo.array_bsize;
+	size_t index2 = ((cell)((cell *)elem2 - SortInfo.array_base)) / SortInfo.array_bsize;
+
+	return executeForwards(
+		SortInfo.func,
+		SortInfo.array_hndl,
+		*&SortInfo.array_base[index1 * SortInfo.array_bsize], 
+		*&SortInfo.array_base[index2 * SortInfo.array_bsize],
+		SortInfo.data,
+		SortInfo.size
+	);
+}
+
+int SortArrayListExArray(const void *elem1, const void *elem2)
+{
+	size_t index1 = ((cell)((cell *)elem1 - SortInfo.array_base)) / SortInfo.array_bsize;
+	size_t index2 = ((cell)((cell *)elem2 - SortInfo.array_base)) / SortInfo.array_bsize;
+
+	cell *addr1 = get_amxaddr(SortInfo.amx, SortInfo.addr1);
+	cell *addr2 = get_amxaddr(SortInfo.amx, SortInfo.addr2);
+
+	memcpy(addr1, &SortInfo.array_base[index1 * SortInfo.array_bsize], SortInfo.array_bsize * sizeof(cell));
+	memcpy(addr2, &SortInfo.array_base[index2 * SortInfo.array_bsize], SortInfo.array_bsize * sizeof(cell));
+
+	return executeForwards(
+		SortInfo.func,
+		SortInfo.array_hndl,
+		SortInfo.addr1,
+		SortInfo.addr2,
+		SortInfo.data,
+		SortInfo.size
+	);
+}
+
+// native ArraySortEx(Array:array, const comparefunc[], data[]="", data_size=0);
+static cell AMX_NATIVE_CALL ArraySortEx(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	int len;
+	char* funcName = get_amxstring(amx, params[2], 0, len);
+
+	int func = registerSPForwardByName(amx, funcName, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+
+	if (!func)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "The public function \"%s\" was not found.", funcName);
+		return 0;
+	}
+
+	size_t arraysize = vec->size();
+	size_t blocksize = vec->blocksize();
+	cell *array = vec->base();
+	cell amx_addr1 = 0, amx_addr2 = 0, *phys_addr = NULL;
+
+	if (blocksize > 1)
+	{
+		int err;
+		if ((err = amx_Allot(amx, blocksize, &amx_addr1, &phys_addr)) != AMX_ERR_NONE
+		|| ( err = amx_Allot(amx, blocksize, &amx_addr2, &phys_addr)) != AMX_ERR_NONE)
+		{
+			LogError(amx, err, "Ran out of memory");
+			return 0;
+		}
+	}
+
+	ArraySort_s oldinfo = SortInfo;
+
+	SortInfo.func        = func;
+	SortInfo.array_base  = array;
+	SortInfo.array_bsize = static_cast<cell>(blocksize);
+	SortInfo.array_hndl  = params[1];
+	SortInfo.data        = params[3];
+	SortInfo.size        = params[4];
+	SortInfo.amx         = amx;
+	SortInfo.addr1       = amx_addr1;
+	SortInfo.addr2       = amx_addr2;
+
+	qsort(array, arraysize, blocksize * sizeof(cell), blocksize > 1 ? SortArrayListExArray : SortArrayListExCell);
+
+	SortInfo = oldinfo;
+
+	if (blocksize > 1)
+	{
+		amx_Release(amx, amx_addr1);
+		amx_Release(amx, amx_addr2);
+	}
+
+	unregisterSPForward(func);
+
+	return 1;
+}
+
+extern bool fastcellcmp(cell *a, cell *b, cell len);
+extern int amxstring_len(cell* a);
+
+// native ArrayFindString(Array:which, const item[]);
+static cell AMX_NATIVE_CALL ArrayFindString(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return -1;
+	}
+
+	cell *b, *a = get_amxaddr(amx, params[2]);
+	size_t cellcount = vec->blocksize();
+	size_t a_len = ke::Max(1, amxstring_len(a));
+	size_t len = a_len > cellcount ? cellcount : a_len;
+
+	for (size_t i = 0; i < vec->size(); i++)
+	{	
+		b = vec->at(i);
+
+		if (fastcellcmp(a, b, len))
+		{
+			return static_cast<cell>(i);
+		}
+	}
+
+	return -1;
+}
+
+// native ArrayFindValue(Array:which, any:item); 
+static cell AMX_NATIVE_CALL ArrayFindValue(AMX* amx, cell* params)
+{
+	CellArray* vec = ArrayHandles.lookup(params[1]);
+
+	if (!vec)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
+		return -1;
+	}
+
+	for (size_t i = 0; i < vec->size(); i++)
+	{
+		if (params[2] == *vec->at(i))
+		{
+			return static_cast<cell>(i);
+		}
+	}
+
+	return -1;
+}
+
+AMX_NATIVE_INFO g_DataStructNatives[] = 
+{
+	{ "ArrayCreate"            , ArrayCreate },
+	{ "ArrayClear"             , ArrayClear },
+	{ "ArrayClone"             , ArrayClone },
+	{ "ArraySize"              , ArraySize },
+	{ "ArrayResize"            , ArrayResize },
+	{ "ArrayGetArray"          , ArrayGetArray },
+	{ "ArrayGetCell"           , ArrayGetCell },
+	{ "ArrayGetString"         , ArrayGetString },
+	{ "ArraySetArray"          , ArraySetArray },
+	{ "ArraySetCell"           , ArraySetCell },
+	{ "ArraySetString"         , ArraySetString },
+	{ "ArrayPushArray"         , ArrayPushArray },
+	{ "ArrayPushCell"          , ArrayPushCell },
+	{ "ArrayPushString"        , ArrayPushString },
+	{ "ArrayInsertArrayAfter"  , ArrayInsertArrayAfter },
+	{ "ArrayInsertCellAfter"   , ArrayInsertCellAfter },
+	{ "ArrayInsertStringAfter" , ArrayInsertStringAfter },
+	{ "ArrayInsertArrayBefore" , ArrayInsertArrayBefore },
+	{ "ArrayInsertCellBefore"  , ArrayInsertCellBefore },
+	{ "ArrayInsertStringBefore", ArrayInsertStringBefore },
+	{ "ArraySwap"              , ArraySwap },
+	{ "ArrayDeleteItem"        , ArrayDeleteItem },
+	{ "ArrayGetStringHandle"   , ArrayGetStringHandle },
+	{ "ArrayDestroy"           , ArrayDestroy },
+	{ "ArraySort"              , ArraySort },
+	{ "ArraySortEx"            , ArraySortEx },
+	{ "ArrayFindString"        , ArrayFindString },
+	{ "ArrayFindValue"         , ArrayFindValue },
+	{ nullptr                  , nullptr }
+};

amxmodx/datastructs.h

@@ -0,0 +1,197 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef DATASTRUCTS_H
+#define DATASTRUCTS_H
+
+#include "natives_handles.h"
+
+class CellArray
+{
+public:
+	CellArray(size_t blocksize, size_t basesize = 0) : m_Data(nullptr), m_BlockSize(blocksize), m_AllocSize(0), m_BaseSize(basesize > 0 ? basesize : 8), m_Size(0)
+	{
+	}
+
+	~CellArray()
+	{
+		free(m_Data);
+	}
+
+	size_t size() const
+	{
+		return m_Size;
+	}
+
+	cell *push()
+	{
+		if (!GrowIfNeeded(1))
+		{
+			return NULL;
+		}
+		cell *arr = &m_Data[m_Size * m_BlockSize];
+		m_Size++;
+		return arr;
+	}
+
+	cell *at(size_t b) const
+	{
+		return &m_Data[b * m_BlockSize];
+	}
+
+	size_t blocksize() const
+	{
+		return m_BlockSize;
+	}
+
+	void clear()
+	{
+		m_Size = 0;
+	}
+
+	bool swap(size_t item1, size_t item2)
+	{
+		/* Make sure there is extra space available */
+		if (!GrowIfNeeded(1))
+		{
+			return false;
+		}
+
+		cell *pri = at(item1);
+		cell *alt = at(item2);
+
+		/* Get our temporary array 1 after the limit */
+		cell *temp = &m_Data[m_Size * m_BlockSize];
+
+		memcpy(temp, pri, sizeof(cell)* m_BlockSize);
+		memcpy(pri, alt, sizeof(cell)* m_BlockSize);
+		memcpy(alt, temp, sizeof(cell)* m_BlockSize);
+
+		return true;
+	}
+
+	void remove(size_t index)
+	{
+		/* If we're at the end, take the easy way out */
+		if (index == m_Size - 1)
+		{
+			m_Size--;
+			return;
+		}
+
+		/* Otherwise, it's time to move stuff! */
+		size_t remaining_indexes = (m_Size - 1) - index;
+		cell *src = at(index + 1);
+		cell *dest = at(index);
+		memmove(dest, src, sizeof(cell)* m_BlockSize * remaining_indexes);
+
+		m_Size--;
+	}
+
+	cell *insert_at(size_t index)
+	{
+		/* Make sure it'll fit */
+		if (!GrowIfNeeded(1))
+		{
+			return nullptr;
+		}
+
+		/* move everything up */
+		cell *src = at(index);
+		cell *dst = at(index + 1);
+		memmove(dst, src, sizeof(cell)* m_BlockSize * (m_Size - index));
+
+		m_Size++;
+
+		return src;
+	}
+
+	bool resize(size_t count)
+	{
+		if (count <= m_Size)
+		{
+			m_Size = count;
+			return true;
+		}
+
+		if (!GrowIfNeeded(count - m_Size))
+		{
+			return false;
+		}
+
+		m_Size = count;
+		return true;
+	}
+
+	CellArray *clone()
+	{
+		CellArray *array = new CellArray(m_BlockSize);
+		array->m_AllocSize = m_AllocSize;
+		array->m_Size = m_Size;
+		array->m_Data = (cell *)malloc(sizeof(cell)* m_BlockSize * m_AllocSize);
+
+		if (!array->m_Data)
+		{
+			delete array;
+			return nullptr;
+		}
+
+		memcpy(array->m_Data, m_Data, sizeof(cell)* m_BlockSize * m_Size);
+		return array;
+	}
+
+	cell *base()
+	{
+		return m_Data;
+	}
+
+	size_t mem_usage()
+	{
+		return m_AllocSize * m_BlockSize * sizeof(cell);
+	}
+
+private:
+	bool GrowIfNeeded(size_t count)
+	{
+		/* Shortcut out if we can store this */
+		if (m_Size + count <= m_AllocSize)
+		{
+			return true;
+		}
+		/* Set a base allocation size of 8 items */
+		if (!m_AllocSize)
+		{
+			m_AllocSize = m_BaseSize;
+		}
+		/* If it's not enough, keep doubling */
+		while (m_Size + count > m_AllocSize)
+		{
+			m_AllocSize *= 2;
+		}
+		/* finally, allocate the new block */
+		if (m_Data)
+		{
+			m_Data = (cell *)realloc(m_Data, sizeof(cell)* m_BlockSize * m_AllocSize);
+		}
+		else {
+			m_Data = (cell *)malloc(sizeof(cell)* m_BlockSize * m_AllocSize);
+		}
+		return (m_Data != NULL);
+	}
+private:
+	cell  *m_Data;
+	size_t m_BlockSize;
+	size_t m_AllocSize;
+	size_t m_BaseSize;
+	size_t m_Size;
+};
+
+extern NativeHandle<CellArray> ArrayHandles;
+
+#endif

amxmodx/debugger.h

@@ -0,0 +1,180 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef _INCLUDE_DEBUGGER_H_
+#define _INCLUDE_DEBUGGER_H_
+
+#include "amxdbg.h"
+
+/**
+ * Third revision of the AMX Mod X Plugin Debugger.
+ * This final, object oriented version is safe for multiple calls and lets you 
+ *  fine-tune error handling.
+ *  -BAILOPAN
+ */
+class Debugger
+{
+public:
+	class Tracer
+	{
+	public:
+		
+		struct trace_info
+		{
+			trace_info() : cip(0), frm(0), next(NULL), prev(NULL), used(false) {};
+			
+			cell cip;
+			cell frm;
+			
+			trace_info *next;
+			trace_info *prev;
+			
+			bool used;
+		};
+	
+	public:
+		Tracer() : m_Error(0), m_pStart(NULL), m_pEnd(NULL), m_Reset(true) {};
+		~Tracer();
+	public:
+		void StepI(cell frm, cell cip);
+		void Reset();
+		void Clear();
+		
+		Debugger::Tracer::trace_info *GetStart() const;
+		Debugger::Tracer::trace_info *GetEnd() const;
+	public:
+		int m_Error;
+	private:
+		trace_info *m_pStart;
+		trace_info *m_pEnd;
+		
+		bool m_Reset;
+	};
+
+public:
+	Debugger(AMX *pAmx, AMX_DBG *pAmxDbg) : m_pAmx(pAmx), m_pAmxDbg(pAmxDbg), m_Top(-1)
+	{
+		_CacheAmxOpcodeList();
+	};
+	~Debugger();
+public:
+	//Begin a trace for a function
+	void BeginExec();
+
+	//Step through one instruction
+	void StepI();
+
+	//Get/set the last traced error
+	int GetTracedError();
+	void SetTracedError(int error);
+
+	//Get the first trace info of the call stack
+	Debugger::Tracer::trace_info *GetTraceStart() const;
+
+	//Get extra info about the call stack
+	bool GetTraceInfo(Debugger::Tracer::trace_info *pTraceInfo, long &line, const char *&function, const char *&file);
+
+	//Get the next trace in the call stack, NULL if none
+	Debugger::Tracer::trace_info *GetNextTrace(Debugger::Tracer::trace_info *pTraceInfo);
+
+	//Returns true if an error exists
+	bool ErrorExists();
+
+	//Formats the error message into a buffer.
+	//returns length of data copied, or -1 if there is no error.
+	int FormatError(char *buffer, size_t maxLength);
+
+	//End a trace
+	void EndExec();
+
+	//Reset the internal states as if the debugger was inactive
+	void Reset();
+
+	//Destroy internal states for shutdown
+	void Clear();
+
+	void DisplayTrace(const char *message);
+
+	AMX *GetAMX() const { return m_pAmx; }
+public:
+	//generic static opcode breaker
+	static int AMXAPI DebugHook(AMX *amx);
+	
+	static void FmtGenericMsg(AMX *amx, int error, char buffer[], size_t maxLength);
+	static void GenericMessage(AMX *amx, int error);
+private:
+	void _CacheAmxOpcodeList();
+	
+	int _GetOpcodeFromCip(cell cip, cell *&addr);
+	cell _CipAsVa(cell cip);
+	
+	const char *_GetFilename();
+	const char *_GetVersion();
+public:
+	AMX *m_pAmx;
+	AMX_DBG *m_pAmxDbg;
+	
+	int m_Top;
+	cell *m_pOpcodeList;
+	ke::AString m_FileName;
+	ke::AString m_Version;
+
+	ke::Vector<Tracer *> m_pCalls;
+};
+
+typedef Debugger::Tracer::trace_info trace_info_t;
+
+/**
+ * Error handler for plugins
+ */
+
+class Handler
+{
+public:
+	Handler(AMX *pAmx) : m_pAmx(pAmx), m_iErrFunc(-1), m_iModFunc(-1), m_iNatFunc(-1), m_Handling(false), m_InNativeFilter(false) {};
+	~Handler() {};
+public:
+	int SetErrorHandler(const char *function);
+	int SetNativeFilter(const char *function);
+	int SetModuleFilter(const char *function);
+public:
+	int HandleError(const char *msg);
+	int HandleNative(const char *native, int index, int trap);
+	int HandleModule(const char *module, bool isClass=false);
+public:
+	bool IsHandling() const { return m_Handling; }
+	void SetErrorMsg(const char *msg);
+	
+	const char *GetLastMsg();
+	trace_info_t *GetTrace() const { return m_pTrace; }
+	const char *GetFmtCache() { return m_FmtCache.chars(); }
+	
+	bool IsNativeFiltering() { return (m_iNatFunc > -1); }
+	bool InNativeFilter() { return m_InNativeFilter; }
+private:
+	AMX *m_pAmx;
+	
+	int m_iErrFunc;
+	int m_iModFunc;
+	int m_iNatFunc;
+	
+	bool m_Handling;
+	
+	//in the future, make this a stack!
+	bool m_InNativeFilter;
+	
+	ke::AString m_MsgCache;
+	ke::AString m_FmtCache;
+	
+	trace_info_t *m_pTrace;
+};
+
+extern AMX_NATIVE_INFO g_DebugNatives[];
+
+#endif //_INCLUDE_DEBUGGER_H_

amxmodx/emsg.cpp

@@ -1,35 +1,14 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*  originally developed by OLO
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #include "amxmodx.h"
+#include "CMenu.h"
 
 int gmsgAmmoPickup;
 int gmsgAmmoX;
@@ -51,214 +30,288 @@ int gmsgWeaponList;
 int gmsgintermission;
 int gmsgResetHUD;
 int gmsgRoundTime;
+int gmsgSayText;
+int gmsgInitHUD;
 
 TeamIds g_teamsIds;
 WeaponsVault g_weaponsData[MAX_WEAPONS];
 
 void Client_VGUIMenu(void* mValue)
 {
-  if (!mPlayer) return;
-  switch (mState++){
-  case 0:
-    mPlayer->menu = -(*(int*)mValue);
-    break;
-  case 1:
-    mPlayer->keys = *(int*)mValue;
-  }
+	if (!mPlayer) return;
+
+	mPlayer->vgui = true;
+
+	switch (mState++)
+	{
+		case 0:
+			mPlayer->menu = -(*(int*)mValue);
+			mPlayer->newmenu = -1;
+			break;
+		case 1:
+			mPlayer->keys = *(int*)mValue;
+	}
 }
 
 void Client_ShowMenu(void* mValue)
 {
-  if (!mPlayer) return;
-  switch (mState++){
-  case 0:
-    mPlayer->keys = *(int*)mValue;
-    break;
-  case 3:
-    mPlayer->menu = g_menucmds.findMenuId( (char*)mValue );
-  }
+	if (!mPlayer) return;
+
+	mPlayer->vgui = true;
+
+	switch (mState++)
+	{
+		case 0:
+			mPlayer->keys = *(int*)mValue;
+			break;
+		case 3:
+			{
+			mPlayer->menu = g_menucmds.findMenuId((char*)mValue);
+			mPlayer->newmenu = -1;
+			break;
+			}
+	}
 }
 
+extern bool g_bmod_tfc;
 void Client_TeamInfo(void* mValue)
 {
-  if (mPlayer) return;
-  static int index;
-  switch (mState++) {
-  case 0:
-    index = *(int*)mValue;
-    break;
-  case 1:
-	if ( index < 1 || index > gpGlobals->maxClients ) break;
-	char* msg = (char*)mValue;
-    g_players[ index ].team.assign( msg );
-	g_teamsIds.registerTeam( msg , -1 );
-  }
+	if (mPlayer && !g_bmod_tfc) return;
+	static int index;
+
+	switch (mState++)
+	{
+		case 0:
+			index = *(int*)mValue;
+			break;
+		case 1:
+			if (index < 1 || index > gpGlobals->maxClients) break;
+			char* msg = (char*)mValue;
+			if (!msg) break;
+
+			auto pPlayer = GET_PLAYER_POINTER_I(index);
+		
+			pPlayer->team = msg;
+			g_teamsIds.registerTeam(msg, -1);
+			pPlayer->teamId = g_teamsIds.findTeamId(msg);
+						
+			if (pPlayer->teamId == -1)
+			{
+				/**
+				 * CS fix for SPECTATOR team. 
+				 * -
+				 * When a player chooses spectator, ScoreInfo is sent before TeamInfo and with 0 as index.
+				 * This means for the first round of first spectator, SPECTATOR name is not associated with its index.
+				 *  The following fix manually sets the team index when we hit SPECTATOR team.
+				 */
+				if (g_bmod_cstrike && !strcmp(msg, "SPECTATOR"))
+				{
+					pPlayer->teamId = 3;
+					g_teamsIds.registerTeam(msg, 3);
+				}
+
+				/**
+				 * Fixes in-between situation where the team name is not yet associated with a valid index
+				 * and ScoreInfo is executed later (used to retrieve the index). E.g. a player is dead,
+				 * then changes team. Index will return -1 until ScoreInfo is sent, usually at the next spawn.
+				 */
+				else if ((g_bmod_cstrike || g_bmod_dod || g_bmod_tfc || g_bmod_gearbox || g_bmod_valve) 
+					&&  pPlayer->pEdict->pvPrivateData 
+					&& !pPlayer->IsAlive())
+				{
+					GET_OFFSET_NO_ERROR("CBasePlayer", m_iTeam);
+
+					const auto teamId = get_pdata<int>(pPlayer->pEdict, m_iTeam);
+					
+					pPlayer->teamId = teamId;
+					g_teamsIds.registerTeam(msg, teamId);
+				}
+			}
+
+			break;
+	}
 }
 
 void Client_TextMsg(void* mValue)
 {
-	if ( mPlayer ) return;
-	switch (mState++) {
-	case 1:{
-		char * msg = (char*)mValue;
-		if (!msg) break;
-		if ( !strncmp("#Game_C", msg , 7) ) {
-			g_game_timeleft = g_game_restarting = gpGlobals->time + 3;
-			//      g_endround_time = gpGlobals->time;
-			//      g_newround_time = gpGlobals->time + CVAR_GET_FLOAT("mp_freezetime") + 3;
-		}
-		else if (!strncmp("#Game_w", msg , 7) ) {
-			g_game_timeleft = -2;
-		}
-		else if ( !strncmp("#game_clan_s", msg , 12)  ){
-			g_game_timeleft = -3;
-		}
-		break;
-		   }
-	case 2:{
-		char * msg = (char*)mValue;
-		if (!msg) break;
-		if (g_game_timeleft == -2 ){
-			g_game_timeleft = g_game_restarting = gpGlobals->time + atoi( msg );
-			//    g_newround_time = g_game_timeleft + CVAR_GET_FLOAT("mp_freezetime");
-		}
-		else if ( g_game_timeleft == -3 )
-			g_game_restarting = atoi( msg ) * 60;
-		break;
-		   }
-	case 3:{
-		char * msg = (char*)mValue;
-		if (!msg) break;
-		if ( g_game_timeleft != -3 ) break;
-		g_game_restarting += atoi( msg );
-		g_game_timeleft = g_game_restarting	= gpGlobals->time + g_game_restarting;
-		break;
-		   }
-	}
+	if (mPlayer) return;
 	
+	switch (mState++)
+	{
+		case 1:
+		{
+			char * msg = (char*)mValue;
+			if (!msg) break;
+			
+			if (!strncmp("#Game_C", msg, 7))
+			{
+				g_game_timeleft = g_game_restarting = gpGlobals->time + 3;
+				//g_endround_time = gpGlobals->time;
+				//g_newround_time = gpGlobals->time + CVAR_GET_FLOAT("mp_freezetime") + 3;
+			}
+			else if (!strncmp("#Game_w", msg, 7))
+			{
+				g_game_timeleft = -2;
+			}
+			else if (!strncmp("#game_clan_s", msg, 12))
+			{
+				g_game_timeleft = -3;
+			}
+			
+			break;
+		}
+		case 2:
+		{
+			char * msg = (char*)mValue;
+			if (!msg) break;
+			
+			if (g_game_timeleft == -2)
+			{
+				g_game_timeleft = g_game_restarting = gpGlobals->time + atoi(msg);
+				//g_newround_time = g_game_timeleft + CVAR_GET_FLOAT("mp_freezetime");
+			}
+			else if (g_game_timeleft == -3)
+				g_game_restarting = atoi(msg) * 60.0f;
+			
+			break;
+		}
+		case 3:
+		{
+			char * msg = (char*)mValue;
+			if (!msg) break;
+			if (g_game_timeleft != -3) break;
+			g_game_restarting += atoi(msg);
+			g_game_timeleft = g_game_restarting	= gpGlobals->time + g_game_restarting;
+			
+			break;
+		}
+	}
 }
 
 void Client_WeaponList(void* mValue)
 {
-  static int wpnList = 0;
-  //static int wpnList2;
-  static int iSlot;
-  static const char* wpnName;
-  switch (mState++) {
-  case 0:
-    wpnName = (char*)mValue;
-    break;
-  case 1:
-    iSlot = *(int*)mValue;
-    break;
-  case 7:
-    int iId = *(int*)mValue;
-	/*int* blocker;
-
-	int iwpn = iId;
+	static int wpnList = 0;
+	//static int wpnList2;
+	static int iSlot;
+	static const char* wpnName;
 	
-	if (iId > 31) {
-		iwpn -= 31;
-		blocker = &wpnList2;
+	switch (mState++)
+	{
+		case 0:
+			wpnName = (char*)mValue;
+			break;
+		case 1:
+			iSlot = *(int*)mValue;
+			break;
+		case 7:
+			int iId = *(int*)mValue;
+			if ((iId < 0 || iId >= MAX_WEAPONS) || (wpnList & (1<<iId)))
+			break;
+			wpnList |= (1<<iId);
+			g_weaponsData[iId].iId = iId;
+			g_weaponsData[iId].ammoSlot = iSlot;
+			g_weaponsData[iId].fullName = wpnName;
 	}
-	else
-		blocker = &wpnList;*/
-
-    if ( (iId < 0 || iId >= MAX_WEAPONS ) || (wpnList & (1<<iId)) )
-      break;
-    wpnList |= (1<<iId);
-    g_weaponsData[iId].iId = iId;
-    g_weaponsData[iId].ammoSlot = iSlot;
-    g_weaponsData[iId].fullName.assign(wpnName);
-
-  }
 }
 
 void Client_CurWeapon(void* mValue)
 {
-  static int iState;
-  static int iId;
-  switch (mState++){
-  case 0:
-    iState = *(int*)mValue;
-    break;
-  case 1:
-    if (!iState) break;
-    iId = *(int*)mValue;
-    break;
-  case 2:
-  if (!mPlayer) return;
-    if (!iState || (iId < 1 || iId >= MAX_WEAPONS ) ) break;
-    mPlayer->weapons[iId].clip = *(int*)mValue;
-    mPlayer->current = iId;
-    mPlayer->lastHit = mPlayer->lastTrace;
-  }
+	static int iState;
+	static int iId;
+	
+	switch (mState++)
+	{
+		case 0:
+			iState = *(int*)mValue;
+			break;
+		case 1:
+			if (!iState) break;
+			iId = *(int*)mValue;
+			break;
+		case 2:
+			if (!mPlayer) return;
+			if (!iState || (iId < 1 || iId >= MAX_WEAPONS)) break;
+			mPlayer->current = iId;
+
+			
+			if (*(int*)mValue < mPlayer->weapons[iId].clip && // Only update the lastHit vector if the clip size is decreasing
+				*(int*)mValue != -1) // But not if it's a melee weapon
+			{
+				mPlayer->lastHit = mPlayer->lastTrace;
+			}
+			mPlayer->weapons[iId].clip = *(int*)mValue;
+	}
 }
 
 void Client_AmmoX(void* mValue)
 {
-
-  static int iAmmo;
-  switch (mState++){
-  case 0:
-    iAmmo = *(int*)mValue;
-    break;
-  case 1:
-  if (!mPlayer) return;
-    for(int i=1;i<MAX_WEAPONS;++i)
-    if (iAmmo == g_weaponsData[i].ammoSlot)
-        mPlayer->weapons[i].ammo = *(int*)mValue;
-  }
+	static int iAmmo;
+	
+	switch (mState++)
+	{
+		case 0:
+			iAmmo = *(int*)mValue;
+			break;
+		case 1:
+			if (!mPlayer) return;
+			for (int i = 1; i < MAX_WEAPONS; ++i)
+				if (iAmmo == g_weaponsData[i].ammoSlot)
+					mPlayer->weapons[i].ammo = *(int*)mValue;
+	}
 }
 
 void Client_AmmoPickup(void* mValue)
 {
-  static int iSlot;
-  switch (mState++){
-  case 0:
-    iSlot = *(int*)mValue;
-    break;
-  case 1:
-  if (!mPlayer) return;
-    for(int i=1;i<MAX_WEAPONS;++i)
-    if (g_weaponsData[i].ammoSlot==iSlot)
-        mPlayer->weapons[i].ammo += *(int*)mValue;
-  }
+	static int iSlot;
+	
+	switch (mState++)
+	{
+		case 0:
+			iSlot = *(int*)mValue;
+			break;
+		case 1:
+			if (!mPlayer) return;
+			for (int i = 1; i < MAX_WEAPONS; ++i)
+				if (g_weaponsData[i].ammoSlot==iSlot)
+					mPlayer->weapons[i].ammo += *(int*)mValue;
+	}
 }
 
 void Client_ScoreInfo(void* mValue)
 {
-  static int index;
-  static int deaths;
-  switch (mState++){
-  case 0:
-    index = *(int*)mValue;
-    break;
-  case 2:
-    deaths = *(int*)mValue;
-    break;
-  case 4:
-	if ( index < 1 || index > gpGlobals->maxClients ) break;
-    CPlayer*pPlayer = GET_PLAYER_POINTER_I( index );
-    pPlayer->deaths = deaths;
-    pPlayer->teamId = *(int*)mValue;
-    if ( g_teamsIds.isNewTeam() )
-      g_teamsIds.registerTeam( pPlayer->team.c_str() , pPlayer->teamId );
-  }
+	static int index;
+	static int deaths;
+
+	switch (mState++)
+	{
+		case 0:
+			index = *(int*)mValue;
+			break;
+		case 2:
+			deaths = *(int*)mValue;
+			break;
+		case 4:
+			if (index < 1 || index > gpGlobals->maxClients) break;
+			CPlayer*pPlayer = GET_PLAYER_POINTER_I(index);
+			pPlayer->deaths = deaths;
+			pPlayer->teamId = *(int*)mValue;
+			if (g_teamsIds.isNewTeam())
+				g_teamsIds.registerTeam(pPlayer->team.chars(), pPlayer->teamId);
+	}
 }
 
 void Client_DamageEnd(void* mValue)
 {
 	CPlayer* dead = mPlayer;
 
-	if ( dead && dead->death_killer )
+	if (dead && dead->death_killer)
 	{
-		g_events.parserInit( CS_DEATHMSG , &gpGlobals->time , mPlayer = 0, mPlayerIndex = 0 );
-		g_events.parseValue( dead->death_killer  );
-		g_events.parseValue( dead->index  );
-		g_events.parseValue( dead->death_headshot  );
-		g_events.parseValue( dead->death_weapon.c_str()  );
-		g_events.parseValue( dead->death_tk ? 1 : 0  );
+		g_events.parserInit(CS_DEATHMSG, &gpGlobals->time, mPlayer = 0, mPlayerIndex = 0);
+		g_events.parseValue(dead->death_killer);
+		g_events.parseValue(dead->index);
+		g_events.parseValue(dead->death_headshot);
+		g_events.parseValue(dead->death_weapon.chars());
+		g_events.parseValue(dead->death_tk ? 1 : 0);
 		g_events.executeEvents();
 		dead->death_killer = 0;
 	}
@@ -272,30 +325,47 @@ void Client_DeathMsg(void* mValue)
 	static int victim_id;
 	static int hs;
 	
-	switch (mState++){
-	case 0:
-		killer_id = *(int*)mValue;
-		killer = (killer_id > 0 && killer_id < 33) ? 
-			GET_PLAYER_POINTER_I(killer_id) : 0;
-		break;
-	case 1:
-		victim_id = *(int*)mValue;
-		victim = (victim_id > 0 && victim_id < 33) ? 
-			GET_PLAYER_POINTER_I(victim_id) : 0;
-		break;
-	case 2:	
-		hs = *(int*)mValue;
-		break;
-	case 3:
-		
-		if (  !killer || !victim ) break;
-
-		victim->death_killer = killer_id;
-		victim->death_weapon.assign((char*)mValue);
-		victim->death_headshot = hs;
-		victim->death_tk = (killer->teamId == victim->teamId);
+	switch (mState++)
+	{
+		case 0:
+			killer_id = *(int*)mValue;
+			killer = (killer_id > 0 && killer_id < 33) ? GET_PLAYER_POINTER_I(killer_id) : 0;
+			break;
+		case 1:
+			victim_id = *(int*)mValue;
+			victim = (victim_id > 0 && victim_id < 33) ? GET_PLAYER_POINTER_I(victim_id) : 0;
+			break;
+		case 2:	
+			hs = *(int*)mValue;
+			break;
+		case 3:
+			if (!killer || !victim) break;
+			victim->death_killer = killer_id;
+			victim->death_weapon = (char*)mValue;
+			victim->death_headshot = hs;
+			victim->death_tk = (killer->teamId == victim->teamId);
 	}
 }
+
+void Client_InitHUDEnd(void* mValue)
+{
+	if (!g_bmod_cstrike)
+		return;
+
+	CPlayer *pPlayer = mPlayer;
+
+	if (!pPlayer->teamIdsInitialized && !pPlayer->IsBot())
+	{
+		// This creates specific indexes (> maxplayers) for print_chat_color().
+		// 33 : print_team_grey / spectator
+		// 34 : print_team_red  / terrorist
+		// 35 : print_team_blue / ct
+		UTIL_TeamInfo(pPlayer->pEdict, 33 + 1, "TERRORIST"); // print_team_red
+		UTIL_TeamInfo(pPlayer->pEdict, 33 + 2, "CT");		 // print_team_blue
+		pPlayer->teamIdsInitialized = true;
+	}
+}
+
 /*
 void Client_SendAudio(void* mValue)
 {
@@ -323,4 +393,4 @@ void Client_ResetHUD(void* mValue)
 {
 
 }
-*/
+*/

amxmodx/fakemeta.h

@@ -1,229 +1,16 @@
-/* AMX Mod X
-*
-* by the AMX Mod X Development Team
-*
-*
-*  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*
-*  In addition, as a special exception, the author gives permission to
-*  link the code of this program with the Half-Life Game Engine ("HL
-*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*  L.L.C ("Valve"). You must obey the GNU General Public License in all
-*  respects for all of the code used other than the HL Engine and MODs
-*  from Valve. If you modify this file, you may extend this exception
-*  to your version of the file, but you are not obligated to do so. If
-*  you do not wish to do so, delete this exception statement from your
-*  version.
-*/
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
 
 #ifndef __FAKEMETA_H__
 #define __FAKEMETA_H__
 
-// Fake metamod api for modules
-
-#include "CList.h"
-
-// from mplugin.h (metamod)
-// Flags to indicate current "load" state of plugin.
-// NOTE: order is important, as greater/less comparisons are made.
-typedef enum {
-	PL_EMPTY = 0,		// empty slot
-	PL_VALID,			// has valid info in it
-	PL_BADFILE,			// nonexistent file (open failed), 
-						//    or not a valid plugin file (query failed)
-	PL_OPENED,			// dlopened and queried
-	PL_FAILED,			// opened, but failed to attach or unattach
-	PL_RUNNING,			// attached and running
-	PL_PAUSED,			// attached but paused
-} PLUG_STATUS;
-
-// from h_export.h (metamod)
-// Our GiveFnptrsToDll, called by engine.
-typedef void (WINAPI *GIVE_ENGINE_FUNCTIONS_FN) (enginefuncs_t 
-		*pengfuncsFromEngine, globalvars_t *pGlobals);
-
-
-// *** CFakeMeta
-class CFakeMeta
-{
-private:
-	// Core tables
-	/* DLL_FUNCTIONS m_CoreDllFuncTable;
-	enginefuncs_t m_CoreEngineFuncTable;
-	NEW_DLL_FUNCTIONS m_CoreNewDllFuncTable;
-
-	DLL_FUNCTIONS m_CoreDllFuncTable_Post;
-	enginefuncs_t m_CoreEngineFuncTable_Post;
-	NEW_DLL_FUNCTIONS m_CoreNewDllFuncTable_Post; */
-
-	bool AddCorePlugin();	// Adds the core plugin if needed
-public:
-	class CFakeMetaPlugin
-	{
-	private:
-		// plugin info
-		String m_Path;
-		PLUG_STATUS m_Status;
-		plugin_info_t *m_Info;
-		// Function tables
-		META_FUNCTIONS m_MetaFuncTable;
-
-		DLL_FUNCTIONS m_DllFuncTable;
-		enginefuncs_t m_EngineFuncTable;
-		NEW_DLL_FUNCTIONS m_NewDllFuncTable;
-
-		DLL_FUNCTIONS m_DllFuncTable_Post;
-		enginefuncs_t m_EngineFuncTable_Post;
-		NEW_DLL_FUNCTIONS m_NewDllFuncTable_Post;
-
-		// OS dep handle
-		DLHANDLE m_Handle;
-	public:
-		inline PLUG_STATUS GetStatus() const
-		{ return m_Status; }
-		inline void SetStatus(PLUG_STATUS newStatus)
-		{ m_Status = newStatus; }
-
-
-		inline plugin_info_t * GetInfo()
-		{ return m_Info; }
-		inline const plugin_info_t * GetInfo() const
-		{ return m_Info; }
-		inline void SetInfo(plugin_info_t *newInfo)
-		{ m_Info = newInfo; }
-
-		inline const char * GetPath() 
-		{ return m_Path.c_str(); }
-
-		inline const META_FUNCTIONS &GetMetaFunctions() const
-		{ return m_MetaFuncTable; }
-
-		// Get
-		inline DLL_FUNCTIONS &GetDllFuncTable()
-		{ return m_DllFuncTable; }
-		inline enginefuncs_t &GetEngineFuncTable()
-		{ return m_EngineFuncTable; }
-		inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable()
-		{ return m_NewDllFuncTable; }
-		
-		// Get const
-		inline const DLL_FUNCTIONS &GetDllFuncTable() const
-		{ return m_DllFuncTable; }
-		inline const enginefuncs_t &GetEngineFuncTable() const
-		{ return m_EngineFuncTable; }
-		inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable() const
-		{ return m_NewDllFuncTable; }
-
-		// Get post
-		inline DLL_FUNCTIONS &GetDllFuncTable_Post()
-		{ return m_DllFuncTable_Post; }
-		inline enginefuncs_t &GetEngineFuncTable_Post()
-		{ return m_EngineFuncTable_Post; }
-		inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post()
-		{ return m_NewDllFuncTable_Post; }
-
-		// Get post const
-		inline const DLL_FUNCTIONS &GetDllFuncTable_Post() const
-		{ return m_DllFuncTable_Post; }
-		inline const enginefuncs_t &GetEngineFuncTable_Post() const
-		{ return m_EngineFuncTable_Post; }
-		inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post() const
-		{ return m_NewDllFuncTable_Post; }
-
-		int Query(mutil_funcs_t *pMetaUtilFuncs);	// Also calls GiveFnPtrsToDll
-		int Attach(PLUG_LOADTIME now, meta_globals_t *pMGlobals, gamedll_funcs_t *pGameDllFuncs);
-		int Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
-
-		int GetEntityAPI2(int interfaceVersion);
-		int GetEntityAPI2_Post(int interfaceVersion);
-		int GetEngineFunctions(int interfaceVersion);
-		int GetEngineFunctions_Post(int interfaceVersion);
-		int GetNewDLLFunctions(int interfaceVersion);
-		int GetNewDLLFunctions_Post(int interfaceVersion);
-
-		CFakeMetaPlugin(const char *path);
-		~CFakeMetaPlugin();
-	};	// CFakeMetaPlugin
-
-	CFakeMeta();
-	~CFakeMeta();
-
-	bool AddPlugin(const char *path /*path relative to moddir*/);
-	void ReleasePlugins();
-
-	// This is public because i don't want to declare all the functions as friends :)
-	// :NOTE: The core is now a special, first plugin!
-	CList<CFakeMetaPlugin> m_Plugins;
-
-	// ****** Meta functions ******
-	// Query all added plugins
-	void Meta_Query(mutil_funcs_t *pMetaUtilFuncs);
-	// Attach all added plugins
-	void Meta_Attach(PLUG_LOADTIME now, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs);
-	// Detach all added plugins
-	void Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
-	// :NOTE: Meta_Init currently not supported
-	int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable /*from metamod*/, int *interfaceVersion /*from metamod*/,
-		DLL_FUNCTIONS *pAMXXFunctionTable /*Functions amxx needs*/);
-	int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable /*from metamod*/, int *interfaceVersion /*from metamod*/,
-		DLL_FUNCTIONS *pAMXXFunctionTable /*Functions amxx needs*/);
-	int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion,
-		enginefuncs_t *pAMXXFunctionTable /*Fucntions amxx needs*/);
-	int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion,
-		enginefuncs_t *pAMXXFunctionTable /*Fucntions amxx needs*/);
-	int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion,
-		NEW_DLL_FUNCTIONS *pAMXXFunctionTable);
-	int GetNewDLLFunctions_Post(NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion,
-		NEW_DLL_FUNCTIONS *pAMXXFunctionTable);
-
-	// Get
-	/*inline DLL_FUNCTIONS &GetDllFuncTable()
-	{ return m_CoreDllFuncTable; }
-	inline enginefuncs_t &GetEngineFuncTable()
-	{ return m_CoreEngineFuncTable; }
-	inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable()
-	{ return m_CoreNewDllFuncTable; }
-	
-	// Get const
-	inline const DLL_FUNCTIONS &GetDllFuncTable() const
-	{ return m_CoreDllFuncTable; }
-	inline const enginefuncs_t &GetEngineFuncTable() const
-	{ return m_CoreEngineFuncTable; }
-	inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable() const
-	{ return m_CoreNewDllFuncTable; }
-
-	// Get post
-	inline DLL_FUNCTIONS &GetDllFuncTable_Post()
-	{ return m_CoreDllFuncTable_Post; }
-	inline enginefuncs_t &GetEngineFuncTable_Post()
-	{ return m_CoreEngineFuncTable_Post; }
-	inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post()
-	{ return m_CoreNewDllFuncTable_Post; }
-
-	// Get post const
-	inline const DLL_FUNCTIONS &GetDllFuncTable_Post() const
-	{ return m_CoreDllFuncTable_Post; }
-	inline const enginefuncs_t &GetEngineFuncTable_Post() const
-	{ return m_CoreEngineFuncTable_Post; }
-	inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post() const
-	{ return m_CoreNewDllFuncTable_Post; } */
-};	// CFakeMeta
-
-// Fake Metamod
-// defined in meta_api.cpp
-extern CFakeMeta g_FakeMeta;
+int UnloadMetamodPlugin(void *handle);
+int LoadMetamodPlugin(const char *path, void **handle, PLUG_LOADTIME now);
 
 #endif // #ifndef __FAKEMETA_H__
-

amxmodx/float.cpp

@@ -20,7 +20,7 @@
 #include <stdlib.h>     /* for atof() */
 #include <stdio.h>      /* for NULL */
 #include <assert.h>
-#include <math.h>
+#include <cmath>
 
 // this file does not include amxmodx.h, so we have to include the memory manager here
 #ifdef MEMORY_TEST
@@ -96,7 +96,7 @@ static cell AMX_NATIVE_CALL n_floatstr(AMX *amx,cell *params)
         return 0;
 
     /* Now convert the Small String into a C type null terminated string */
-    amx_GetString(szSource, pString, 0);
+    amx_GetStringOld(szSource, pString, 0);
 
     /* Now convert this to a float. */
     fNum = (REAL)atof(szSource);
@@ -368,7 +368,6 @@ static cell AMX_NATIVE_CALL n_floatatan(AMX *amx, cell *params)
 	 * params[2] = radix
 	 */
 	REAL fA = amx_ctof(params[1]);
-	fA = ToRadians(fA, params[2]);
 	fA = atan(fA);
 	fA = FromRadians(fA, params[2]);
 	return amx_ftoc(fA);
@@ -425,6 +424,54 @@ static cell AMX_NATIVE_CALL n_floatatan2(AMX *amx, cell *params)
 	return amx_ftoc(fC);
 }
 
+#if defined __BORLANDC__ || defined __WATCOMC__
+  #pragma argsused
+#endif
+/* Added by DS */
+static cell AMX_NATIVE_CALL n_floatsinh(AMX *amx, cell *params)
+{
+	/*
+	 * params[1] = angle
+	 * params[2] = radix
+	 */
+	REAL fA = amx_ctof(params[1]);
+	fA = ToRadians(fA, params[2]);
+	fA = sinh(fA);
+	return amx_ftoc(fA);
+}
+
+#if defined __BORLANDC__ || defined __WATCOMC__
+  #pragma argsused
+#endif
+/* Added by DS */
+static cell AMX_NATIVE_CALL n_floatcosh(AMX *amx, cell *params)
+{
+	/*
+	 * params[1] = angle
+	 * params[2] = radix
+	 */
+	REAL fA = amx_ctof(params[1]);
+	fA = ToRadians(fA, params[2]);
+	fA = cosh(fA);
+	return amx_ftoc(fA);
+}
+
+#if defined __BORLANDC__ || defined __WATCOMC__
+  #pragma argsused
+#endif
+/* Added by DS */
+static cell AMX_NATIVE_CALL n_floattanh(AMX *amx, cell *params)
+{
+	/*
+	 * params[1] = angle
+	 * params[2] = radix
+	 */
+	REAL fA = amx_ctof(params[1]);
+	fA = ToRadians(fA, params[2]);
+	fA = tanh(fA);
+	return amx_ftoc(fA);
+}
+
 #if defined __BORLANDC__ || defined __WATCOMC__
   #pragma argsused
 #endif
@@ -457,6 +504,9 @@ AMX_NATIVE_INFO float_Natives[] = {
   { "floatacos",   n_floatacos  },
   { "floatatan",   n_floatatan  },
   { "floatatan2",  n_floatatan2 },
+  { "floatsinh",   n_floatsinh  },
+  { "floatcosh",   n_floatcosh  },
+  { "floattanh",   n_floattanh  },
   { NULL, NULL }        /* terminator */
 };
 

amxmodx/format.cpp

@@ -0,0 +1,828 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "amxmodx.h"
+#include "format.h"
+#include "datastructs.h"
+
+//Adapted from Quake3's vsprintf
+// thanks to cybermind for linking me to this :)
+//I made the following changes:
+// - Fixed spacing to be AMX Mod X standard
+// - Added 'n' support, no buffer overflows
+// - Templatized input/output buffers
+
+#define ALT			0x00000001		/* alternate form */
+#define HEXPREFIX	0x00000002		/* add 0x or 0X prefix */
+#define LADJUST		0x00000004		/* left adjustment */
+#define LONGDBL		0x00000008		/* long double */
+#define LONGINT		0x00000010		/* long integer */
+#define QUADINT		0x00000020		/* quad integer */
+#define SHORTINT	0x00000040		/* short integer */
+#define ZEROPAD		0x00000080		/* zero (as opposed to blank) pad */
+#define FPT			0x00000100		/* floating point number */
+#define UPPERDIGITS	0x00000200		/* make alpha digits uppercase */
+#define to_digit(c)		((c) - '0')
+#define is_digit(c)		((unsigned)to_digit(c) <= 9)
+#define to_char(n)		((n) + '0')
+#define CHECK_ARGS(n) \
+	if ((arg+n) > args) { \
+		LogError(amx, AMX_ERR_PARAMS, "String formatted incorrectly - parameter %d (total %d)", arg, args); \
+		return 0; \
+	}
+
+template size_t atcprintf<cell, cell>(cell *, size_t, const cell *, AMX *, cell *, int *);
+template size_t atcprintf<char, cell>(char *, size_t, const cell *, AMX *, cell *, int *);
+template size_t atcprintf<cell, char>(cell *, size_t, const char *, AMX *, cell *, int *);
+template size_t atcprintf<char, char>(char *, size_t, const char *, AMX *, cell *, int *);
+
+THash<ke::AString, lang_err> BadLang_Table;
+
+static cvar_t *amx_mldebug = nullptr;
+static cvar_t *amx_cl_langs = nullptr;
+
+const char *playerlang(const cell index)
+{
+	const char *pLangName = nullptr;
+
+	if (index == LANG_PLAYER)
+	{
+		if (!amx_cl_langs)
+		{
+			amx_cl_langs = CVAR_GET_POINTER("amx_client_languages");
+		}
+
+		if (static_cast<int>(amx_cl_langs->value) == 0)
+		{
+			pLangName = amxmodx_language->string;
+		}
+		else
+		{
+			pLangName = ENTITY_KEYVALUE(GET_PLAYER_POINTER_I(g_langMngr.GetDefLang())->pEdict, "lang");
+		}
+	}
+	else if (index == LANG_SERVER)
+	{
+		pLangName = amxmodx_language->string;
+	}
+	else if (index >= 1 && index <= gpGlobals->maxClients)
+	{
+		if (!amx_cl_langs)
+		{
+			amx_cl_langs = CVAR_GET_POINTER("amx_client_languages");
+		}
+
+		if (static_cast<int>(amx_cl_langs->value) == 0)
+		{
+			pLangName = amxmodx_language->string;
+		}
+		else
+		{
+			pLangName = ENTITY_KEYVALUE(GET_PLAYER_POINTER_I(index)->pEdict, "lang");
+		}
+	}
+
+	return pLangName;
+}
+
+const char *translate(AMX *amx, const char *lang, const char *key)
+{
+	auto pLangName = lang;
+	int status;
+
+	if (!pLangName || !isalpha(pLangName[0]))
+	{
+		pLangName = amxmodx_language->string;
+	}
+
+	auto def = g_langMngr.GetDef(pLangName, key, status);
+
+	if (!amx_mldebug)
+	{
+		amx_mldebug = CVAR_GET_POINTER("amx_mldebug");
+	}
+
+	auto debug = (amx_mldebug && amx_mldebug->string && (amx_mldebug->string[0] != '\0'));
+
+	if (debug)
+	{
+		int debug_status;
+		auto validlang = true;
+		auto testlang = amx_mldebug->string;
+
+		if (!g_langMngr.LangExists(testlang))
+		{
+			AMXXLOG_Error("[AMXX] \"%s\" is an invalid debug language", testlang);
+			validlang = false;
+		}
+
+		g_langMngr.GetDef(testlang, key, debug_status);
+
+		if (validlang && debug_status == ERR_BADKEY)
+		{
+			AMXXLOG_Error("[AMXX] Language key \"%s\" not found for language \"%s\", check \"%s\"", key, testlang, GetFileName(amx));
+		}
+	}
+
+	if (!def)
+	{
+		if (debug && status == ERR_BADLANG)
+		{
+			ke::AString langName(pLangName);
+
+			auto &err = BadLang_Table.AltFindOrInsert(ke::Move(langName));
+
+			if (err.last + 120.0f < gpGlobals->time)
+			{
+				AMXXLOG_Error("[AMXX] Language \"%s\" not found", pLangName);
+				err.last = gpGlobals->time;
+			}
+		}
+
+		if (strcmp(pLangName, amxmodx_language->string) != 0)
+		{
+			def = g_langMngr.GetDef(amxmodx_language->string, key, status);
+		}
+
+		if (!def && (strcmp(pLangName, "en") != 0 && strcmp(amxmodx_language->string, "en") != 0))
+		{
+			def = g_langMngr.GetDef("en", key, status);
+		}
+	}
+
+	return def;
+}
+
+template <typename U, typename S>
+void AddString(U **buf_p, size_t &maxlen, const S *string, int width, int prec)
+{
+	int		size = 0;
+	U		*buf;
+	static S nlstr[] = {'(','n','u','l','l',')','\0'};
+
+	buf = *buf_p;
+
+	if (string == NULL)
+	{
+		string = nlstr;
+		prec = -1;
+	}
+
+	if (prec >= 0)
+	{
+		for (size = 0; size < prec; size++) 
+		{
+			if (string[size] == '\0')
+				break;
+		}
+	} else {
+		while (string[size++]) ;
+		size--;
+	}
+
+	if (size > (int)maxlen)
+		size = maxlen;
+
+	/* If precision is provided, make sure we don't truncate a multi-byte character */
+	if (prec >= size && (string[size - 1] & 1 << 7))
+	{
+		size -= UTIL_CheckValidChar((cell *)string + size - 1);
+	}
+
+	maxlen -= size;
+	width -= size;
+
+	while (size--)
+		*buf++ = static_cast<U>(*string++);
+
+	while (width-- > 0 && maxlen)
+	{
+		*buf++ = ' ';
+		maxlen--;
+	}
+
+	*buf_p = buf;
+}
+
+template <typename U>
+void AddFloat(U **buf_p, size_t &maxlen, double fval, int width, int prec, int flags)
+{
+	int digits;				// non-fraction part digits
+	double tmp;				// temporary
+	U *buf = *buf_p;			// output buffer pointer
+	int val;				// temporary
+	int sign = 0;				// 0: positive, 1: negative
+	int fieldlength;			// for padding
+	int significant_digits = 0;		// number of significant digits written
+	const int MAX_SIGNIFICANT_DIGITS = 16;
+
+	// default precision
+	if (prec < 0)
+	{
+		prec = 6;
+	}
+
+	// get the sign
+	if (fval < 0)
+	{
+		fval = -fval;
+		sign = 1;
+	}
+
+	// compute whole-part digits count
+	digits = (int)log10(fval) + 1;
+
+	// Only print 0.something if 0 < fval < 1
+	if (digits < 1)
+	{
+		digits = 1;
+	}
+
+	// compute the field length
+	fieldlength = digits + prec + ((prec > 0) ? 1 : 0) + sign;
+
+	// minus sign BEFORE left padding if padding with zeros
+	if (sign && maxlen && (flags & ZEROPAD))
+	{
+		*buf++ = '-';
+		maxlen--;
+	}
+
+	// right justify if required
+	if ((flags & LADJUST) == 0)
+	{
+		while ((fieldlength < width) && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	// minus sign AFTER left padding if padding with spaces
+	if (sign && maxlen && !(flags & ZEROPAD))
+	{
+		*buf++ = '-';
+		maxlen--;
+	}
+
+	// write the whole part
+	tmp = pow(10.0, digits-1);
+	while ((digits--) && maxlen)
+	{
+		if (++significant_digits > MAX_SIGNIFICANT_DIGITS)
+		{
+			*buf++ = '0';
+		}
+		else
+		{
+			val = (int)(fval / tmp);
+			*buf++ = '0' + val;
+			fval -= val * tmp;
+			tmp *= 0.1;
+		}
+		maxlen--;
+	}
+
+	// write the fraction part
+	if (maxlen && prec)
+	{
+		*buf++ = '.';
+		maxlen--;
+	}
+
+	tmp = pow(10.0, prec);
+
+	fval *= tmp;
+	while (prec-- && maxlen)
+	{
+		if (++significant_digits > MAX_SIGNIFICANT_DIGITS)
+		{
+			*buf++ = '0';
+		}
+		else
+		{
+			tmp *= 0.1;
+			val = (int)(fval / tmp);
+			*buf++ = '0' + val;
+			fval -= val * tmp;
+		}
+		maxlen--;
+	}
+
+	// left justify if required
+	if (flags & LADJUST)
+	{
+		while ((fieldlength < width) && maxlen)
+		{
+			// right-padding only with spaces, ZEROPAD is ignored
+			*buf++ = ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	// update parent's buffer pointer
+	*buf_p = buf;
+}
+
+template <typename U>
+void AddBinary(U **buf_p, size_t &maxlen, unsigned int val, int width, int flags)
+{
+	char text[32];
+	int digits;
+	U *buf;
+
+	digits = 0;
+	do
+	{
+		if (val & 1)
+		{
+			text[digits++] = '1';
+		}
+		else
+		{
+			text[digits++] = '0';
+		}
+		val >>= 1;
+	} while (val);
+
+	buf = *buf_p;
+
+	if (!(flags & LADJUST))
+	{
+		while (digits < width && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	while (digits-- && maxlen)
+	{
+		*buf++ = text[digits];
+		width--;
+		maxlen--;
+	}
+
+	if (flags & LADJUST)
+	{
+		while (width-- && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			maxlen--;
+		}
+	}
+
+	*buf_p = buf;
+}
+
+template <typename U>
+void AddUInt(U **buf_p, size_t &maxlen, unsigned int val, int width, int flags)
+{
+	U		text[32];
+	int		digits;
+	U		*buf;
+
+	digits = 0;
+	do {
+		text[digits++] = '0' + val % 10;
+		val /= 10;
+	} while (val);
+
+	buf = *buf_p;
+
+	if( !(flags & LADJUST) )
+	{
+		while (digits < width && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	while (digits-- && maxlen)
+	{
+		*buf++ = text[digits];
+		width--;
+		maxlen--;
+	}
+
+	if (flags & LADJUST)
+	{
+		while (width-- && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			maxlen--;
+		}
+	}
+
+	*buf_p = buf;
+}
+
+template <typename U>
+void AddInt(U **buf_p, size_t &maxlen, int val, int width, int flags)
+{
+	U		text[32];
+	int		digits;
+	int		signedVal;
+	U		*buf;
+	unsigned int unsignedVal;
+
+	digits = 0;
+	signedVal = val;
+	if (val < 0)
+	{
+		/* we want the unsigned version */
+		unsignedVal = abs(val);
+	} else {
+		unsignedVal = val;
+	}
+	do {
+		text[digits++] = '0' + unsignedVal % 10;
+		unsignedVal /= 10;
+	} while (unsignedVal);
+
+	if (signedVal < 0)
+		text[digits++] = '-';
+
+	buf = *buf_p;
+
+	if( !(flags & LADJUST) )
+	{
+		while (digits < width && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	while (digits-- && maxlen)
+	{
+		*buf++ = text[digits];
+		width--;
+		maxlen--;
+	}
+
+	if (flags & LADJUST)
+	{
+		while (width-- && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			maxlen--;
+		}
+	}
+
+	*buf_p = buf;
+}
+
+template <typename U>
+void AddHex(U **buf_p, size_t &maxlen, unsigned int val, int width, int flags)
+{
+	U		text[32];
+	int		digits;
+	U		*buf;
+	U		digit;
+	int		hexadjust;
+
+	if (flags & UPPERDIGITS)
+	{
+		hexadjust = 'A' - '9' - 1;
+	} else {
+		hexadjust = 'a' - '9' - 1;
+	}
+
+	digits = 0;
+	do
+	{
+		digit = ('0' + val % 16);
+		if (digit > '9')
+		{
+			digit += hexadjust;
+		}
+
+		text[digits++] = digit;
+		val /= 16;
+	} while (val);
+
+	buf = *buf_p;
+
+	if( !(flags & LADJUST) )
+	{
+		while (digits < width && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	while (digits-- && maxlen)
+	{
+		*buf++ = text[digits];
+		width--;
+		maxlen--;
+	}
+
+	if (flags & LADJUST)
+	{
+		while (width-- && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			maxlen--;
+		}
+	}
+
+	*buf_p = buf;
+}
+
+template <typename D, typename S>
+size_t atcprintf(D *buffer, size_t maxlen, const S *format, AMX *amx, cell *params, int *param)
+{
+	int		arg;
+	int		args = params[0] / sizeof(cell);
+	D		*buf_p;
+	D		ch;
+	int		flags;
+	int		width;
+	int		prec;
+	int		n;
+	//char	sign;
+	const S	*fmt;
+	size_t	llen = maxlen;
+
+	buf_p = buffer;
+	arg = *param;
+	fmt = format;
+
+	while (true)
+	{
+		// run through the format string until we hit a '%' or '\0'
+		for (ch = static_cast<D>(*fmt); 
+			llen && ((ch = static_cast<D>(*fmt)) != '\0' && ch != '%');
+			fmt++)
+		{
+			*buf_p++ = static_cast<D>(ch);
+			llen--;
+		}
+		if (ch == '\0' || llen <= 0)
+			goto done;
+
+		// skip over the '%'
+		fmt++;
+
+		// reset formatting state
+		flags = 0;
+		width = 0;
+		prec = -1;
+		//sign = '\0';
+
+rflag:
+		ch = static_cast<D>(*fmt++);
+reswitch:
+		switch(ch)
+		{
+		case '-':
+			flags |= LADJUST;
+			goto rflag;
+		case '.':
+			n = 0;
+			while( is_digit( ( ch = static_cast<D>(*fmt++)) ) )
+				n = 10 * n + ( ch - '0' );
+			prec = n < 0 ? -1 : n;
+			goto reswitch;
+		case '0':
+			flags |= ZEROPAD;
+			goto rflag;
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			n = 0;
+			do {
+				n = 10 * n + ( ch - '0' );
+				ch = static_cast<D>(*fmt++);
+			} while( is_digit( ch ) );
+			width = n;
+			goto reswitch;
+		case 'c':
+			CHECK_ARGS(0);
+			*buf_p++ = static_cast<D>(*get_amxaddr(amx, params[arg]));
+			llen--;
+			arg++;
+			break;
+		case 'b':
+			CHECK_ARGS(0);
+			AddBinary(&buf_p, llen, *get_amxaddr(amx, params[arg]), width, flags);
+			arg++;
+			break;
+		case 'd':
+		case 'i':
+			CHECK_ARGS(0);
+			AddInt(&buf_p, llen, *get_amxaddr(amx, params[arg]), width, flags);
+			arg++;
+			break;
+		case 'u':
+			CHECK_ARGS(0);
+			AddUInt(&buf_p, llen, static_cast<unsigned int>(*get_amxaddr(amx, params[arg])), width, flags);
+			arg++;
+			break;
+		case 'f':
+			CHECK_ARGS(0);
+			AddFloat(&buf_p, llen, amx_ctof(*get_amxaddr(amx, params[arg])), width, prec, flags);
+			arg++;
+			break;
+		case 'X':
+			CHECK_ARGS(0);
+			flags |= UPPERDIGITS;
+			AddHex(&buf_p, llen, static_cast<unsigned int>(*get_amxaddr(amx, params[arg])), width, flags);
+			arg++;
+			break;
+		case 'x':
+			CHECK_ARGS(0);
+			AddHex(&buf_p, llen, static_cast<unsigned int>(*get_amxaddr(amx, params[arg])), width, flags);
+			arg++;
+			break;
+		case 'a':
+			{
+				CHECK_ARGS(0);
+				// %a is passed a pointer directly to a cell string.
+				cell* ptr=reinterpret_cast<cell*>(*get_amxaddr(amx, params[arg]));
+				if (!ptr)
+				{
+					LogError(amx, AMX_ERR_NATIVE, "Invalid vector string handle provided (%d)", *get_amxaddr(amx, params[arg]));
+					return 0;
+				}
+
+				AddString(&buf_p, llen, ptr, width, prec);
+				arg++;
+				break;
+			}
+		case 's':
+			CHECK_ARGS(0);
+			AddString(&buf_p, llen, get_amxaddr(amx, params[arg]), width, prec);
+			arg++;
+			break;
+		case 'L':
+		case 'l':
+			{
+				const char *lang;
+				int len;
+				if (ch == 'L')
+				{
+					CHECK_ARGS(1);
+					auto currParam = params[arg++];
+					lang = playerlang(*get_amxaddr(amx, currParam));
+					if (!lang)
+						lang = get_amxstring(amx, currParam, 2, len);
+				}
+				else
+				{
+					CHECK_ARGS(0);
+					lang = playerlang(g_langMngr.GetDefLang());
+				}
+				const char *key = get_amxstring(amx, params[arg++], 3, len);
+				const char *def = translate(amx, lang, key);
+				if (!def)
+				{
+					static char buf[255];
+					ke::SafeSprintf(buf, sizeof(buf), "ML_NOTFOUND: %s", key);
+					def = buf;
+				}
+				size_t written = atcprintf(buf_p, llen, def, amx, params, &arg);
+				buf_p += written;
+				llen -= written;
+				break;
+			}
+		case 'N':
+			{
+				CHECK_ARGS(0);
+				cell *addr = get_amxaddr(amx, params[arg]);
+				char buffer[255];
+				if (*addr)
+				{
+					CPlayer *player = NULL;
+
+					if (*addr >= 1 && *addr <= gpGlobals->maxClients)
+					{
+						player = GET_PLAYER_POINTER_I(*addr);
+					}
+
+					if (!player || !player->initialized)
+					{
+						LogError(amx, AMX_ERR_NATIVE, "Client index %d is invalid", *addr);
+						return 0;
+					}
+
+					const char *auth = GETPLAYERAUTHID(player->pEdict);
+					if (!auth || auth[0] == '\0')
+					{
+						auth = "STEAM_ID_PENDING";
+					}
+
+					int userid = GETPLAYERUSERID(player->pEdict);
+					ke::SafeSprintf(buffer, sizeof(buffer), "%s<%d><%s><%s>", player->name.chars(), userid, auth, player->team.chars());
+				}
+				else
+				{
+					ke::SafeSprintf(buffer, sizeof(buffer), "Console<0><Console><Console>");
+				}
+
+				AddString(&buf_p, llen, buffer, width, prec);
+				arg++;
+				break;
+			}
+		case 'n':
+			{
+				CHECK_ARGS(0);
+				cell *addr = get_amxaddr(amx, params[arg]);
+				const char *name = "Console";
+
+				if (*addr)
+				{
+					CPlayer *player = NULL;
+
+					if (*addr >= 1 && *addr <= gpGlobals->maxClients)
+					{
+						player = GET_PLAYER_POINTER_I(*addr);
+					}
+
+					if (!player || !player->initialized)
+					{
+						LogError(amx, AMX_ERR_NATIVE, "Client index %d is invalid", *addr);
+						return 0;
+					}
+
+					name = player->name.chars();
+				}
+			
+				AddString(&buf_p, llen, name, width, prec);
+				arg++;
+				break;
+			}
+		case '%':
+			*buf_p++ = static_cast<D>(ch);
+			if (!llen)
+				goto done;
+			llen--;
+			break;
+		case '\0':
+			*buf_p++ = static_cast<D>('%');
+			if (!llen)
+				goto done;
+			llen--;
+			goto done;
+			break;
+		default:
+			*buf_p++ = static_cast<D>(ch);
+			if (!llen)
+				goto done;
+			llen--;
+			break;
+		}
+	}
+
+done:
+	*buf_p = static_cast<D>(0);
+	*param = arg;
+
+	/* if max buffer length consumed, make sure we don't truncate a multi-byte character */
+	if (llen <= 0 && *(buf_p - 1) & 1 << 7)
+	{
+		llen += UTIL_CheckValidChar(buf_p - 1);
+		*(buf_p - llen) = static_cast<D>(0);
+	}
+
+	return maxlen-llen;
+}
+
+/**
+ * HACKHACK: The compiler will generate code for each case we need.
+ * Don't remove this, otherwise files that use certain code generations
+ *  will have extern problems.  For each case you need, add dummy code
+ *  here.
+ */
+void __WHOA_DONT_CALL_ME_PLZ_K_lol_o_O()
+{
+	//acsprintf
+	atcprintf((cell *)NULL, 0, (const char *)NULL, NULL, NULL, NULL);
+	//accprintf
+	atcprintf((cell *)NULL, 0, (cell *)NULL, NULL, NULL, NULL);
+	//ascprintf
+	atcprintf((char *)NULL, 0, (cell *)NULL, NULL, NULL, NULL);
+}
+

amxmodx/format.h

@@ -0,0 +1,20 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef _INCLUDE_FORMATTING_H
+#define _INCLUDE_FORMATTING_H
+
+//Amx Templatized Cell Printf
+template <typename D, typename S>
+size_t atcprintf(D *buffer, size_t maxlen, const S *format, AMX *amx, cell *params, int *param);
+
+const char *playerlang(const cell index);
+const char *translate(AMX *amx, const char *lang, const char *key);
+
+#endif //_INCLUDE_FORMATTING_H

amxmodx/gameconfigs.cpp

@@ -0,0 +1,175 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "gameconfigs.h"
+#include "amxmodx.h"
+#include "CGameConfigs.h"
+
+NativeHandle<GameConfigNative> GameConfigHandle;
+
+// native GameConfig:LoadGameConfigFile(const file[]);
+static cell AMX_NATIVE_CALL LoadGameConfigFile(AMX *amx, cell *params)
+{
+	int length;
+	const char *filename = get_amxstring(amx, params[1], 0, length);
+
+	IGameConfig *config = nullptr;
+	char error[128];
+
+	if (!ConfigManager.LoadGameConfigFile(filename, &config, error, sizeof(error)))
+	{
+		ConfigManager.CloseGameConfigFile(config);
+		LogError(amx, AMX_ERR_NATIVE, "Unable to open %s: %s", filename, error);
+		return 0;
+	}
+
+	int handle = GameConfigHandle.create();
+
+	auto configHandle = GameConfigHandle.lookup(handle);
+
+	if (!configHandle)
+	{
+		return 0;
+	}
+
+	configHandle->m_config = config;
+
+	return handle;
+}
+
+// native GameConfGetOffset(GameConfig:handle, const key[]);
+static cell AMX_NATIVE_CALL GameConfGetOffset(AMX *amx, cell *params)
+{
+	GameConfigNative *handle = GameConfigHandle.lookup(params[1]);
+
+	if (!handle)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid game config handle %d", params[1]);
+		return 0;
+	}
+
+	int length;
+	TypeDescription value;
+
+	const char *key = get_amxstring(amx, params[2], 0, length);
+
+	if (!handle->m_config->GetOffset(key, &value))
+	{
+		return -1;
+	}
+
+	return value.fieldOffset;
+}
+
+// native GameConfGetClassOffset(GameConfig:handle, const classname[], const key[]);
+static cell AMX_NATIVE_CALL GameConfGetClassOffset(AMX *amx, cell *params)
+{
+	GameConfigNative *handle = GameConfigHandle.lookup(params[1]);
+
+	if (!handle)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid game config handle %d", params[1]);
+		return 0;
+	}
+
+	int length;
+	TypeDescription value;
+
+	const char *classname = get_amxstring(amx, params[2], 0, length);
+	const char *key = get_amxstring(amx, params[3], 1, length);
+
+	if (!handle->m_config->GetOffsetByClass(classname, key, &value))
+	{
+		return -1;
+	}
+
+	return value.fieldOffset;
+}
+
+// native bool:GameConfGetKeyValue(GameConfig:handle, const key[], buffer[], maxlen);
+static cell AMX_NATIVE_CALL GameConfGetKeyValue(AMX *amx, cell *params)
+{
+	GameConfigNative *handle = GameConfigHandle.lookup(params[1]);
+
+	if (!handle)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid game config handle %d", params[1]);
+		return 0;
+	}
+
+	int length;
+	const char *value;
+	const char *key = get_amxstring(amx, params[2], 0, length);
+
+	if (!(value = handle->m_config->GetKeyValue(key)))
+	{
+		return 0;
+	}
+
+	set_amxstring_utf8(amx, params[3], value, strlen(value), params[4]);
+
+	return 1;
+}
+
+// native GameConfGetAddress(GameConfig:handle, const name[]);
+static cell AMX_NATIVE_CALL GameConfGetAddress(AMX *amx, cell *params)
+{
+	GameConfigNative *handle = GameConfigHandle.lookup(params[1]);
+
+	if (!handle)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid game config handle %d", params[1]);
+		return 0;
+	}
+
+	int length;
+	void *value;
+
+	const char *key = get_amxstring(amx, params[2], 0, length);
+
+	if (!handle->m_config->GetAddress(key, &value))
+	{
+		return 0;
+	}
+
+	return reinterpret_cast<cell>(value);
+}
+
+// native CloseGameConfigFile(&GameConfig:handle);
+static cell AMX_NATIVE_CALL CloseGameConfigFile(AMX *amx, cell *params)
+{
+	cell *address = get_amxaddr(amx, params[1]);
+
+	GameConfigNative *handle = GameConfigHandle.lookup(*address);
+
+	if (!handle)
+	{
+		return 0;
+	}
+
+	if (GameConfigHandle.destroy(*address))
+	{
+		*address = 0;
+		return 1;
+	}
+
+	return 0;
+}
+
+
+AMX_NATIVE_INFO g_GameConfigNatives[] = 
+{
+	{ "LoadGameConfigFile"    , LoadGameConfigFile     },
+	{ "GameConfGetOffset"     , GameConfGetOffset      },
+	{ "GameConfGetClassOffset", GameConfGetClassOffset },
+	{ "GameConfGetKeyValue"   , GameConfGetKeyValue    },
+	{ "GameConfGetAddress"    , GameConfGetAddress     },
+	{ "CloseGameConfigFile"   , CloseGameConfigFile    },
+	{ nullptr                 , nullptr                }
+};

amxmodx/gameconfigs.h

@@ -0,0 +1,18 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "IGameConfigs.h"
+#include "natives_handles.h"
+
+struct GameConfigNative
+{
+	IGameConfig *m_config;
+};
+
+extern NativeHandle<GameConfigNative> GameConfigHandle;

amxmodx/helpers-x86.asm

@@ -0,0 +1,52 @@
+; vim: set ts=4 sw=4 tw=99 noet ft=nasm:
+;
+; AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+; Copyright (C) The AMX Mod X Development Team.
+;
+; This software is licensed under the GNU General Public License, version 3 or higher.
+; Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+;     https://alliedmods.net/amxmodx-license
+
+section .text
+
+global amxx_CpuSupport, _amxx_CpuSupport
+
+amxx_CpuSupport:
+_amxx_CpuSupport:
+	push	ebp
+	mov		ebp, esp
+	
+	push	ebx
+	
+	mov		eax, 0
+	cpuid
+	cmp		eax, 1
+	jl		.fail
+	
+	mov		eax, 1
+	cpuid
+	;check if family == 5 or 4
+	and		eax, 0780h	;family mask
+	shr		eax, 7		;family shift
+	cmp		eax, 5
+	je		.fail
+	cmp		eax, 4
+	je		.fail
+	;check if CMOV exists
+	shr		edx, 15
+	and		edx, 1
+	cmp		edx, 0
+	je		.fail
+	
+	mov		eax, 1
+	jmp		.end
+
+.fail:
+	xor		eax, eax
+	
+.end:
+	
+	pop		ebx
+
+	pop		ebp
+	ret

amxmodx/libraries.cpp

@@ -0,0 +1,252 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "libraries.h"
+#include "sh_list.h"
+
+List<Library *> g_libraries;
+
+bool AddLibrary(const char *name, LibType type, LibSource src, void *parent)
+{
+	if (FindLibrary(name, type))
+		return false;
+
+	Library *lib = new Library;
+
+	lib->name = name;
+	lib->type = type;
+	lib->src = src;
+	lib->parent = parent;
+
+	g_libraries.push_back(lib);
+	
+	return true;
+}
+
+bool DecodeLibCmdString(const char *str, LibDecoder *dec)
+{
+	if (dec->buffer)
+	{
+		free(dec->buffer);
+		dec->buffer = NULL;
+	}
+	if (str[0] != '?')
+	{
+		return false;
+	} else {
+		str++;
+		if (*str == 'r')
+		{
+			str++;
+			if (*str == 'c')
+				dec->cmd = LibCmd_ReqClass;
+			else if (*str == 'l')
+				dec->cmd = LibCmd_ReqLib;
+			else
+				return false;
+			str++;
+		} else if (*str == 'f') {
+			str++;
+			dec->cmd = LibCmd_ForceLib;
+		} else if (*str == 'e') {
+			str++;
+			if (*str == 'c')
+				dec->cmd = LibCmd_ExpectClass;
+			else if (*str == 'l')
+				dec->cmd = LibCmd_ExpectLib;
+			else
+				return false;
+			str++;
+		} else if (*str == 'd') {
+			str++;
+			dec->cmd = LibCmd_DefaultLib;
+		}
+		if (*str != '_')
+			return false;
+		str++;
+		if (dec->cmd < LibCmd_ExpectLib)
+		{
+			dec->buffer = strdup(str);
+			dec->param1 = dec->buffer;
+			dec->param2 = NULL;
+		} else {
+			dec->buffer = strdup(str);
+			char *p = strchr(dec->buffer, '_');
+			while (p && (*(p+1) == '_'))
+				p = strchr(p+2, '_');
+			if (!p || !*(p+1))
+				return false;
+			*p = '\0';
+			dec->param1 = dec->buffer;
+			dec->param2 = p+1;
+		}
+	}
+
+	return true;
+}
+
+size_t AddLibrariesFromString(const char *name, LibType type, LibSource src, void *parent)
+{
+	char buffer[255];
+	char *ptr, *p, s;
+	size_t count = 0;
+
+	ke::SafeSprintf(buffer, sizeof(buffer), "%s", name);
+
+	ptr = buffer;
+	p = buffer;
+	while (*p)
+	{
+		while (*p && (*p != ','))
+			p++;
+		s = *p;
+		*p = '\0';
+		if (AddLibrary(ptr, type, src, parent))
+			count++;
+		if (!s)
+			break;
+		p++;
+		while (*p && (*p == ','))
+			p++;
+		ptr = p;
+	}
+
+	return count;
+}
+
+size_t ClearLibraries(LibSource src)
+{
+	List<Library *>::iterator iter;
+	size_t count = 0;
+
+	iter = g_libraries.begin();
+	while (iter != g_libraries.end())
+	{
+		if ( (*iter)->src == src )
+		{
+			delete (*iter);
+			iter = g_libraries.erase(iter);
+			count++;
+		} else {
+			iter++;
+		}
+	}
+
+	return count;
+}
+
+size_t RemoveLibraries(void *parent)
+{
+	List<Library *>::iterator iter;
+	Library *lib;
+	size_t count = 0;
+
+	iter = g_libraries.begin();
+	while (iter != g_libraries.end())
+	{
+		lib = (*iter);
+		if (lib->parent == parent)
+		{
+			delete (*iter);
+			iter = g_libraries.erase(iter);
+			count++;
+		} else {
+			iter++;
+		}
+	}
+
+	return count;
+}
+
+bool FindLibrary(const char *name, LibType type)
+{
+	List<Library *>::iterator iter;
+	Library *lib;
+
+	for (iter = g_libraries.begin(); iter != g_libraries.end(); iter++)
+	{
+		lib = (*iter);
+		if (lib->type != type)
+			continue;
+		if (strcasecmp(lib->name.chars(), name) == 0)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+LibError RunLibCommand(const LibDecoder *enc)
+{
+	List<Library *>::iterator iter,end;
+	Library *lib;
+	
+	iter = g_libraries.begin();
+	end = g_libraries.end();
+
+	if ( (enc->cmd == LibCmd_ReqLib) || (enc->cmd == LibCmd_ReqClass) )
+	{
+		LibType expect = LibType_Library;
+
+		if (enc->cmd == LibCmd_ReqLib)
+			expect = LibType_Library;
+		else if (enc->cmd == LibCmd_ReqClass)
+			expect = LibType_Class;
+
+		/** see if it exists */
+		for (; iter != end; iter++)
+		{
+			lib = (*iter);
+			if (lib->type != expect)
+				continue;
+			if (strcasecmp(lib->name.chars(), enc->param1) == 0)
+				return LibErr_None;
+		}
+		if (expect == LibType_Library)
+			return LibErr_NoLibrary;
+		else if (expect == LibType_Class)
+			return LibErr_NoClass;
+
+		return LibErr_NoLibrary;
+	} else if (enc->cmd == LibCmd_ForceLib) {
+		if (!LoadModule(enc->param1, PT_ANYTIME, true, true))
+		{
+			return LibErr_NoLibrary;
+		}
+	} else if ( (enc->cmd == LibCmd_DefaultLib) || 
+				((enc->cmd == LibCmd_ExpectLib) || (enc->cmd == LibCmd_ExpectClass)) )
+	{
+		LibType expect;
+
+		if (enc->cmd == LibCmd_ExpectLib)
+			expect = LibType_Library;
+		else
+			expect = LibType_Class;
+
+		/** see if it exists */
+		for (; iter != end; iter++)
+		{
+			lib = (*iter);
+			if (lib->type != expect)
+				continue;
+			if (strcasecmp(lib->name.chars(), enc->param1) == 0)
+				return LibErr_None;
+		}
+
+		if (!LoadModule(enc->param2, PT_ANYTIME, true, true))
+		{
+			return LibErr_NoLibrary;
+		}
+
+		return LibErr_None;
+	}
+
+	return LibErr_None;
+}

amxmodx/libraries.h

@@ -0,0 +1,81 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef _INCLUDE_LIBRARIES_H
+#define _INCLUDE_LIBRARIES_H
+
+#include <string.h>
+#include "amxmodx.h"
+
+enum LibSource
+{
+	LibSource_Plugin,
+	LibSource_Module
+};
+
+enum LibType
+{
+	LibType_Library,
+	LibType_Class
+};
+
+struct Library
+{
+	ke::AString name;
+	LibSource src;
+	LibType type;
+	void *parent;
+};
+
+enum LibCmd
+{
+	LibCmd_ReqLib,
+	LibCmd_ReqClass,
+	LibCmd_ForceLib,
+	LibCmd_ExpectLib,
+	LibCmd_ExpectClass,
+	LibCmd_DefaultLib,
+};
+
+enum LibError
+{
+	LibErr_None = 0,
+	LibErr_NoLibrary,
+	LibErr_NoClass,
+};
+
+class LibDecoder
+{
+public:
+	LibDecoder() : buffer(NULL)
+	{
+	}
+	~LibDecoder()
+	{
+		free(buffer);
+		buffer = NULL;
+		param1 = NULL;
+		param2 = NULL;
+	}
+	char *buffer;
+	char *param1;
+	char *param2;
+	LibCmd cmd;
+};
+
+bool AddLibrary(const char *name, LibType type, LibSource src, void *parent=NULL);
+bool DecodeLibCmdString(const char *str, LibDecoder *cmd);
+size_t AddLibrariesFromString(const char *name, LibType type, LibSource src, void *parent=NULL);
+size_t ClearLibraries(LibSource src);
+LibError RunLibCommand(const LibDecoder *enc);
+size_t RemoveLibraries(void *parent);
+bool FindLibrary(const char *name, LibType type);
+
+
+#endif //_INCLUDE_LIBRARIES_H

amxmodx/md5.cpp

@@ -1,474 +0,0 @@
-// MD5.CC - source code for the C++/object oriented translation and 
-//          modification of MD5.
-
-// Translation and modification (c) 1995 by Mordechai T. Abzug 
-
-// This translation/ modification is provided "as is," without express or 
-// implied warranty of any kind.
-
-// The translator/ modifier does not claim (1) that MD5 will do what you think 
-// it does; (2) that this translation/ modification is accurate; or (3) that 
-// this software is "merchantible."  (Language for this disclaimer partially 
-// copied from the disclaimer below).
-
-/* based on:
-
-   MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
-   MDDRIVER.C - test driver for MD2, MD4 and MD5
-
-
-   Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
-rights reserved.
-
-License to copy and use this software is granted provided that it
-is identified as the "RSA Data Security, Inc. MD5 Message-Digest
-Algorithm" in all material mentioning or referencing this software
-or this function.
-
-License is also granted to make and use derivative works provided
-that such works are identified as "derived from the RSA Data
-Security, Inc. MD5 Message-Digest Algorithm" in all material
-mentioning or referencing the derived work.
-
-RSA Data Security, Inc. makes no representations concerning either
-the merchantability of this software or the suitability of this
-software for any particular purpose. It is provided "as is"
-without express or implied warranty of any kind.
-
-These notices must be retained in any copies of any part of this
-documentation and/or software.
-
- */
-
-#include "md5.h"
-
-#include <assert.h>
-#include <string.h>
-
-// MD5 simple initialization method
-
-MD5::MD5(){
-
-  init();
-
-}
-
-
-// MD5 block update operation. Continues an MD5 message-digest
-// operation, processing another message block, and updating the
-// context.
-
-void MD5::update (uint1 *input, uint4 input_length) {
-
-  uint4 input_index, buffer_index;
-  uint4 buffer_space;                // how much space is left in buffer
-
-  if (finalized){  // so we can't update!
-    /*cerr << "MD5::update:  Can't update a finalized digest!" << endl;*/
-    return;
-  }
-
-  // Compute number of bytes mod 64
-  buffer_index = (unsigned int)((count[0] >> 3) & 0x3F);
-
-  // Update number of bits
-  if (  (count[0] += ((uint4) input_length << 3))<((uint4) input_length << 3) )
-    count[1]++;
-
-  count[1] += ((uint4)input_length >> 29);
-
-
-  buffer_space = 64 - buffer_index;  // how much space is left in buffer
-
-  // Transform as many times as possible.
-  if (input_length >= buffer_space) { // ie. we have enough to fill the buffer
-    // fill the rest of the buffer and transform
-    memcpy (buffer + buffer_index, input, buffer_space);
-    transform (buffer);
-
-    // now, transform each 64-byte piece of the input, bypassing the buffer
-    for (input_index = buffer_space; input_index + 63 < input_length; 
-	 input_index += 64)
-      transform (input+input_index);
-
-    buffer_index = 0;  // so we can buffer remaining
-  }
-  else
-    input_index=0;     // so we can buffer the whole input
-
-
-  // and here we do the buffering:
-  memcpy(buffer+buffer_index, input+input_index, input_length-input_index);
-}
-
-
-
-// MD5 update for files.
-// Like above, except that it works on files (and uses above as a primitive.)
-
-void MD5::update(FILE *file){
-
-  unsigned char buffer[1024];
-  int len;
-
-  while (len=fread(buffer, 1, 1024, file))
-    update(buffer, len);
-
-  fclose (file);
-
-}
-
-
-// MD5 finalization. Ends an MD5 message-digest operation, writing the
-// the message digest and zeroizing the context.
-
-
-void MD5::finalize (){
-
-  unsigned char bits[8];
-  unsigned int index, padLen;
-  static uint1 PADDING[64]={
-    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    };
-
-  if (finalized){
-   /* cerr << "MD5::finalize:  Already finalized this digest!" << endl;*/
-    return;
-  }
-
-  // Save number of bits
-  encode (bits, count, 8);
-
-  // Pad out to 56 mod 64.
-  index = (uint4) ((count[0] >> 3) & 0x3f);
-  padLen = (index < 56) ? (56 - index) : (120 - index);
-  update (PADDING, padLen);
-
-  // Append length (before padding)
-  update (bits, 8);
-
-  // Store state in digest
-  encode (digest, state, 16);
-
-  // Zeroize sensitive information
-  memset (buffer, 0, sizeof(*buffer));
-
-  finalized=1;
-
-}
-
-
-
-
-MD5::MD5(FILE *file){
-
-  init();  // must be called be all constructors
-  update(file);
-  finalize ();
-}
-
-unsigned char *MD5::raw_digest(){
-
-  uint1 *s = new uint1[16];
-
-  if (!finalized){
-/*    cerr << "MD5::raw_digest:  Can't get digest if you haven't "<<
-      "finalized the digest!" <<endl;*/
-    return ( (unsigned char*) "");
-  }
-
-  memcpy(s, digest, 16);
-  return s;
-}
-
-
-
-char *MD5::hex_digest(){
-
-  int i;
-  char *s= new char[33];
-
-  if (!finalized){
-/*    cerr << "MD5::hex_digest:  Can't get digest if you haven't "<<
-      "finalized the digest!" <<endl;*/
-    return "";
-  }
-
-  for (i=0; i<16; i++)
-    sprintf(s+i*2, "%02x", digest[i]);
-
-  s[32]='\0';
-
-  return s;
-}
-
-
-char *MD5::hex_digest(char buffer[33]){
-
-  int i;
-
-  if (!finalized)
-  {
-	 /* cerr << "MD5::hex_digest:  Can't get digest if you haven't "<<
-      "finalized the digest!" <<endl;*/
-    return "";
-  }
-
-  for (i=0; i<16; i++)
-    sprintf(buffer+i*2, "%02x", digest[i]);
-
-  buffer[32]='\0';
-
-  return buffer;
-}
-
-
-// PRIVATE METHODS:
-
-
-
-void MD5::init(){
-  finalized=0;  // we just started!
-
-  // Nothing counted, so count=0
-  count[0] = 0;
-  count[1] = 0;
-
-  // Load magic initialization constants.
-  state[0] = 0x67452301;
-  state[1] = 0xefcdab89;
-  state[2] = 0x98badcfe;
-  state[3] = 0x10325476;
-}
-
-
-
-// Constants for MD5Transform routine.
-// Although we could use C++ style constants, defines are actually better,
-// since they let us easily evade scope clashes.
-
-#define S11 7
-#define S12 12
-#define S13 17
-#define S14 22
-#define S21 5
-#define S22 9
-#define S23 14
-#define S24 20
-#define S31 4
-#define S32 11
-#define S33 16
-#define S34 23
-#define S41 6
-#define S42 10
-#define S43 15
-#define S44 21
-
-
-
-
-// MD5 basic transformation. Transforms state based on block.
-void MD5::transform (uint1 block[64]){
-
-  uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
-
-  decode (x, block, 64);
-
-  assert(!finalized);  // not just a user error, since the method is private
-
-  /* Round 1 */
-  FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
-  FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
-  FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
-  FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
-  FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
-  FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
-  FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
-  FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
-  FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
-  FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
-  FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
-  FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
-  FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
-  FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
-  FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
-  FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
-
- /* Round 2 */
-  GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
-  GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
-  GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
-  GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
-  GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
-  GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
-  GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
-  GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
-  GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
-  GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
-  GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
-  GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
-  GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
-  GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
-  GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
-  GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
-
-  /* Round 3 */
-  HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
-  HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
-  HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
-  HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
-  HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
-  HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
-  HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
-  HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
-  HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
-  HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
-  HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
-  HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
-  HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
-  HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
-  HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
-  HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
-
-  /* Round 4 */
-  II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
-  II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
-  II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
-  II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
-  II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
-  II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
-  II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
-  II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
-  II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
-  II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
-  II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
-  II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
-  II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
-  II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
-  II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
-  II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
-
-  state[0] += a;
-  state[1] += b;
-  state[2] += c;
-  state[3] += d;
-
-  // Zeroize sensitive information.
-  memset ( (uint1 *) x, 0, sizeof(x));
-
-}
-
-
-
-// Encodes input (UINT4) into output (unsigned char). Assumes len is
-// a multiple of 4.
-void MD5::encode (uint1 *output, uint4 *input, uint4 len) {
-
-  unsigned int i, j;
-
-  for (i = 0, j = 0; j < len; i++, j += 4) {
-    output[j]   = (uint1)  (input[i] & 0xff);
-    output[j+1] = (uint1) ((input[i] >> 8) & 0xff);
-    output[j+2] = (uint1) ((input[i] >> 16) & 0xff);
-    output[j+3] = (uint1) ((input[i] >> 24) & 0xff);
-  }
-}
-
-
-
-
-// Decodes input (unsigned char) into output (UINT4). Assumes len is
-// a multiple of 4.
-void MD5::decode (uint4 *output, uint1 *input, uint4 len){
-
-  unsigned int i, j;
-
-  for (i = 0, j = 0; j < len; i++, j += 4)
-    output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
-      (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
-}
-
-
-
-
-
-// Note: Replace "for loop" with standard memcpy if possible.
-void MD5::memcpy (uint1 *output, uint1 *input, uint4 len){
-
-  unsigned int i;
-
-  for (i = 0; i < len; i++)
-    output[i] = input[i];
-}
-
-
-
-// Note: Replace "for loop" with standard memset if possible.
-void MD5::memset (uint1 *output, uint1 value, uint4 len){
-
-  unsigned int i;
-
-  for (i = 0; i < len; i++)
-    output[i] = value;
-}
-
-
-
-// ROTATE_LEFT rotates x left n bits.
-
-inline unsigned int MD5::rotate_left  (uint4 x, uint4 n){
-  return (x << n) | (x >> (32-n))  ;
-}
-
-
-
-
-// F, G, H and I are basic MD5 functions.
-
-inline unsigned int MD5::F            (uint4 x, uint4 y, uint4 z){
-  return (x & y) | (~x & z);
-}
-
-inline unsigned int MD5::G            (uint4 x, uint4 y, uint4 z){
-  return (x & z) | (y & ~z);
-}
-
-inline unsigned int MD5::H            (uint4 x, uint4 y, uint4 z){
-  return x ^ y ^ z;
-}
-
-inline unsigned int MD5::I            (uint4 x, uint4 y, uint4 z){
-  return y ^ (x | ~z);
-}
-
-
-
-// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
-// Rotation is separate from addition to prevent recomputation.
-
-
-inline void MD5::FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
-		    uint4  s, uint4 ac){
- a += F(b, c, d) + x + ac;
- a = rotate_left (a, s) +b;
-}
-
-inline void MD5::GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
-		    uint4 s, uint4 ac){
- a += G(b, c, d) + x + ac;
- a = rotate_left (a, s) +b;
-}
-
-inline void MD5::HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
-		    uint4 s, uint4 ac){
- a += H(b, c, d) + x + ac;
- a = rotate_left (a, s) +b;
-}
-
-inline void MD5::II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
-			     uint4 s, uint4 ac){
- a += I(b, c, d) + x + ac;
- a = rotate_left (a, s) +b;
-}

amxmodx/md5.h

@@ -1,105 +0,0 @@
-// MD5.CC - source code for the C++/object oriented translation and 
-//          modification of MD5.
-
-// Translation and modification (c) 1995 by Mordechai T. Abzug 
-
-// This translation/ modification is provided "as is," without express or 
-// implied warranty of any kind.
-
-// The translator/ modifier does not claim (1) that MD5 will do what you think 
-// it does; (2) that this translation/ modification is accurate; or (3) that 
-// this software is "merchantible."  (Language for this disclaimer partially 
-// copied from the disclaimer below).
-
-/* based on:
-
-   MD5.H - header file for MD5C.C
-   MDDRIVER.C - test driver for MD2, MD4 and MD5
-
-   Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
-rights reserved.
-
-License to copy and use this software is granted provided that it
-is identified as the "RSA Data Security, Inc. MD5 Message-Digest
-Algorithm" in all material mentioning or referencing this software
-or this function.
-
-License is also granted to make and use derivative works provided
-that such works are identified as "derived from the RSA Data
-Security, Inc. MD5 Message-Digest Algorithm" in all material
-mentioning or referencing the derived work.
-
-RSA Data Security, Inc. makes no representations concerning either
-the merchantability of this software or the suitability of this
-software for any particular purpose. It is provided "as is"
-without express or implied warranty of any kind.
-
-These notices must be retained in any copies of any part of this
-documentation and/or software.
-
-*/
-
-#include <stdio.h>
-//#include <fstream.h>
-//#include <iostream.h>
-
-class MD5 {
-
-public:
-// methods for controlled operation:
-  MD5              ();  // simple initializer
-  void  update     (unsigned char *input, unsigned int input_length);
-  void  update     (FILE *file);
-  void  finalize   ();
-
-// constructors for special circumstances.  All these constructors finalize
-// the MD5 context.
-  MD5              (unsigned char *string); // digest string, finalize
-  MD5              (FILE *file);            // digest file, close, finalize
-
-// methods to acquire finalized result
-  unsigned char    *raw_digest ();  // digest as a 16-byte binary array
-  char *            hex_digest ();  // digest as a 33-byte ascii-hex string
-  char *			hex_digest (char buffer[33]); //same as above, passing buffer
-
-
-
-private:
-
-// first, some types:
-  typedef unsigned       int uint4; // assumes integer is 4 words long
-  typedef unsigned short int uint2; // assumes short integer is 2 words long
-  typedef unsigned      char uint1; // assumes char is 1 word long
-
-// next, the private data:
-  uint4 state[4];
-  uint4 count[2];     // number of *bits*, mod 2^64
-  uint1 buffer[64];   // input buffer
-  uint1 digest[16];
-  uint1 finalized;
-
-// last, the private methods, mostly static:
-  void init             ();               // called by all constructors
-  void transform        (uint1 *buffer);  // does the real update work.  Note 
-                                          // that length is implied to be 64.
-
-  static void encode    (uint1 *dest, uint4 *src, uint4 length);
-  static void decode    (uint4 *dest, uint1 *src, uint4 length);
-  static void memcpy    (uint1 *dest, uint1 *src, uint4 length);
-  static void memset    (uint1 *start, uint1 val, uint4 length);
-
-  static inline uint4  rotate_left (uint4 x, uint4 n);
-  static inline uint4  F           (uint4 x, uint4 y, uint4 z);
-  static inline uint4  G           (uint4 x, uint4 y, uint4 z);
-  static inline uint4  H           (uint4 x, uint4 y, uint4 z);
-  static inline uint4  I           (uint4 x, uint4 y, uint4 z);
-  static inline void   FF  (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
-			    uint4 s, uint4 ac);
-  static inline void   GG  (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
-			    uint4 s, uint4 ac);
-  static inline void   HH  (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
-			    uint4 s, uint4 ac);
-  static inline void   II  (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
-			    uint4 s, uint4 ac);
-
-};

amxmodx/messages.cpp

@@ -0,0 +1,908 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#include "amxmodx.h"
+#include "messages.h"
+
+Message Msg;
+RegisteredMessage msgHooks[256];
+int msgBlocks[256] = {BLOCK_NOT};
+int msgDest;
+int msgType;
+float *msgOrigin;
+edict_t *msgpEntity;
+bool inhook = false;
+bool inblock = false;
+enginefuncs_t *g_pEngTable = NULL;
+
+void ClearMessages()
+{
+	for (size_t i=0; i<MAX_MESSAGES; i++)
+	{
+		msgHooks[i].Clear();
+		msgBlocks[i] = BLOCK_NOT;
+	}
+}
+
+Message::Message()
+{
+	m_CurParam = 0;
+}
+
+bool Message::Ready()
+{
+	if (!m_Params.length())
+		return false;
+	return true;
+}
+
+void Message::Init()
+{
+	if (!Ready())
+	{
+		msgparam *p = new msgparam;
+		m_Params.append(p);
+	}
+	m_CurParam = 0;
+}
+
+Message::~Message()
+{
+	for (size_t i=0; i<m_Params.length(); i++)
+		delete m_Params[i];
+	
+	m_Params.clear();
+}
+
+msgparam *Message::AdvPtr()
+{
+	msgparam *pParam = NULL;
+
+	if (++m_CurParam >= m_Params.length())
+	{
+		pParam = new msgparam;
+		m_Params.append(pParam);
+	} else {
+		pParam = m_Params[m_CurParam];
+	}
+
+	return pParam;
+}
+
+void Message::AddParam(const char *data, msgtype type)
+{
+	msgparam *pParam = AdvPtr();
+
+	pParam->szData = data;
+	pParam->type = type;
+}
+
+void Message::AddParam(int data, msgtype type)
+{
+	msgparam *pParam = AdvPtr();
+	
+	pParam->v.iData = data;
+	pParam->type = type;
+}
+
+void Message::AddParam(float data, msgtype type)
+{
+	msgparam *pParam = AdvPtr();
+
+	pParam->v.fData = data;
+	pParam->type = type;
+}
+
+msgtype Message::GetParamType(size_t index)
+{
+	if (index < 1 || index > m_CurParam)
+		return static_cast<msgtype>(0);
+
+	return m_Params[index]->type;
+}
+
+float Message::GetParamFloat(size_t index)
+{
+	if (index < 1 || index > m_CurParam)
+		return 0;
+
+	return m_Params[index]->v.fData;
+}
+
+const char *Message::GetParamString(size_t index)
+{
+	if (index < 1 || index > m_CurParam)
+		return 0;
+
+	return m_Params[index]->szData.chars();
+}
+
+int Message::GetParamInt(size_t index)
+{
+	if (index < 1 || index > m_CurParam)
+		return 0;
+
+	return m_Params[index]->v.iData;
+}
+
+void Message::SetParam(size_t index, float data)
+{
+	if (index < 1 || index > m_CurParam)
+		return;
+
+	m_Params[index]->v.fData = data;
+}
+
+void Message::SetParam(size_t index, int data)
+{
+	if (index < 1 || index > m_CurParam)
+		return;
+
+	m_Params[index]->v.iData = data;
+}
+
+void Message::SetParam(size_t index, const char *data)
+{
+	if (index < 1 || index > m_CurParam)
+		return;
+
+	m_Params[index]->szData = data;
+}
+
+void Message::Reset()
+{
+	m_CurParam = 0;
+}
+
+size_t Message::Params()
+{
+	return m_CurParam;
+}
+
+void Message::Send()
+{
+	msgparam *pParam = NULL;
+
+	for (size_t i=1; i<=m_CurParam; i++)
+	{
+		pParam = m_Params[i];
+		switch (pParam->type)
+		{
+		case arg_byte:
+			WRITE_BYTE(pParam->v.iData);
+			break;
+		case arg_char:
+			WRITE_CHAR(pParam->v.iData);
+			break;
+		case arg_short:
+			WRITE_SHORT(pParam->v.iData);
+			break;
+		case arg_long:
+			WRITE_LONG(pParam->v.iData);
+			break;
+		case arg_angle:
+			WRITE_ANGLE(pParam->v.fData);
+			break;
+		case arg_coord:
+			WRITE_COORD(pParam->v.fData);
+			break;
+		case arg_string:
+			WRITE_STRING(pParam->szData.chars());
+			break;
+		case arg_entity:
+			WRITE_ENTITY(pParam->v.iData);
+			break;
+		}
+	}
+}
+
+void C_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed)
+{
+	if (msgBlocks[msg_type])
+	{
+		inblock = true;
+		msgType = msg_type;
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (msgHooks[msg_type].Hooked()) {
+		inhook = true;
+		msgDest = msg_dest;
+		msgType = msg_type;
+		msgOrigin = (float *)pOrigin;
+		msgpEntity = ed;
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteByte(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_byte);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteChar(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_char);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteShort(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_short);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteLong(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_long);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteAngle(float flValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(flValue, arg_angle);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteCoord(float flValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(flValue, arg_coord);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteString(const char *sz)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(sz, arg_string);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteEntity(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_entity);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_MessageEnd(void)
+{
+	int mres = 0;
+	
+	if (inblock)
+	{
+		inblock = false;
+		if (msgBlocks[msgType] == BLOCK_ONCE)
+		{
+			msgBlocks[msgType] = BLOCK_NOT;
+		}
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+
+		mres = msgHooks[msgType].Execute((cell)msgType, (cell)msgDest, (cell)ENTINDEX(msgpEntity));
+
+		/*
+		for (i=0; i<msgHooks[msgType].size(); i++)
+		{
+				mresB = executeForwards(msgHooks[msgType].at(i), (cell)msgType, (cell)msgDest, (cell)ENTINDEX(msgpEntity));
+				if (mresB > mres)
+						mres = mresB;
+		}
+		*/
+		inhook = false;
+		if (mres & 1)
+		{
+			Msg.Reset();
+			RETURN_META(MRES_SUPERCEDE);
+		}
+
+		/* send the real message */
+		MESSAGE_BEGIN(msgDest, msgType, msgOrigin, msgpEntity);
+		Msg.Send();
+		MESSAGE_END();
+
+		/* reset */
+		Msg.Reset();
+
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+static cell _message_begin(AMX *amx, cell *params, bool useFloat) /* 4 param */
+{
+	int numparam = *params / sizeof(cell);
+	float vecOrigin[3];
+	cell *cpOrigin;
+
+	if (params[2] < 1 || ((params[2] > 63)		// maximal number of engine messages
+		&& !GET_USER_MSG_NAME(PLID, params[2], NULL)))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Plugin called message_begin with an invalid message id (%d).", params[2]);
+		return 0;
+	}
+
+	switch (params[1])
+	{
+	case MSG_BROADCAST:
+	case MSG_ALL:
+	case MSG_SPEC:
+	case MSG_INIT:
+		MESSAGE_BEGIN(params[1], params[2], NULL);
+		break;
+	case MSG_PVS: case MSG_PAS:
+	case MSG_PVS_R: case MSG_PAS_R:
+		if (numparam < 3)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid number of parameters passed");
+			return 0;
+		}
+
+		cpOrigin = get_amxaddr(amx, params[3]);
+
+		if (!useFloat)
+		{
+			vecOrigin[0] = static_cast<float>(*cpOrigin);
+			vecOrigin[1] = static_cast<float>(*(cpOrigin + 1));
+			vecOrigin[2] = static_cast<float>(*(cpOrigin + 2));
+		} else {
+			vecOrigin[0] = amx_ctof(*cpOrigin);
+			vecOrigin[1] = amx_ctof(*(cpOrigin + 1));
+			vecOrigin[2] = amx_ctof(*(cpOrigin + 2));
+		}
+
+		MESSAGE_BEGIN(params[1], params[2], vecOrigin);
+
+		break;
+	case MSG_ONE_UNRELIABLE:
+	case MSG_ONE:
+		if (numparam < 4)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid number of parameters passed");
+			return 0;
+		}
+
+		MESSAGE_BEGIN(params[1], params[2], NULL, TypeConversion.id_to_edict(params[4]));
+		break;
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL message_begin(AMX *amx, cell *params) /* 4 param */
+{
+	return _message_begin(amx, params, false);
+}
+
+static cell AMX_NATIVE_CALL message_begin_f(AMX *amx, cell *params) /* 4 param */
+{
+	return _message_begin(amx, params, true);
+}
+
+static cell AMX_NATIVE_CALL message_end(AMX *amx, cell *params)
+{
+	MESSAGE_END();
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_byte(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_BYTE(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_char(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_CHAR(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_short(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_SHORT(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_long(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_LONG(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_entity(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_ENTITY(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_angle(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_ANGLE(static_cast<float>(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_angle_f(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_ANGLE(amx_ctof(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_coord(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_COORD(static_cast<float>(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_coord_f(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_COORD(amx_ctof(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_string(AMX *amx, cell *params) /* 1 param */
+{
+	int a;
+	WRITE_STRING(get_amxstring(amx, params[1], 3, a));
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL register_message(AMX *amx, cell *params)
+{
+	int len;
+	char *name = get_amxstring(amx, params[2], 0, len);
+
+	if (!Msg.Ready())
+		Msg.Init();
+
+	if (params[1]>0 && params[1] < 256)
+	{
+		int id = registerSPForwardByName(amx, name, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+		if (id != -1)
+		{
+			msgHooks[params[1]].AddHook(id);
+			return id;
+		} else {
+			LogError(amx, AMX_ERR_NOTFOUND, "Could not find function \"%s\"", name);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+// unregister_message(msgid, msghandle)
+static cell AMX_NATIVE_CALL unregister_message(AMX *amx, cell *params)
+{
+	if (!Msg.Ready())
+		Msg.Init();
+
+	if (params[1]>0 && params[1] < 256)
+	{
+		int id = params[2];
+		if (id != -1)
+		{
+			msgHooks[params[1]].RemoveHook(id);
+			return id;
+		} else {
+			LogError(amx, AMX_ERR_NOTFOUND, "Invalid registered message handle");
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+
+static cell AMX_NATIVE_CALL set_msg_block(AMX *amx, cell *params)
+{
+	int msgid = params[1];
+	int block = params[2];
+
+	if (msgid < 1 || msgid > 255)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message id");
+		return 0;
+	}
+
+	msgBlocks[msgid] = block;
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_msg_block(AMX *amx, cell *params)
+{
+	int msgid = params[1];
+
+	if (msgid < 1 || msgid > 255)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message id");
+		return 0;
+	}
+
+	return msgBlocks[msgid];
+}
+
+static cell AMX_NATIVE_CALL get_msg_args(AMX *amx, cell *params)
+{
+	return Msg.Params();
+}
+
+static cell AMX_NATIVE_CALL get_msg_argtype(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	return Msg.GetParamType(argn);
+}
+
+static cell AMX_NATIVE_CALL get_msg_arg_int(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	return Msg.GetParamInt(argn);
+}
+
+static cell AMX_NATIVE_CALL set_msg_arg_int(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	Msg.SetParam(argn, (int)params[3]);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_msg_arg_float(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	REAL f = (REAL)Msg.GetParamFloat(argn);
+	return amx_ftoc(f);
+}
+
+static cell AMX_NATIVE_CALL set_msg_arg_float(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	REAL fVal = amx_ctof(params[3]);
+
+	Msg.SetParam(argn, (float)fVal);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_msg_arg_string(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	const char *szVal = Msg.GetParamString(argn);
+
+	return set_amxstring(amx, params[2], szVal, params[3]);
+}
+
+static cell AMX_NATIVE_CALL set_msg_arg_string(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+	int iLen;
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	char *szVal = get_amxstring(amx, params[2], 0, iLen);
+
+	Msg.SetParam(argn, szVal);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_msg_origin(AMX *amx, cell *params)
+{
+	if (!inhook)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not in a message hook");
+		return 0;
+	}
+
+	cell *cAddr = get_amxaddr(amx, params[1]);
+
+	if (msgDest >= MSG_PVS && msgDest <= MSG_PAS_R)
+	{
+		vec3_t vRet = (Vector)msgOrigin;
+		cAddr[0] = FloatToCell(vRet.x);
+		cAddr[1] = FloatToCell(vRet.y);
+		cAddr[2] = FloatToCell(vRet.z);
+	} else {
+		cAddr[0] = 0;
+		cAddr[1] = 0;
+		cAddr[2] = 0;
+	}
+
+	return 1;
+}
+
+static cell _emessage_begin(AMX *amx, cell *params, bool useFloat)
+{
+	int numparam = *params / sizeof(cell);
+	float vecOrigin[3];
+	cell *cpOrigin;
+
+	if (params[2] < 1 || ((params[2] > 63)		// maximal number of engine messages
+		&& !GET_USER_MSG_NAME(PLID, params[2], NULL)))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Plugin called message_begin with an invalid message id (%d).", params[2]);
+		return 0;
+	}
+
+	switch (params[1])
+	{
+	case MSG_BROADCAST:
+	case MSG_ALL:
+	case MSG_SPEC:
+		g_pEngTable->pfnMessageBegin(params[1], params[2], NULL, NULL);
+		break;
+	case MSG_PVS: case MSG_PAS:
+	case MSG_PVS_R: case MSG_PAS_R:
+		if (numparam < 3)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid number of parameters passed");
+			return 0;
+		}
+
+		cpOrigin = get_amxaddr(amx, params[3]);
+
+		if (!useFloat)
+		{
+			vecOrigin[0] = static_cast<float>(*cpOrigin);
+			vecOrigin[1] = static_cast<float>(*(cpOrigin + 1));
+			vecOrigin[2] = static_cast<float>(*(cpOrigin + 2));
+		} else {
+			vecOrigin[0] = amx_ctof(*cpOrigin);
+			vecOrigin[1] = amx_ctof(*(cpOrigin + 1));
+			vecOrigin[2] = amx_ctof(*(cpOrigin + 2));
+		}
+
+		g_pEngTable->pfnMessageBegin(params[1], params[2], vecOrigin, NULL);
+
+		break;
+	case MSG_ONE_UNRELIABLE:
+	case MSG_ONE:
+		if (numparam < 4)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid number of parameters passed");
+			return 0;
+		}
+
+		g_pEngTable->pfnMessageBegin(params[1], params[2], NULL, TypeConversion.id_to_edict(params[4]));
+		break;
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL emessage_begin(AMX *amx, cell *params) /* 4 param */
+{
+	return _emessage_begin(amx, params, false);
+}
+
+static cell AMX_NATIVE_CALL emessage_begin_f(AMX *amx, cell *params) /* 4 param */
+{
+	return _emessage_begin(amx, params, true);
+}
+
+static cell AMX_NATIVE_CALL emessage_end(AMX *amx, cell *params)
+{
+	g_pEngTable->pfnMessageEnd();
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_byte(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteByte(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_char(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteChar(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_short(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteShort(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_long(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteLong(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_entity(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteEntity(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_angle(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteAngle(static_cast<float>(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_angle_f(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteAngle(amx_ctof(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_coord(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteCoord(static_cast<float>(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_coord_f(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteCoord(amx_ctof(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_string(AMX *amx, cell *params) /* 1 param */
+{
+	int a;
+	g_pEngTable->pfnWriteString(get_amxstring(amx, params[1], 3, a));
+
+	return 1;
+}
+
+AMX_NATIVE_INFO msg_Natives[] =
+{
+	{"message_begin",		message_begin},
+	{"message_begin_f",		message_begin_f},
+	{"message_end",			message_end},
+	
+	{"write_angle",			write_angle},
+	{"write_angle_f",		write_angle_f},
+	{"write_byte",			write_byte},
+	{"write_char",			write_char},
+	{"write_coord",			write_coord},
+	{"write_coord_f",		write_coord_f},
+	{"write_entity",		write_entity},
+	{"write_long",			write_long},
+	{"write_short",			write_short},
+	{"write_string",		write_string},
+
+	{"register_message",	register_message},
+	{"unregister_message",	unregister_message},
+
+	{"set_msg_block",		set_msg_block},
+	{"get_msg_block",		get_msg_block},
+
+	{"get_msg_args",		get_msg_args},
+	{"get_msg_argtype",		get_msg_argtype},
+	{"get_msg_arg_int",		get_msg_arg_int},
+	{"set_msg_arg_int",		set_msg_arg_int},
+	{"get_msg_arg_float",	get_msg_arg_float},
+	{"set_msg_arg_float",	set_msg_arg_float},
+	{"get_msg_arg_string",	get_msg_arg_string},
+	{"set_msg_arg_string",	set_msg_arg_string},
+	{"get_msg_origin",		get_msg_origin},
+	
+	{"emessage_begin",		emessage_begin},
+	{"emessage_begin_f",	emessage_begin_f},
+	{"emessage_end",		emessage_end},
+	
+	{"ewrite_angle",		ewrite_angle},
+	{"ewrite_angle_f",		ewrite_angle_f},
+	{"ewrite_byte",			ewrite_byte},
+	{"ewrite_char",			ewrite_char},
+	{"ewrite_coord",		ewrite_coord},
+	{"ewrite_coord_f",		ewrite_coord_f},
+	{"ewrite_entity",		ewrite_entity},
+	{"ewrite_long",			ewrite_long},
+	{"ewrite_short",		ewrite_short},
+	{"ewrite_string",		ewrite_string},
+
+	{NULL,					NULL},
+};

amxmodx/messages.h

@@ -0,0 +1,216 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#ifndef _MSGS_INCLUDE_H
+#define _MSGS_INCLUDE_H
+
+#include <extdll.h>
+#include <meta_api.h>
+#include "amx.h"
+#include "sh_stack.h"
+
+#define MAX_MESSAGES 255
+
+#define MSGBLOCK_SET	0
+#define MSGBLOCK_GET	1
+#define BLOCK_NOT 0
+#define BLOCK_ONCE 1
+#define BLOCK_SET 2
+
+class RegisteredMessage
+{
+private:
+	ke::Vector<int> m_Forwards;
+	CStack<int> m_InExecution;
+	bool m_Cleanup;
+
+public:
+	RegisteredMessage() : m_Cleanup(false) { } 
+	~RegisteredMessage() { this->Clear(); }
+
+	void AddHook(int fwd)
+	{
+		m_Forwards.append(fwd);
+	}
+	bool RemoveHook(int fwd)
+	{
+		// Don't erase a forward if we're in the middle of execution; this
+		// could throw off the iterator that is going through the forwards
+		// and executing them.  Instead, unregister the forward and set it
+		// to -1 from within the vector.
+		if (m_InExecution.size())
+		{
+			this->m_Cleanup = true;
+
+			for (size_t i = 0; i < m_Forwards.length(); ++i)
+			{
+				int& forward = m_Forwards[i];
+
+				if (forward == fwd)
+				{
+					if (forward != -1)
+					{
+						unregisterSPForward(forward);
+					}
+
+					forward = -1;
+
+					return true;
+				}
+			}
+		}
+		else
+		{
+			for (size_t i = 0; i < m_Forwards.length(); ++i)
+			{
+				int forward = m_Forwards[i];
+
+				if (forward == fwd)
+				{
+					if (forward != -1)
+					{
+						unregisterSPForward(forward);
+
+						m_Forwards.remove(forward);
+
+						return true;
+					}
+					else
+					{
+						// -1 could be in here more than once
+						m_Forwards.remove(forward);
+					}
+				}
+			}
+		}
+
+		return false;
+	}
+
+	void Clear()
+	{
+		while (m_InExecution.size())
+		{
+			m_InExecution.pop();
+		}
+		for (size_t i = 0; i < m_Forwards.length(); i++)
+		{
+			int fwd = m_Forwards[i];
+
+			if (fwd != -1)
+			{
+				unregisterSPForward(m_Forwards[i]);
+			}
+		}
+
+		m_Forwards.clear();
+	}
+
+	cell Execute(cell type, cell dest, cell entity)
+	{
+		m_InExecution.push(1);
+		cell res = 0;
+		cell thisres = 0;
+		for (size_t i = 0; i < m_Forwards.length(); i++)
+		{
+			int fwd = m_Forwards[i];
+
+			if (fwd != -1)
+			{
+				thisres = executeForwards(fwd, type, dest, entity);
+				if (thisres > res)
+				{
+					res = thisres;
+				}
+
+			}
+		}
+
+		m_InExecution.pop();
+
+		if (m_InExecution.size() == 0 && m_Cleanup)
+		{
+			this->RemoveHook(-1);
+		}
+
+		return res;
+	}
+	bool Hooked() const
+	{
+		return m_Forwards.length() != 0;
+	}
+};
+enum msgtype
+{
+	arg_byte = 1,
+	arg_char,
+	arg_short,
+	arg_long,
+	arg_angle,
+	arg_coord,
+	arg_string,
+	arg_entity,
+};
+
+struct msgparam
+{
+	msgtype type;
+	union
+	{
+		REAL fData;
+		int iData;
+	} v;
+	ke::AString szData;
+};
+
+class Message
+{
+public:
+	Message();
+	~Message();
+	void AddParam(float data, msgtype type);
+	void AddParam(int data, msgtype type);
+	void AddParam(const char *data, msgtype type);
+	void SetParam(size_t index, float data);
+	void SetParam(size_t index, int data);
+	void SetParam(size_t index, const char *data);
+	const char *GetParamString(size_t index);
+	float GetParamFloat(size_t index);
+	bool Ready();
+	void Init();
+	int GetParamInt(size_t index);
+	msgtype GetParamType(size_t index);
+	void Reset();
+	void Send();
+	size_t Params();
+private:
+	msgparam *AdvPtr();
+private:
+	ke::Vector<msgparam *> m_Params;
+	size_t m_CurParam;
+};
+
+void C_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+void C_WriteByte(int iValue);
+void C_WriteChar(int iValue);
+void C_WriteShort(int iValue);
+void C_WriteLong(int iValue);
+void C_WriteAngle(float flValue);
+void C_WriteCoord(float flValue);
+void C_WriteString(const char *sz);
+void C_WriteEntity(int iValue);
+void C_MessageEnd(void);
+
+extern RegisteredMessage msgHooks[256];
+extern int msgBlocks[256];
+
+void ClearMessages();
+
+#endif //_MSGS_INCLUDE_H
+